diff --git a/apps/site/app/components/registerCatalogBlocks.ts b/apps/site/app/components/registerCatalogBlocks.ts
index 7cd388428..97d3ae303 100644
--- a/apps/site/app/components/registerCatalogBlocks.ts
+++ b/apps/site/app/components/registerCatalogBlocks.ts
@@ -19,34 +19,110 @@
  * nothing else. `PluginLoader` covers the individual docs pages that embed a
  * demo, but the gallery embeds EVERY example and never wraps them in one.
  *
- * Measured on `origin/main` before this file: all 9 `plugin-dashboard` entries
- * rendered the registry's red "Unknown component type: dashboard (OBJUI-001)"
- * panel in the gallery — not the dashboard, and not the retired-widget
- * placeholder that the entries produce once the plugin IS loaded. This is the
- * objectui#3787 defect one layer up: there it was `page-header` resolving to
- * nothing, here it is the whole `dashboard` block.
+ * ## Why the list is the WHOLE bucket census, not two packages (objectui#4616)
  *
- * `@object-ui/plugin-charts` comes with it because it owns `chart` — what a
- * dashboard's widgets (static, provider-backed and dataset-bound alike) draw
- * with, and the root type of the `plugin-charts/*` catalog entries.
+ * #4600 registered only the two packages its own category needed. Measured on
+ * `origin/main` @ `e028dfcd8` — every one of the 423 catalog entries rendered
+ * the way `SchemaThumbnail` renders it — that left **33 entries** still
+ * painting the registry's red "Unknown component type … (OBJUI-001)" panel, in
+ * 14 categories:
+ *
+ *   components-form-calendar 6 (calendar)   plugin-chatbot 3 (chatbot)
+ *   plugin-editor 3 (code-editor)           plugin-gantt 3 (object-gantt)
+ *   plugin-map 3 (object-map)               plugin-markdown 3 (markdown)
+ *   plugin-timeline 3 (timeline)            plugin-calendar 2 (calendar-view)
+ *   plugin-kanban 2 (kanban)                components-complex-filter-ui 1
+ *   components-complex-sort-ui 1            components-complex-view-switcher 1
+ *   components-disclosure-toggle-group 1    core-schema-renderer 1
+ *
+ * The gallery page's PURPOSE is to render the whole catalog, so its baseline is
+ * that every type an entry names is registered before the render. The nine
+ * imports below are exactly the packages that census resolves to — not a
+ * precautionary sweep of the workspace.
+ *
+ * ## The cost, measured before deciding (objectui#4616 ruling 1)
+ *
+ * Eager registration pulls each package's graph into the `/docs/[[...slug]]`
+ * route — and that route is shared by all 181 docs pages, not just the gallery
+ * (measured: `/docs/guide/schema-catalog` and `/docs/guide/architecture` load
+ * an identical chunk set, and `SchemaThumbnail`'s own code sits in one of
+ * them). So the cost had to be measured, not assumed. Next 16.3 + Turbopack
+ * prints no "Size / First Load JS" columns, so the figure was reconstructed
+ * from the build on disk — the `<script src>` set of the prerendered route:
+ *
+ *   before  7738.7 kB across 29 chunks
+ *   after   9542.6 kB across 40 chunks
+ *   delta   +1803.9 kB  (+23.3%)   — the ruling's stop condition was +50%
+ *
+ * The prerender is unaffected: the build still emits 556/556 static pages, and
+ * the gallery's own HTML still carries all 440 thumbnail frames (it grew
+ * 572.1 -> 580.7 kB). `/playground`, which imports the layout registrar but not
+ * this module, is byte-identical at 6872.8 kB — the widening is confined to the
+ * docs route. Whole-app `static/chunks` did not grow at all (27582.2 ->
+ * 27517.2 kB): the plugin code was already being emitted for the docs pages
+ * that load it through `PluginLoader`, and what changed is which chunks the
+ * docs route pulls in up front.
+ *
+ * Worth knowing when re-reading this: the thumbnails themselves are
+ * NOT in that HTML — `SchemaThumbnail` gates its mount behind an
+ * `IntersectionObserver`, so the OBJUI-001 panels appeared on the client after
+ * hydration. The eagerness here is still what makes registration precede the
+ * first client render of a tile; it is not what puts a tile in the HTML.
+ *
+ * ## What this does NOT fix
+ *
+ * 31 of those 33 tiles go from the panel to a drawn component. The rest are
+ * not registration defects, so they are filed and named rather than fixed here:
+ *
+ *   objectui#4624  `components-disclosure-toggle-group/with-labels` names root
+ *                  type `single`, which no package registers.
+ *   objectui#4625  the six `components-form-calendar/*` author the bare
+ *                  `calendar` keyword, which `@object-ui/components`
+ *                  deliberately registers as `ui:calendar` only (`skipFallback`,
+ *                  "collides with the plugin-calendar full CRUD calendar VIEW")
+ *                  — so they reach `ObjectCalendar` and swap the OBJUI-001
+ *                  panel for its missing-data-source error.
+ *   objectui#4627  the two `plugin-calendar/*` entries author 2024 event dates,
+ *                  outside the window `calendar-view` paints.
+ *
+ * (`core-schema-renderer/unknown-component-type` also keeps the panel, on
+ * purpose — the panel IS that example.) Two further entries were found blank
+ * rather than red by the same sweep and filed as objectui#4626.
  *
  * EAGER, at module scope, for the same reason `./registerLayoutBlocks` is
- * eager: registration has then already happened for the server render, so the
- * thumbnails stay in the prerendered HTML instead of appearing on hydration.
- * Neither package declares `sideEffects: false`, so a bare side-effect import
- * survives bundling (checked); the layout package is the one that needs an
- * explicit call, which its own module does.
+ * eager: registration has then already happened before the first tile renders,
+ * instead of a tile painting the red panel and repainting once a lazy chunk
+ * lands. Not every package declares `sideEffects: false`, so a bare side-effect
+ * import survives bundling (checked); the layout package is the one that needs
+ * an explicit call, which its own module does.
  *
  * Deliberately NOT imported by `InteractiveDemo` / `LiveSplitDemo`: those host
  * demos on ordinary docs pages, which opt into their plugins through
- * `PluginLoader`, and making them eager would pull the chart + dashboard graphs
- * into every page carrying any demo. The gallery page's own modal preview is
- * unaffected — it renders after `SchemaThumbnail` has already registered these
- * on that page.
- *
- * Guarded by `examples/schema-catalog/test/plugin-dashboard-gallery-render.
- * test.tsx`, which mirrors this registration set and fails if this file stops
- * loading either package.
+ * `PluginLoader`, and making them eager would pull every graph below into any
+ * page carrying a demo. The gallery page's own modal preview is unaffected — it
+ * renders after `SchemaThumbnail` has already registered these on that page.
+ *
+ * IMPORT ORDER IS CONTRACT. Several packages register the same bare keyword
+ * (`chart` is claimed by plugin-charts, plugin-dashboard and plugin-report;
+ * `calendar` by plugin-calendar over `@object-ui/components`' `ui:calendar`),
+ * and the last registration of a key wins. The first two lines keep the order
+ * objectui#4600 established; the rest are appended, which is the order the
+ * census above was measured in.
+ *
+ * Guarded by two pins in `examples/schema-catalog/test/`:
+ * `plugin-dashboard-gallery-render.test.tsx` (objectui#4600, the dashboard
+ * category) and `catalog-gallery-render.test.tsx` (objectui#4616, every
+ * category), both of which mirror this list and fail if it stops loading a
+ * package.
  */
 import '@object-ui/plugin-dashboard';
 import '@object-ui/plugin-charts';
+import '@object-ui/plugin-calendar';
+import '@object-ui/plugin-chatbot';
+import '@object-ui/plugin-editor';
+import '@object-ui/plugin-gantt';
+import '@object-ui/plugin-kanban';
+import '@object-ui/plugin-map';
+import '@object-ui/plugin-markdown';
+import '@object-ui/plugin-timeline';
+import '@object-ui/plugin-view';
diff --git a/examples/schema-catalog/package.json b/examples/schema-catalog/package.json
index 8ec2d8c01..a9fea04db 100644
--- a/examples/schema-catalog/package.json
+++ b/examples/schema-catalog/package.json
@@ -33,8 +33,17 @@
     "@object-ui/core": "workspace:*",
     "@object-ui/fields": "workspace:*",
     "@object-ui/layout": "workspace:*",
+    "@object-ui/plugin-calendar": "workspace:*",
     "@object-ui/plugin-charts": "workspace:*",
+    "@object-ui/plugin-chatbot": "workspace:*",
     "@object-ui/plugin-dashboard": "workspace:*",
+    "@object-ui/plugin-editor": "workspace:*",
+    "@object-ui/plugin-gantt": "workspace:*",
+    "@object-ui/plugin-kanban": "workspace:*",
+    "@object-ui/plugin-map": "workspace:*",
+    "@object-ui/plugin-markdown": "workspace:*",
+    "@object-ui/plugin-timeline": "workspace:*",
+    "@object-ui/plugin-view": "workspace:*",
     "@object-ui/react": "workspace:*",
     "@object-ui/sdui-parser": "workspace:*",
     "typescript": "^6.0.3"
diff --git a/examples/schema-catalog/test/catalog-gallery-render.test.tsx b/examples/schema-catalog/test/catalog-gallery-render.test.tsx
new file mode 100644
index 000000000..81537225b
--- /dev/null
+++ b/examples/schema-catalog/test/catalog-gallery-render.test.tsx
@@ -0,0 +1,557 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * objectui#4616 — EVERY catalog entry is rendered the way the docs gallery
+ * renders it, and no tile may show the registry's "Unknown component type"
+ * panel or the renderer's error boundary.
+ *
+ * ## What this generalizes
+ *
+ * `plugin-dashboard-gallery-render.test.tsx` (objectui#4600) pinned one
+ * category. It closed the blind spot for that category and left the rest of the
+ * corpus in it: `smoke.test.tsx` has no `render(` call at all (its assertions
+ * are structural — every entry is an object with a non-empty `type`) and
+ * `plugin-dashboard-global-filters-spec.test.ts` (objectui#4356) validates
+ * `globalFilters` against the spec without rendering. Both are satisfied by an
+ * entry that renders nothing but a red error box.
+ *
+ * Measured on `origin/main` @ `e028dfcd8`, rendering all 423 entries against
+ * the gallery's registration set as it stood after #4600 — 33 entries painted
+ * the OBJUI-001 panel:
+ *
+ *   components-form-calendar 6 (calendar)   plugin-chatbot 3 (chatbot)
+ *   plugin-editor 3 (code-editor)           plugin-gantt 3 (object-gantt)
+ *   plugin-map 3 (object-map)               plugin-markdown 3 (markdown)
+ *   plugin-timeline 3 (timeline)            plugin-calendar 2 (calendar-view)
+ *   plugin-kanban 2 (kanban)                components-complex-filter-ui 1
+ *   components-complex-sort-ui 1            components-complex-view-switcher 1
+ *   components-disclosure-toggle-group 1    core-schema-renderer 1
+ *
+ * That is the red this file was written against. `apps/site/app/components/
+ * registerCatalogBlocks.ts` now loads the nine further packages that census
+ * resolves to, which takes 31 of those 33 tiles from the panel to a drawn
+ * component. What registration cannot reach is named — never skipped silently —
+ * in the tables below. Four classes are defects in the entries, one issue each:
+ *
+ *   objectui#4624  1 entry  names root type "single", which nothing registers
+ *   objectui#4625  6 entries author the bare `calendar` keyword, which belongs
+ *                          to plugin-calendar's data-bound ObjectCalendar
+ *   objectui#4626  2 entries render a blank tile — each authors a key its own
+ *                          renderer never reads (found by the control below)
+ *   objectui#4627  2 entries author 2024 event dates, outside the window
+ *                          `calendar-view` paints
+ *
+ * #4625 is the reason this file asserts three diagnostic strings rather than
+ * one: registering a package is not the same as a tile drawing, and a pin that
+ * named only OBJUI-001 would have reported those six as fixed.
+ *
+ * Six further entries are not rendered here at all, for reasons that are limits
+ * of the environment rather than defects in anything: `plugin-editor`'s three
+ * mount Monaco and `plugin-map`'s three mount maplibre, which between them want
+ * a CDN loader script, WebGL2, and a live third-party tile host. The exclusion
+ * table says why for each; what stays pinned for both buckets is the thing
+ * objectui#4616 actually changed — that their types resolve — asserted in the
+ * control case below.
+ *
+ * ## Why the module-scope package imports
+ *
+ * `ComponentRegistry` only knows a type once the package owning it has loaded,
+ * so this file mirrors exactly what the gallery host registers, in the same
+ * order — several packages claim the same bare keyword (`chart`, `calendar`)
+ * and the last registration wins, so a reordered mirror would not be a mirror.
+ * The last case in this file reads the host and fails if the two lists drift.
+ *
+ * ## What is asserted, per entry
+ *
+ * None of the three diagnostics, and — the non-vacuity half, since an entry
+ * that renders nothing at all trivially satisfies all three — the tile actually
+ * produced DOM or text of its own. That control is not decoration: it is what
+ * found objectui#4626's two blank tiles, which no red-tile sweep can see. For
+ * the categories objectui#4616 newly registered, a stronger positive control on
+ * top: the titles the entry itself authors are on screen
+ * (`AUTHORED_TEXT_EXEMPT` records the two that cannot be asserted that way,
+ * with the reason).
+ *
+ * The diagnostic strings are COPIED as literals rather than imported from the
+ * packages' internals, for the reason objectui#4600 gave: they are
+ * user-visible contract for this pin, and a reworded panel should turn it red
+ * for review rather than silently follow along.
+ *
+ * `role="alert"` is deliberately NOT asserted category-wide the way #4600
+ * asserts it for dashboards. Measured: `components-data-display-alert`'s two
+ * entries render `role="alert"` because that is what an Alert IS — the
+ * assertion is correct for a dashboard tile and wrong for the corpus.
+ */
+import { describe, it, expect } from 'vitest';
+import { render, waitFor } from '@testing-library/react';
+import '@object-ui/components';
+// Mirrors apps/site/app/components/registerCatalogBlocks.ts, in its order.
+import '@object-ui/plugin-dashboard';
+import '@object-ui/plugin-charts';
+import '@object-ui/plugin-calendar';
+import '@object-ui/plugin-chatbot';
+import '@object-ui/plugin-editor';
+import '@object-ui/plugin-gantt';
+import '@object-ui/plugin-kanban';
+import '@object-ui/plugin-map';
+import '@object-ui/plugin-markdown';
+import '@object-ui/plugin-timeline';
+import '@object-ui/plugin-view';
+import { SidebarProvider } from '@object-ui/components';
+import { registerLayout } from '@object-ui/layout';
+import { ComponentRegistry } from '@object-ui/core';
+import { SchemaRenderer, SchemaRendererContext, toRenderableSchema } from '@object-ui/react';
+import fs from 'node:fs';
+import path from 'node:path';
+import { allExamples } from '../src/index.js';
+
+registerLayout();
+
+/** The registry's panel for a type no loaded package registers (OBJUI-001). */
+const UNKNOWN_COMPONENT = 'Unknown component type';
+/** `SchemaRenderer`'s error boundary (packages/react/src/SchemaRenderer.tsx). */
+const FAILED_TO_RENDER = 'failed to render';
+/**
+ * The data-bound plugins' guard when the host supplies no data source
+ * (`ObjectCalendar.tsx`, `ObjectGantt.tsx`, `ObjectMap.tsx` all throw it).
+ * Asserted alongside the other two because registering a package is not the
+ * same as the tile drawing: `components-form-calendar/*` trades the OBJUI-001
+ * panel for exactly this string, and a pin that named only the panel would
+ * report those six as fixed.
+ */
+const DATASOURCE_REQUIRED = 'DataSource required for object/api providers';
+
+const ALL_DIAGNOSTICS = [UNKNOWN_COMPONENT, FAILED_TO_RENDER, DATASOURCE_REQUIRED];
+
+/** The packages the gallery host must load, in the host's own order. */
+const HOST_PACKAGES = [
+  '@object-ui/plugin-dashboard',
+  '@object-ui/plugin-charts',
+  '@object-ui/plugin-calendar',
+  '@object-ui/plugin-chatbot',
+  '@object-ui/plugin-editor',
+  '@object-ui/plugin-gantt',
+  '@object-ui/plugin-kanban',
+  '@object-ui/plugin-map',
+  '@object-ui/plugin-markdown',
+  '@object-ui/plugin-timeline',
+  '@object-ui/plugin-view',
+];
+
+/**
+ * Entries this pin does NOT hold to the no-red-tile rule, each with the reason
+ * it is not a registration defect. Named here rather than skipped silently:
+ * an exclusion that stops being true should be visible to the next reader, and
+ * the case below fails if an id here no longer exists.
+ */
+const EXCLUSIONS: Record<string, string> = {
+  'core-schema-renderer/unknown-component-type':
+    'Demonstrates the OBJUI-001 panel on purpose — the panel IS the example.',
+  'components-disclosure-toggle-group/with-labels':
+    'Authoring defect, not registration: the entry names root type "single", which no ' +
+    'package registers. Its two siblings spell the same thing "toggle-group" + ' +
+    '"selectionType": "single". Filed as objectui#4624.',
+  'components-overlay-tooltip/basic-tooltip':
+    'Blank tile, not a red one, and not registration: the entry authors its trigger under ' +
+    '"children", which the tooltip renderer never reads (it reads "trigger" / "body"), so ' +
+    'the tile renders nothing at all. Filed as objectui#4626.',
+  'components-overlay-hover-card/basic-hover-card':
+    'Blank tile, not a red one, and not registration: both slots author {"type":"text", ' +
+    '"value":…} and the text renderer reads "content", so both render empty. ' +
+    'Filed as objectui#4626.',
+  // The three below are an ENVIRONMENT limit, not a defect in the entries.
+  // Rendering `code-editor` mounts `@monaco-editor/react`, which appends its
+  // loader as a `script` tag pointing at a CDN. happy-dom cannot fetch it and
+  // dispatches a resource-load `error` event, which Vitest reports as an
+  // unhandled error and exits non-zero on — while every assertion in the file
+  // passes (measured: 2534/2534 tests green, 4 unhandled errors, exit 1).
+  // `packages/plugin-editor/src/index.test.ts` reached the same place first and
+  // settled it the same way: that suite asserts registration and metadata and
+  // never renders, with a header explaining Monaco's cost. So what is pinned
+  // for this bucket is `ComponentRegistry.get('code-editor')` in the control
+  // case above — which IS what objectui#4616 changed for it.
+  'plugin-editor/javascript-editor': "Monaco's CDN loader cannot run under happy-dom.",
+  'plugin-editor/python-editor': "Monaco's CDN loader cannot run under happy-dom.",
+  'plugin-editor/read-only-json-viewer': "Monaco's CDN loader cannot run under happy-dom.",
+  // The three below are the same class as Monaco, one layer worse. Rendering
+  // `object-map` mounts maplibre, which (a) refuses to initialise without WebGL2
+  // — "WebGL2 is required to display this map", GPUInitializationError, verbatim
+  // from the run — and then trips `SchemaRenderer`'s error boundary tearing its
+  // own painter down, and (b) fetches its style sheet from
+  // `https://demotiles.maplibre.org` over the real network. (b) is the reason
+  // this is an exclusion rather than a narrowed assertion: a unit test that
+  // reaches a third-party host is nondeterministic and makes CI depend on that
+  // host being up, whatever it asserts. All five of `packages/plugin-map`'s own
+  // test files reach the same conclusion and `vi.mock('react-map-gl/maplibre')`;
+  // this pin renders the gallery's real stack, so it cannot mock and must
+  // abstain instead. `ComponentRegistry.get('object-map')` in the control case
+  // is what stays pinned — and that IS what objectui#4616 changed here.
+  'plugin-map/event-venue-finder': 'maplibre needs WebGL2 and a live tile host.',
+  'plugin-map/real-time-delivery-tracking': 'maplibre needs WebGL2 and a live tile host.',
+  'plugin-map/store-locator-map': 'maplibre needs WebGL2 and a live tile host.',
+};
+
+/**
+ * Entries allowed ONE named diagnostic, because that diagnostic is a defect
+ * this card measured and filed rather than caused. Every other assertion still
+ * applies to them — including the other two diagnostics — so the exemption is
+ * one string wide, not one entry wide.
+ *
+ * All six `components-form-calendar` entries author the bare `calendar`
+ * keyword, which `@object-ui/components` deliberately registers as
+ * `ui:calendar` only ("collides with the plugin-calendar full CRUD calendar
+ * VIEW", `skipFallback: true`). So the bare keyword reaches `ObjectCalendar`,
+ * which has no data source here and says so. Registering the package is what
+ * exposed it; correcting six entries' authored type is a separate decision,
+ * filed as objectui#4625.
+ */
+const KNOWN_DIAGNOSTIC: Record<string, string> = {
+  'components-form-calendar/custom-style': DATASOURCE_REQUIRED,
+  'components-form-calendar/date-range': DATASOURCE_REQUIRED,
+  'components-form-calendar/form-integration': DATASOURCE_REQUIRED,
+  'components-form-calendar/multiple-dates': DATASOURCE_REQUIRED,
+  'components-form-calendar/simple-calendar': DATASOURCE_REQUIRED,
+  'components-form-calendar/single-date': DATASOURCE_REQUIRED,
+};
+
+/**
+ * Categories objectui#4616 newly registered a package for. These get the
+ * stronger positive control — the entry's own authored strings on screen —
+ * because they are the ones whose tiles were red before this change, and
+ * "no longer red" must not be satisfiable by a tile that draws nothing.
+ */
+const NEWLY_REGISTERED_CATEGORIES = [
+  'components-complex-filter-ui',
+  'components-complex-sort-ui',
+  'components-complex-view-switcher',
+  'plugin-calendar',
+  'plugin-chatbot',
+  'plugin-editor',
+  'plugin-gantt',
+  'plugin-kanban',
+  'plugin-map',
+  'plugin-markdown',
+  'plugin-timeline',
+];
+
+/**
+ * Entries in those categories whose authored titles provably cannot reach the
+ * DOM. Each still carries the full no-red-tile assertion and the
+ * DOM-was-produced control above; only the authored-title control is lifted,
+ * with the measured reason.
+ *
+ * date window: `calendar-view` paints the grid for the CURRENT month/week, and
+ * both entries author events with fixed 2024 dates, so no event title is in
+ * range (measured on a 2026-08-14 run: "August 2026" and "Aug 9 - Aug 15,
+ * 2026"). That is a staleness question about the entries' data, not a render
+ * defect — filed as objectui#4627. Everything else still applies to them: both
+ * draw a real calendar, 163 and 421 elements.
+ *
+ * (`plugin-editor`'s and `plugin-map`'s six are absent from this table because
+ * they are not rendered here at all — see `EXCLUSIONS`.)
+ */
+const AUTHORED_TEXT_EXEMPT: Record<string, string> = {
+  'plugin-calendar/month-view-calendar': 'date window',
+  'plugin-calendar/week-view-calendar': 'date window',
+};
+
+/**
+ * The gallery's data source, in the shape `SchemaThumbnail` supplies it. Kept
+ * as a local literal rather than imported from `apps/site` because `apps/**` is
+ * outside every root Vitest project (`vitest.config.mts` `sharedExclude`); the
+ * host-parity case at the end guards the two from drifting apart.
+ */
+const galleryDataSource = {
+  queryDataset: async (
+    _dataset: string,
+    query: { dimensions?: string[]; measures?: string[] },
+  ) => {
+    const dimensions = query?.dimensions ?? [];
+    const measures = query?.measures ?? [];
+    const measure = measures[0] ?? 'value';
+    const rows = dimensions.length
+      ? [
+          { [dimensions[0]]: 'Alpha', [measure]: 42 },
+          { [dimensions[0]]: 'Beta', [measure]: 27 },
+        ]
+      : [{ [measure]: 69 }];
+    return { rows, fields: [] };
+  },
+};
+
+/** The two wrapper elements this harness adds around the entry's own root. */
+const WRAPPER_ELEMENTS = 2;
+
+interface Rendered {
+  text: string;
+  elements: number;
+  unmount: () => void;
+}
+
+/**
+ * Did the tile draw anything of its own? Elements OR text, because both are
+ * real: `components-basic-text/*` render a bare text node with no element
+ * around it (measured — "Heading 1" is a direct child of the wrapper), so an
+ * element-count-only control reads nine correct tiles as empty.
+ */
+const drewSomething = (elements: number, text: string) =>
+  elements > WRAPPER_ELEMENTS || text.trim().length > 0;
+
+/** Which diagnostics this entry must not show. */
+const diagnosticsFor = (id: string) =>
+  ALL_DIAGNOSTICS.filter((d) => d !== KNOWN_DIAGNOSTIC[id]);
+
+/** Render one entry exactly as `SchemaThumbnail` does, then let it settle. */
+async function renderEntry(schema: unknown): Promise<Rendered> {
+  const { container, unmount } = render(
+    <SchemaRendererContext.Provider value={{ dataSource: galleryDataSource } as never}>
+      <SidebarProvider className="min-h-0 w-full" defaultOpen={false}>
+        <div className="w-full p-4">
+          <SchemaRenderer
+            schema={toRenderableSchema(schema as never) as never}
+            dataSource={galleryDataSource as never}
+          />
+        </div>
+      </SidebarProvider>
+    </SchemaRendererContext.Provider>,
+  );
+  // Two settles, for two different asynchronous shapes:
+  //  - a dataset widget starts in `loading` and resolves on a promise;
+  //  - `code-editor`, `kanban` and `markdown` are `React.lazy` behind
+  //    `Suspense`, so their first paint is the fallback and their real DOM
+  //    arrives one dynamic import later.
+  // Asserting before either settles would pass while the diagnostic is still a
+  // tick away — the vacuous green this pin exists to prevent.
+  await waitFor(() =>
+    expect(container.querySelector('[data-testid="dataset-loading"]')).toBeNull(),
+  );
+  await waitFor(() =>
+    expect(
+      drewSomething(container.querySelectorAll('*').length, container.textContent ?? ''),
+    ).toBe(true),
+  );
+  return {
+    text: container.textContent ?? '',
+    elements: container.querySelectorAll('*').length,
+    unmount,
+  };
+}
+
+/**
+ * `object-map` tears maplibre down through a GL context that happy-dom never
+ * gave it, so unmount throws `Cannot read properties of undefined (reading
+ * 'destroy')` for those three entries. Swallowed HERE, at teardown only, so it
+ * cannot mask anything the assertions above already read off the settled DOM —
+ * and done explicitly so RTL's auto-cleanup does not hit it later, out of band,
+ * where it would surface as an unattributable error on some other file.
+ */
+function teardown(r: Rendered) {
+  try {
+    r.unmount();
+  } catch {
+    /* environment-only; see the comment above */
+  }
+}
+
+/**
+ * Authored TITLES at any depth — the same key objectui#4600 used for dashboard
+ * widgets, generalized. Deliberately only `title`:
+ *  - `label` also names the options inside a filter/sort config, which are not
+ *    on screen until a row is added (measured: `components-complex-filter-ui/
+ *    filter-ui` renders "Filters" and authors Name/Status/Open/Closed);
+ *  - `content` on a markdown block is markdown SOURCE, whose rendered form is
+ *    deliberately not the source text.
+ * Both would make this control fail on tiles that are drawing correctly.
+ */
+function authoredTitles(node: unknown, acc: string[] = []): string[] {
+  if (Array.isArray(node)) {
+    for (const n of node) authoredTitles(n, acc);
+    return acc;
+  }
+  if (node && typeof node === 'object') {
+    for (const [k, v] of Object.entries(node as Record<string, unknown>)) {
+      if (
+        k === 'title' &&
+        typeof v === 'string' &&
+        v.trim().length > 1 &&
+        // Template expressions resolve against data this corpus does not ship.
+        !v.includes('{{') &&
+        !v.includes('${')
+      ) {
+        acc.push(v.trim());
+      }
+      authoredTitles(v, acc);
+    }
+  }
+  return acc;
+}
+
+const entries = allExamples();
+const occurrences = (haystack: string, needle: string) => haystack.split(needle).length - 1;
+
+describe('objectui#4616 — every catalog entry renders in the docs gallery', () => {
+  /**
+   * NON-VACUITY CONTROL for the sweep as a whole. `it.each([])` reports nothing
+   * rather than failing, and every root type resolving to the red panel would
+   * still leave each per-entry case asserting over a string — so pin the corpus
+   * size and the registration set the sweep depends on.
+   */
+  it('the corpus is populated and every package the census needs is loaded', () => {
+    expect(entries.length).toBeGreaterThanOrEqual(423);
+    // One type per package below, chosen as the one the census actually needed.
+    for (const type of [
+      'dashboard',
+      'chart',
+      'calendar-view',
+      'chatbot',
+      'code-editor',
+      'object-gantt',
+      'kanban',
+      'object-map',
+      'markdown',
+      'timeline',
+      'filter-ui',
+      'sort-ui',
+      'view-switcher',
+    ]) {
+      expect(ComponentRegistry.get(type), `${type} is not registered`).toBeTruthy();
+    }
+  });
+
+  it('every exclusion still names a real entry', () => {
+    const ids = new Set(entries.map((e) => e.id));
+    for (const id of [
+      ...Object.keys(EXCLUSIONS),
+      ...Object.keys(KNOWN_DIAGNOSTIC),
+      ...Object.keys(AUTHORED_TEXT_EXEMPT),
+    ]) {
+      expect(ids.has(id), `${id} is excluded but no longer exists in the catalog`).toBe(true);
+    }
+  });
+
+  it.each(entries.filter((e) => !EXCLUSIONS[e.id]).map((e) => [e.id, e.schema] as const))(
+    '%s renders without a red tile',
+    async (id, schema) => {
+      const r = await renderEntry(schema);
+      try {
+        for (const diagnostic of diagnosticsFor(id)) {
+          expect(r.text, `${id} shows "${diagnostic}"`).not.toContain(diagnostic);
+        }
+        // Positive control: the tile drew something of its own.
+        expect(drewSomething(r.elements, r.text)).toBe(true);
+      } finally {
+        teardown(r);
+      }
+    },
+  );
+
+  it.each(
+    entries
+      .filter(
+        (e) =>
+          NEWLY_REGISTERED_CATEGORIES.includes(e.meta.category) &&
+          !EXCLUSIONS[e.id] &&
+          !AUTHORED_TEXT_EXEMPT[e.id],
+      )
+      .map((e) => [e.id, e.schema] as const),
+  )('%s puts its authored content on screen', async (_id, schema) => {
+    const r = await renderEntry(schema);
+    try {
+      const titles = [...new Set(authoredTitles(schema))];
+      if (titles.length > 0) {
+        // Same control objectui#4600 applies to dashboard widget titles.
+        expect(titles.filter((t) => !r.text.includes(t))).toEqual([]);
+      } else {
+        // Entries in these categories that author no `title` at all —
+        // `filter-ui`, `sort-ui`, `view-switcher`, `markdown` — still have to
+        // paint text of their own rather than an empty frame.
+        expect(r.text.trim().length).toBeGreaterThan(0);
+      }
+    } finally {
+      teardown(r);
+    }
+  });
+
+  /**
+   * The same facts as COUNTS, so a regression reports "3 entries across
+   * plugin-gantt and plugin-timeline" rather than one failing entry at a time —
+   * and so the numbers in this file's header stay measured numbers.
+   */
+  it('the whole corpus produces zero unknown-type panels and zero error tiles', async () => {
+    const counts: Record<string, number> = {
+      [UNKNOWN_COMPONENT]: 0,
+      [FAILED_TO_RENDER]: 0,
+      [DATASOURCE_REQUIRED]: 0,
+    };
+    const broken: string[] = [];
+    for (const entry of entries) {
+      if (EXCLUSIONS[entry.id]) continue;
+      const r = await renderEntry(entry.schema);
+      const hits: string[] = [];
+      for (const diagnostic of diagnosticsFor(entry.id)) {
+        const n = occurrences(r.text, diagnostic);
+        counts[diagnostic] += n;
+        if (n) hits.push(`${diagnostic} x${n}`);
+      }
+      teardown(r);
+      if (hits.length) broken.push(`${entry.meta.category} :: ${entry.id}: ${hits.join(', ')}`);
+    }
+    expect({ ...counts, broken }).toEqual({
+      [UNKNOWN_COMPONENT]: 0,
+      [FAILED_TO_RENDER]: 0,
+      [DATASOURCE_REQUIRED]: 0,
+      broken: [],
+    });
+  }, 120000);
+
+  /**
+   * HOST PARITY (source-text guard, deliberately not behavioural).
+   *
+   * Everything above mirrors the gallery: the same registration set, in the
+   * same order, with the same dataset-capable `dataSource`. It cannot mirror it
+   * by construction — `apps/**` is outside every root Vitest project — so
+   * deleting a package from the host would leave this file green while
+   * `/docs/guide/schema-catalog` went back to painting red panels. This case
+   * reads the host and pins what the sweep assumes about it.
+   */
+  describe('the docs-site gallery host registers the same set', () => {
+    // `process.cwd()` is the repo root by construction: `scripts/vitest-
+    // invocation-guard.mjs` refuses any run whose Vitest root is not it.
+    const siteDir = path.join(process.cwd(), 'apps/site/app/components');
+    const read = (f: string) => fs.readFileSync(path.join(siteDir, f), 'utf8');
+
+    it('loads every package this pin loads, in this pin’s order', () => {
+      const source = read('registerCatalogBlocks.ts');
+      const imported = [...source.matchAll(/^import\s+'(@object-ui\/[^']+)';$/gm)].map(
+        (m) => m[1],
+      );
+      expect(imported).toEqual(HOST_PACKAGES);
+    });
+
+    it('is imported by the gallery thumbnail host', () => {
+      expect(read('SchemaThumbnail.tsx')).toMatch(
+        /^import\s+'\.\/registerCatalogBlocks';$/m,
+      );
+    });
+
+    /**
+     * The objectui#4600 separation, restated because objectui#4616 is exactly
+     * the change that would tempt someone to collapse it: the per-page demo
+     * hosts opt into their plugins through `PluginLoader`, and importing this
+     * module from them would make every docs page carrying a demo load all
+     * eleven graphs eagerly.
+     */
+    it.each(['InteractiveDemo.tsx', 'LiveSplitDemo.tsx'])(
+      '%s still does NOT import it (PluginLoader stays lazy there)',
+      (host) => {
+        expect(read(host)).not.toContain('registerCatalogBlocks');
+      },
+    );
+  });
+});
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 9ad42a11b..f07e699b7 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -657,12 +657,39 @@ importers:
       '@object-ui/layout':
         specifier: workspace:*
         version: link:../../packages/layout
+      '@object-ui/plugin-calendar':
+        specifier: workspace:*
+        version: link:../../packages/plugin-calendar
       '@object-ui/plugin-charts':
         specifier: workspace:*
         version: link:../../packages/plugin-charts
+      '@object-ui/plugin-chatbot':
+        specifier: workspace:*
+        version: link:../../packages/plugin-chatbot
       '@object-ui/plugin-dashboard':
         specifier: workspace:*
         version: link:../../packages/plugin-dashboard
+      '@object-ui/plugin-editor':
+        specifier: workspace:*
+        version: link:../../packages/plugin-editor
+      '@object-ui/plugin-gantt':
+        specifier: workspace:*
+        version: link:../../packages/plugin-gantt
+      '@object-ui/plugin-kanban':
+        specifier: workspace:*
+        version: link:../../packages/plugin-kanban
+      '@object-ui/plugin-map':
+        specifier: workspace:*
+        version: link:../../packages/plugin-map
+      '@object-ui/plugin-markdown':
+        specifier: workspace:*
+        version: link:../../packages/plugin-markdown
+      '@object-ui/plugin-timeline':
+        specifier: workspace:*
+        version: link:../../packages/plugin-timeline
+      '@object-ui/plugin-view':
+        specifier: workspace:*
+        version: link:../../packages/plugin-view
       '@object-ui/react':
         specifier: workspace:*
         version: link:../../packages/react