@ikenga/contract 0.18.1 → 0.19.0

package/src/manifest.test.ts

@@ -1,15 +1,25 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
+import { readFileSync, readdirSync } from 'node:fs';
 
 import {
+  CompanionPanelEntrySchema,
+  ContextActionEntrySchema,
+  ContextActionRunSchema,
+  ContextSelectorSchema,
+  ExplorerSectionDataSchema,
+  ExplorerSectionEntrySchema,
   HttpCapabilitySchema,
   IKENGA_API_VERSION,
   InvokeCapabilitySchema,
+  isCompatible,
   ManifestSchema,
   NamedSecretSchema,
   RequiresEntrySchema,
   RequireSourceSchema,
   SecretsCapabilitySchema,
+  ViewEntrySchema,
+  WidgetEntrySchema,
 } from './manifest.js';
 
 // ─── WP-11 — `requires` field (ADR-015 §3) ──────────────────────────────────
@@ -89,8 +99,8 @@ test('Manifest: requires defaults to [] when absent (pre-Phase-4 manifest)', ()
 
 // ─── WP-01 — trusted-cap tier (ADR-017): http / secrets / invoke + signature ─
 
-test('IKENGA_API_VERSION is 4 (WP-01 Manifest v4)', () => {
-  assert.equal(IKENGA_API_VERSION, 4);
+test('IKENGA_API_VERSION is 5 (WP-27 Manifest v5)', () => {
+  assert.equal(IKENGA_API_VERSION, 5);
 });
 
 test('HttpCapability: auth_header defaults to Authorization; auth_secret optional', () => {
@@ -262,3 +272,341 @@ test('Manifest: capabilities.sqlite accepts object config', () => {
   });
   assert.deepEqual(m.capabilities?.sqlite, { db: 'custom.db' });
 });
+
+// ─── WP-27 — manifest v5 contribution blocks (G-MANIFEST-V5, frozen §2) ─────
+
+test('isCompatible: window is [1, 5] after the v5 bump', () => {
+  assert.equal(isCompatible('1'), true);
+  assert.equal(isCompatible('4'), true);
+  assert.equal(isCompatible('5'), true);
+  assert.equal(isCompatible('6'), false);
+  assert.equal(isCompatible('0'), false);
+  assert.equal(isCompatible('abc'), false);
+});
+
+test('ViewEntry: full shape parses; pin_on_install defaults false', () => {
+  const v = ViewEntrySchema.parse({
+    id: 'grid',
+    title: 'Grid',
+    icon: 'layout-grid',
+    route: '/grid',
+    pin_on_install: true,
+  });
+  assert.equal(v.pin_on_install, true);
+  const minimal = ViewEntrySchema.parse({ id: 'd', title: 'D', route: '/d' });
+  assert.equal(minimal.pin_on_install, false);
+  assert.equal(minimal.icon, undefined);
+});
+
+test('ViewEntry: .strict rejects unknown field (mirrors Rust deny_unknown_fields)', () => {
+  assert.throws(() =>
+    ViewEntrySchema.parse({ id: 'x', title: 'X', route: '/x', label: 'nope' }),
+  );
+});
+
+test('ExplorerSectionEntry: full shape parses; order optional int', () => {
+  const e = ExplorerSectionEntrySchema.parse({
+    id: 'open-tasks',
+    title: 'Open Tasks',
+    icon: 'check-circle',
+    order: 10,
+    data_route: '/pkg/com.ikenga.x/sections/open-tasks',
+  });
+  assert.equal(e.order, 10);
+  const minimal = ExplorerSectionEntrySchema.parse({
+    id: 's',
+    title: 'S',
+    data_route: '/pkg/com.ikenga.x/s',
+  });
+  assert.equal(minimal.order, undefined);
+  assert.equal(minimal.icon, undefined);
+});
+
+test('ExplorerSectionEntry: missing data_route fails; .strict rejects extras; non-int order fails', () => {
+  assert.throws(() =>
+    ExplorerSectionEntrySchema.parse({ id: 's', title: 'S' }),
+  );
+  assert.throws(() =>
+    ExplorerSectionEntrySchema.parse({ id: 's', title: 'S', data_route: '/p', bogus: 1 }),
+  );
+  assert.throws(() =>
+    ExplorerSectionEntrySchema.parse({ id: 's', title: 'S', data_route: '/p', order: 1.5 }),
+  );
+});
+
+test('ExplorerSectionData: rows default []; full wire shape parses', () => {
+  const empty = ExplorerSectionDataSchema.parse({});
+  assert.deepEqual(empty.rows, []);
+  const d = ExplorerSectionDataSchema.parse({
+    rows: [
+      {
+        id: 'r1',
+        label: 'Row 1',
+        badge: { count: 3, tooltip: 'three' },
+        open: 'pkg://com.ikenga.x/detail',
+      },
+      { id: 'r2', label: 'Row 2' },
+    ],
+    as_of_ms: 1727000000000,
+  });
+  assert.equal(d.rows.length, 2);
+  assert.equal(d.rows[0]?.badge?.count, 3);
+  assert.equal(d.as_of_ms, 1727000000000);
+});
+
+test('ExplorerSectionData: .strict rejects unknown top-level field', () => {
+  assert.throws(() => ExplorerSectionDataSchema.parse({ rows: [], bogus: true }));
+});
+
+test('CompanionPanelEntry: full shape parses; session_scoped defaults false', () => {
+  const p = CompanionPanelEntrySchema.parse({
+    id: 'state',
+    title: 'State',
+    icon: 'activity',
+    route: '/state',
+    session_scoped: true,
+  });
+  assert.equal(p.session_scoped, true);
+  const minimal = CompanionPanelEntrySchema.parse({ id: 's', title: 'S', route: '/s' });
+  assert.equal(minimal.session_scoped, false);
+});
+
+test('CompanionPanelEntry: missing route fails; .strict rejects extras', () => {
+  assert.throws(() =>
+    CompanionPanelEntrySchema.parse({ id: 's', title: 'S' }),
+  );
+  assert.throws(() =>
+    CompanionPanelEntrySchema.parse({ id: 's', title: 'S', route: '/s', bogus: 1 }),
+  );
+});
+
+test('ContextSelector: all four kinds parse; unknown kind fails', () => {
+  assert.equal(ContextSelectorSchema.parse({ kind: 'file' }).kind, 'file');
+  assert.equal(
+    ContextSelectorSchema.parse({ kind: 'file', glob: '*.md' }).glob,
+    '*.md',
+  );
+  assert.equal(ContextSelectorSchema.parse({ kind: 'artifact' }).kind, 'artifact');
+  assert.equal(ContextSelectorSchema.parse({ kind: 'session' }).kind, 'session');
+  const n = ContextSelectorSchema.parse({ kind: 'ngwa-item', kinds: ['task'] });
+  assert.equal(n.kind, 'ngwa-item');
+  assert.throws(() => ContextSelectorSchema.parse({ kind: 'project' }));
+});
+
+test('ContextActionRun: dispatch + view variants parse; unknown kind fails', () => {
+  const d = ContextActionRunSchema.parse({
+    kind: 'dispatch',
+    prompt: 'Review {{file.path}}',
+    target: 'chi',
+  });
+  assert.equal(d.kind, 'dispatch');
+  const dMinimal = ContextActionRunSchema.parse({ kind: 'dispatch', prompt: 'p' });
+  assert.equal(dMinimal.target, undefined);
+  const v = ContextActionRunSchema.parse({ kind: 'view', route: '/review' });
+  assert.equal(v.kind, 'view');
+  assert.throws(() =>
+    ContextActionRunSchema.parse({ kind: 'shell', command: 'x' }),
+  );
+});
+
+test('ContextActionEntry: full shape parses; missing when/run fails; .strict rejects extras', () => {
+  const a = ContextActionEntrySchema.parse({
+    id: 'hand-to-chi',
+    label: 'Hand to Chi',
+    when: { kind: 'file', glob: '*.md' },
+    run: { kind: 'dispatch', prompt: 'Handle {{file.path}}' },
+  });
+  assert.equal(a.id, 'hand-to-chi');
+  assert.throws(() =>
+    ContextActionEntrySchema.parse({
+      id: 'x',
+      label: 'X',
+      run: { kind: 'view', route: '/x' },
+    }),
+  );
+  assert.throws(() =>
+    ContextActionEntrySchema.parse({
+      id: 'x',
+      label: 'X',
+      when: { kind: 'session' },
+      run: { kind: 'view', route: '/x' },
+      bogus: true,
+    }),
+  );
+});
+
+test('WidgetEntry: span defaults medium; small|medium|wide parse; other spans fail', () => {
+  const w = WidgetEntrySchema.parse({ id: 'w', title: 'W', route: '/w' });
+  assert.equal(w.span, 'medium');
+  for (const span of ['small', 'medium', 'wide'] as const) {
+    assert.equal(
+      WidgetEntrySchema.parse({ id: 'w', title: 'W', route: '/w', span }).span,
+      span,
+    );
+  }
+  assert.throws(() =>
+    WidgetEntrySchema.parse({ id: 'w', title: 'W', route: '/w', span: 'large' }),
+  );
+  assert.throws(() =>
+    WidgetEntrySchema.parse({ id: 'w', title: 'W', route: '/w', bogus: 1 }),
+  );
+});
+
+test('Manifest v5: ui gains all five contribution blocks with [] defaults', () => {
+  const m = ManifestSchema.parse({ ...BASE, ikenga_api: '5' });
+  assert.deepEqual(m.ui.views, []);
+  assert.deepEqual(m.ui.explorer_sections, []);
+  assert.deepEqual(m.ui.companion_panels, []);
+  assert.deepEqual(m.ui.context_actions, []);
+  assert.deepEqual(m.ui.widgets, []);
+});
+
+test('Manifest v5: ui.side_pane_viewers fails to parse (DEC-34 Q1 hard-retire)', () => {
+  assert.throws(() =>
+    ManifestSchema.parse({
+      ...BASE,
+      ui: {
+        routes: [{ path: '/v', kind: 'iframe', source: 'v.html' }],
+        side_pane_viewers: [{ id: 'v', label: 'V', route: '/v' }],
+      },
+    }),
+  );
+  // Even an empty array is a declaration — the field itself is retired.
+  assert.throws(() =>
+    ManifestSchema.parse({ ...BASE, ui: { side_pane_viewers: [] } }),
+  );
+});
+
+test('Manifest v5: views[].route not in ui.routes[] fails via superRefine, naming the path', () => {
+  const r = ManifestSchema.safeParse({
+    ...BASE,
+    ui: {
+      routes: [{ path: '/grid', kind: 'iframe', source: 'grid.html' }],
+      views: [
+        { id: 'grid', title: 'Grid', route: '/grid' },
+        { id: 'missing', title: 'Missing', route: '/not-declared' },
+      ],
+    },
+  });
+  assert.equal(r.success, false);
+  if (!r.success) {
+    const issue = r.error.issues.find((i) => i.code === 'custom');
+    assert.ok(issue, 'expected a custom (superRefine) issue');
+    assert.deepEqual(issue.path, ['ui', 'views', 1, 'route']);
+    assert.ok(issue.message.includes('/not-declared'));
+  }
+});
+
+test('Manifest v5: views[] referencing every declared route parses (§2b)', () => {
+  const m = ManifestSchema.parse({
+    ...BASE,
+    ui: {
+      routes: [
+        { path: '/a', kind: 'iframe', source: 'a.html' },
+        { path: '/b', kind: 'iframe', source: 'b.html' },
+      ],
+      views: [
+        { id: 'a', title: 'A', route: '/a', pin_on_install: true },
+        { id: 'b', title: 'B', route: '/b' },
+      ],
+    },
+  });
+  assert.equal(m.ui.views.length, 2);
+  assert.equal(m.ui.views[0]?.pin_on_install, true);
+});
+
+test('Manifest v5: companion-panel and widget routes are NOT reference-checked (§2b scopes to views)', () => {
+  const m = ManifestSchema.parse({
+    ...BASE,
+    ui: {
+      routes: [],
+      companion_panels: [{ id: 'p', title: 'P', route: '/unlisted' }],
+      widgets: [{ id: 'w', title: 'W', route: '/also-unlisted' }],
+    },
+  });
+  assert.equal(m.ui.companion_panels.length, 1);
+  assert.equal(m.ui.widgets.length, 1);
+});
+
+test('Manifest v5 alias: ui.nav-only manifest parses; nav kept, views default []', () => {
+  const m = ManifestSchema.parse({
+    ...BASE,
+    ikenga_api: '1',
+    ui: {
+      routes: [{ path: '/home', kind: 'iframe', source: 'home.html' }],
+      nav: [{ id: 'home', label: 'Home', icon: 'home', route: '/home' }],
+    },
+  });
+  assert.equal(m.ui.nav.length, 1);
+  assert.equal(m.ui.nav[0]?.label, 'Home');
+  assert.deepEqual(m.ui.views, []);
+});
+
+test('Manifest v5 alias: nav + views both declared still parses (§4 — nav ignored shell-side)', () => {
+  const m = ManifestSchema.parse({
+    ...BASE,
+    ui: {
+      routes: [{ path: '/grid', kind: 'iframe', source: 'grid.html' }],
+      nav: [{ id: 'legacy', label: 'Legacy', route: '/grid' }],
+      views: [{ id: 'grid', title: 'Grid', route: '/grid' }],
+    },
+  });
+  assert.equal(m.ui.nav.length, 1);
+  assert.equal(m.ui.views.length, 1);
+});
+
+// ─── WP-27 — manifest-v5 fixture sweep (PRODUCES: src/__fixtures__/manifest-v5) ─
+// Verdict-by-folder contract consumed by WP-28's Rust parity test:
+//   valid/ parses · invalid/ fails · alias/ parses (shell applies the §4 mapping).
+
+const V5_FIXTURES = new URL('./__fixtures__/manifest-v5/', import.meta.url);
+
+function fixtureNames(dir: 'valid' | 'invalid' | 'alias'): string[] {
+  return readdirSync(new URL(`${dir}/`, V5_FIXTURES))
+    .filter((f) => f.endsWith('.json'))
+    .sort();
+}
+
+function readFixture(dir: 'valid' | 'invalid' | 'alias', name: string): unknown {
+  return JSON.parse(readFileSync(new URL(`${dir}/${name}`, V5_FIXTURES), 'utf8'));
+}
+
+test('manifest-v5 fixtures: every valid/* parses', () => {
+  const names = fixtureNames('valid');
+  assert.ok(names.length > 0, 'expected at least one valid fixture');
+  for (const name of names) {
+    const r = ManifestSchema.safeParse(readFixture('valid', name));
+    assert.ok(
+      r.success,
+      `valid/${name} should parse: ${r.success ? '' : JSON.stringify(r.error.issues)}`,
+    );
+  }
+});
+
+test('manifest-v5 fixtures: every invalid/* fails to parse', () => {
+  const names = fixtureNames('invalid');
+  assert.ok(names.length > 0, 'expected at least one invalid fixture');
+  for (const name of names) {
+    const r = ManifestSchema.safeParse(readFixture('invalid', name));
+    assert.equal(r.success, false, `invalid/${name} should fail to parse`);
+  }
+});
+
+test('manifest-v5 fixtures: every alias/* parses (nav→views is shell-side, §4)', () => {
+  const names = fixtureNames('alias');
+  assert.ok(names.length > 0, 'expected at least one alias fixture');
+  for (const name of names) {
+    const r = ManifestSchema.safeParse(readFixture('alias', name));
+    assert.ok(
+      r.success,
+      `alias/${name} should parse: ${r.success ? '' : JSON.stringify(r.error.issues)}`,
+    );
+  }
+});
+
+test('manifest-v5 fixtures: alias/nav-only keeps nav populated for the shell-side mapping', () => {
+  const m = ManifestSchema.parse(readFixture('alias', 'nav-only.json'));
+  assert.equal(m.ui.nav.length, 2);
+  assert.equal(m.ui.nav[0]?.route, '/home');
+  assert.deepEqual(m.ui.views, []);
+});

package/src/manifest.ts

@@ -17,7 +17,14 @@ import { BrowserEngineSchema } from './browser.js';
 // v3 (ADR-017): added capabilities.http / .secrets / .invoke (trusted-cap tier)
 // + top-level optional `signature`. All additive; api=1/2 manifests parse
 // unchanged. Elevated caps are inert unless the pkg is trusted.
-export const IKENGA_API_VERSION = 4 as const;
+// v5 (WP-27, G-MANIFEST-V5 — plans/shell-ux-rearchitecture/drafts/g-manifest-v5.md,
+// frozen 2026-09-22 Round 24): added ui.views[] / ui.explorer_sections[] (+ the
+// ExplorerSectionData wire shape) / ui.companion_panels[] / ui.context_actions[] /
+// ui.widgets[]; ui.nav marked a deprecated alias (shell-side mapping, one-release
+// lifetime, §4); ui.side_pane_viewers hard-retired — declaring it now fails
+// validation. All additions are optional-with-default, so api=1..4 manifests
+// parse unchanged; the support window stays [MIN_SUPPORTED, CURRENT].
+export const IKENGA_API_VERSION = 5 as const;
 export const IKENGA_API_MIN_SUPPORTED = 1 as const;
 
 // ---------- Sub-schemas ----------
@@ -123,17 +130,150 @@ export const ManifestUiSessionSchema = z.object({
 });
 export type ManifestUiSession = z.infer<typeof ManifestUiSessionSchema>;
 
+// ---------- Manifest v5 contribution blocks ----------
+// Frozen type block from G-MANIFEST-V5 §2
+// (plans/shell-ux-rearchitecture/drafts/g-manifest-v5.md, frozen 2026-09-22,
+// Round 24 / DEC-34). Copied verbatim — do not reinterpret. `UiBlock` gains
+// `views`, `explorer_sections`, `companion_panels`, `context_actions`,
+// `widgets` (all optional-with-default); `nav` keeps its field and type.
+
+// ── ui.views[] — replaces ui.nav (alias window §4) ────────────────────────
+export const ViewEntrySchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  icon: z.string().optional(),          // lucide name; same vocabulary as pins
+  /** A pkg UI namespace path, e.g. `/grid` → pane route `pkg://<id>/grid`.
+   *  Must match a declared `ui.routes[]` path (§6 Q3). */
+  route: z.string(),
+  /** Honoured ONCE, at first install (Round 2 Q1). Updates never re-pin;
+   *  unpin is permanent. Kernel "first install" = no prior install row. */
+  pin_on_install: z.boolean().default(false),
+}).strict();
+export type ViewEntry = z.infer<typeof ViewEntrySchema>;
+
+// ── ui.explorer_sections[] — Project Explorer sections (G-STATE §1 id rule) ─
+export const ExplorerSectionEntrySchema = z.object({
+  id: z.string(),                       // pkg-local; state id = `${pkg_id}:${id}`
+  title: z.string(),
+  icon: z.string().optional(),
+  order: z.number().int().optional(),   // default: declaration order; ties by pkg id
+  /** GET iyke route under `/pkg/<id>/` returning ExplorerSectionData. */
+  data_route: z.string(),
+}).strict();
+export type ExplorerSectionEntry = z.infer<typeof ExplorerSectionEntrySchema>;
+
+/** The JSON a `data_route` returns. The shell renders it natively — the
+ *  section is data, never an embedded iframe (P4 fix, discussion §3.2). */
+export const ExplorerSectionDataSchema = z.object({
+  rows: z.array(z.object({
+    id: z.string(),
+    label: z.string(),
+    badge: z.object({
+      count: z.number().int().optional(),
+      tooltip: z.string().optional(),
+    }).optional(),
+    /** Pane target on click: a pkg route (`pkg://...`) or a shell route (`/...`). */
+    open: z.string().optional(),
+  })).default([]),
+  as_of_ms: z.number().optional(),
+}).strict();
+export type ExplorerSectionData = z.infer<typeof ExplorerSectionDataSchema>;
+
+// ── ui.companion_panels[] — Companion state panels (ADR-021: state only) ───
+export const CompanionPanelEntrySchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  icon: z.string().optional(),
+  /** Pane route rendered in the panel slot (an iframe view). Must render
+   *  state, never model prose — ADR-021 checklist applies. */
+  route: z.string(),
+  /** When true the shell threads `panelScopeSessionId` (the selected
+   *  Companion session tab) through the AppBridge hostContext. */
+  session_scoped: z.boolean().default(false),
+}).strict();
+export type CompanionPanelEntry = z.infer<typeof CompanionPanelEntrySchema>;
+
+// ── ui.context_actions[] — selector-scoped menu contributions ─────────────
+export const ContextSelectorSchema = z.discriminatedUnion('kind', [
+  z.object({ kind: z.literal('file'), glob: z.string().optional() }),
+  z.object({ kind: z.literal('artifact') }),
+  z.object({ kind: z.literal('session') }),
+  z.object({ kind: z.literal('ngwa-item'), kinds: z.array(z.string()).optional() }),
+]);
+export type ContextSelector = z.infer<typeof ContextSelectorSchema>;
+
+export const ContextActionRunSchema = z.discriminatedUnion('kind', [
+  /** "Hand to Chi" — fills the Companion dispatch bar (spec §5.3 resolveTarget).
+   *  `prompt` is a template with {{file.path}}, {{selection}}, {{project.root}},
+   *  {{pane.url}}, {{branch}} — the D-06 variable set. */
+  z.object({ kind: z.literal('dispatch'), prompt: z.string(), target: z.string().optional() }),
+  z.object({ kind: z.literal('view'), route: z.string() }),
+]);
+export type ContextActionRun = z.infer<typeof ContextActionRunSchema>;
+
+export const ContextActionEntrySchema = z.object({
+  id: z.string(),
+  label: z.string(),
+  when: ContextSelectorSchema,
+  run: ContextActionRunSchema,
+}).strict();
+export type ContextActionEntry = z.infer<typeof ContextActionEntrySchema>;
+
+// ── ui.widgets[] — project-dashboard widgets (formalised home canvas) ──────
+export const WidgetEntrySchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  route: z.string(),                    // iframe view rendered in the dashboard grid
+  span: z.enum(['small', 'medium', 'wide']).default('medium'),
+}).strict();
+export type WidgetEntry = z.infer<typeof WidgetEntrySchema>;
+
 export const UiBlockSchema = z.object({
+  /** @deprecated v5 alias (G-MANIFEST-V5 §4): the shell reads `nav[i]` as
+   *  `views[i]` = `{id, title: label, icon, route, pin_on_install: i === 0}`
+   *  for exactly one shell release, then deletes the mapping. Field and type
+   *  are unchanged; a manifest declaring both `nav` and `views` still parses
+   *  (`nav` is ignored with a shell-side warning). New manifests declare
+   *  `views` instead. */
   nav: z.array(NavEntrySchema).default([]),
   routes: z.array(UiRouteSchema).default([]),
   command_palette: z.array(CommandPaletteEntrySchema).default([]),
-  side_pane_viewers: z.array(SidePaneViewerSchema).default([]),
+  /** v5 hard-retire (G-MANIFEST-V5 §8 Q1 / DEC-34): `side_pane_viewers` was
+   *  removed from the block; declaring it fails validation outright.
+   *  `z.never()` is the contract-side mirror of the Rust canonical rejection
+   *  (skills/commands-bundling precedent). `SidePaneViewerSchema` stays
+   *  exported for tooling that reads historical manifests. */
+  side_pane_viewers: z.never().optional(),
+  // ── v5 contribution blocks (G-MANIFEST-V5 §2; all optional-with-default) ──
+  views: z.array(ViewEntrySchema).default([]),
+  explorer_sections: z.array(ExplorerSectionEntrySchema).default([]),
+  companion_panels: z.array(CompanionPanelEntrySchema).default([]),
+  context_actions: z.array(ContextActionEntrySchema).default([]),
+  widgets: z.array(WidgetEntrySchema).default([]),
   /** Per-directive CSP overrides for the iframe content. */
   csp: z.record(z.array(z.string())).optional(),
   /** Per-directive Permission-Policy values. */
   permissions: z.record(z.array(z.string())).optional(),
   session: ManifestUiSessionSchema.optional(),
-}).default({});
+})
+.superRefine((ui, ctx) => {
+  // G-MANIFEST-V5 §2b / DEC-34 Q2: a `ViewEntry.route` must reference a path
+  // declared in the same manifest's `ui.routes[]`. Companion-panel and widget
+  // routes are deliberately NOT reference-checked (§2b scopes the rule to
+  // views only).
+  const routePaths = new Set(ui.routes.map((r) => r.path));
+  ui.views.forEach((view, i) => {
+    if (!routePaths.has(view.route)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ['views', i, 'route'],
+        message: `ui.views[${i}].route "${view.route}" does not match any declared ui.routes[] path`,
+      });
+    }
+  });
+})
+.default({});
+export type UiBlock = z.infer<typeof UiBlockSchema>;
 
 export const SettingsFieldSchema = z.object({
   key: z.string(),