@warpgogol/werkstatt-shared 0.14.0 → 0.15.0

package/src/{share/scripts → client-scripts/tests}/video-player.test.ts

@@ -6,7 +6,36 @@
 <CHANGE_SUMMARY><item>RFC-0950: initial video-player tests.</item></CHANGE_SUMMARY>
 */
 
-import { test, expect, vi, beforeEach, afterEach } from "vitest";
+import { test, expect, vi, beforeEach, afterEach, type Mock } from "vitest";
+
+// ── Mock types ──────────────────────────────────────────────────────────────
+
+interface MockVideo {
+  dataset: Record<string, string>;
+  canPlayType: ReturnType<typeof vi.fn>;
+  play: ReturnType<typeof vi.fn>;
+  pause: ReturnType<typeof vi.fn>;
+  load: ReturnType<typeof vi.fn>;
+  insertBefore: ReturnType<typeof vi.fn>;
+  firstChild: null;
+}
+interface MockHlsInstance {
+  loadSource: ReturnType<typeof vi.fn>;
+  attachMedia: ReturnType<typeof vi.fn>;
+  destroy: ReturnType<typeof vi.fn>;
+  on: Mock<(event: string, cb: () => void) => void>;
+}
+interface MockEntry {
+  isIntersecting: boolean;
+  target: MockVideo;
+}
+interface MockObserver {
+  unobserve: () => void;
+}
+interface MockDocument {
+  querySelectorAll: ReturnType<typeof vi.fn>;
+  createElement: ReturnType<typeof vi.fn>;
+}
 
 // ── Mocks ───────────────────────────────────────────────────────────────────
 
@@ -15,7 +44,7 @@ vi.mock("plyr", () => ({
 }));
 
 vi.mock("hls.js/light", () => {
-  const hlsRef = { current: null as any };
+  const hlsRef = { current: null as MockHlsInstance | null };
   const fn = vi.fn(function Hls() {
     return hlsRef.current;
   });
@@ -28,8 +57,8 @@ vi.mock("hls.js/light", () => {
 
 // ── Helpers ─────────────────────────────────────────────────────────────────
 
-function createMockVideo(attrs: Record<string, string | undefined> = {}): any {
-  const video: any = {
+function createMockVideo(attrs: Record<string, string | undefined> = {}): MockVideo {
+  const video: MockVideo = {
     dataset: {},
     canPlayType: vi.fn(() => ""),
     play: vi.fn(() => Promise.resolve()),
@@ -44,23 +73,15 @@ function createMockVideo(attrs: Record<string, string | undefined> = {}): any {
   return video;
 }
 
-let observerCallbacks: ((
-  entries: { isIntersecting: boolean; target: any }[],
-  obs: { unobserve: () => void },
-) => void)[] = [];
+let observerCallbacks: ((entries: MockEntry[], obs: MockObserver) => void)[] = [];
 let observerOptions: { threshold?: number; rootMargin?: string }[] = [];
+let mockDocument: MockDocument;
 
 class MockIntersectionObserver {
-  callback: (
-    entries: { isIntersecting: boolean; target: any }[],
-    obs: { unobserve: () => void },
-  ) => void;
+  callback: (entries: MockEntry[], obs: MockObserver) => void;
   options: { threshold?: number; rootMargin?: string };
   constructor(
-    cb: (
-      entries: { isIntersecting: boolean; target: any }[],
-      obs: { unobserve: () => void },
-    ) => void,
+    cb: (entries: MockEntry[], obs: MockObserver) => void,
     opts: { threshold?: number; rootMargin?: string },
   ) {
     this.callback = cb;
@@ -79,24 +100,23 @@ beforeEach(() => {
   vi.clearAllMocks();
   observerCallbacks = [];
   observerOptions = [];
-  (globalThis as any).IntersectionObserver = MockIntersectionObserver;
-  (globalThis as any).window = globalThis;
-  (globalThis as any).document = {
+  mockDocument = {
     querySelectorAll: vi.fn(() => []),
     createElement: vi.fn((tag: string) => ({ tagName: tag.toUpperCase() })),
   };
+  vi.stubGlobal("IntersectionObserver", MockIntersectionObserver);
+  vi.stubGlobal("window", globalThis);
+  vi.stubGlobal("document", mockDocument);
 });
 
 afterEach(() => {
-  delete (globalThis as any).IntersectionObserver;
-  delete (globalThis as any).window;
-  delete (globalThis as any).document;
+  vi.unstubAllGlobals();
   vi.restoreAllMocks();
 });
 
-async function triggerUpgrade(video: any): Promise<void> {
-  const { initVideoPlayers } = await import("../scripts/video-player.ts");
-  vi.spyOn(globalThis.document as any, "querySelectorAll").mockReturnValue([video]);
+async function triggerUpgrade(video: MockVideo): Promise<void> {
+  const { initVideoPlayers } = await import("../video-player.ts");
+  mockDocument.querySelectorAll.mockReturnValue([video]);
   await initVideoPlayers();
 
   expect(observerCallbacks.length).toBeGreaterThanOrEqual(1);
@@ -107,12 +127,10 @@ async function triggerUpgrade(video: any): Promise<void> {
 // ── Tests ───────────────────────────────────────────────────────────────────
 
 test("initVideoPlayers: returns early when no [data-video-player] elements", async () => {
-  const querySelectorAll = vi.spyOn(globalThis.document as any, "querySelectorAll");
-  querySelectorAll.mockReturnValue([]);
-  const { initVideoPlayers } = await import("../scripts/video-player.ts");
+  mockDocument.querySelectorAll.mockReturnValue([]);
+  const { initVideoPlayers } = await import("../video-player.ts");
   await initVideoPlayers();
   expect(observerCallbacks.length).toBe(0);
-  querySelectorAll.mockRestore();
 });
 
 test("upgrade: data-controls='false' configures Plyr with only ['mute']", async () => {
@@ -165,7 +183,9 @@ test("upgrade: data-autoplay='true' with HLS waits for MEDIA_ATTACHED before pla
     destroy: vi.fn(),
     on: vi.fn(),
   };
-  const Hls = (await import("hls.js/light")).default as any;
+  const Hls = (await import("hls.js/light")).default as unknown as {
+    _hlsRef: { current: MockHlsInstance | null };
+  };
   Hls._hlsRef.current = hlsInstance;
 
   await triggerUpgrade(video);
@@ -173,7 +193,7 @@ test("upgrade: data-autoplay='true' with HLS waits for MEDIA_ATTACHED before pla
   expect(Hls).toHaveBeenCalled();
   expect(hlsInstance.attachMedia).toHaveBeenCalledWith(video);
 
-  const attachedCall = hlsInstance.on.mock.calls.find((c: any[]) => c[0] === "hls.MEDIA_ATTACHED");
+  const attachedCall = hlsInstance.on.mock.calls.find((c) => c[0] === "hls.MEDIA_ATTACHED");
   expect(attachedCall, "Hls must register a MEDIA_ATTACHED listener before play()").toBeDefined();
   attachedCall![1]();
 

package/src/component/contracts.ts

@@ -0,0 +1,206 @@
+/*
+<MODULE_CONTRACT>
+<purpose>component contracts — component identity and declaration contract type definitions.</purpose>
+<non-goals>
+  <item>Do not implement components — this module defines the contract.</item>
+</non-goals>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-1097: sweep — werkstatt-engine clean
+
+Sweep batch 4: 73 Compass headers on headerless engine files (certification, component-runtime, isolation, evolution, testing), real KEY_DECISIONS on 75 files (kernel, cache, dht, swim, gitmesh, runtime), ~80 purpose expansions (CONTRACT-02/PURPOSE-02), non-goals on 13 CONTRACT-03 files, CS-07 history literal fix repo-wide (253 files). Policy: .template.ts/.template.astro excludedPaths. werkstatt-engine now 0 diagnostics.</item>
+</CHANGE_SUMMARY>
+*/
+
+import type { Sha256Digest } from "../fingerprint/primitives.ts";
+
+export type ComponentId = `${string}/${string}`;
+export type CapabilityId = `${string}/${string}`;
+
+export type EffectClass =
+  "revertible" | "transactional" | "compensatable" | "irreversible-emission";
+
+export type IsolationTier = 0 | 1 | 2 | 3;
+
+export type GrantScope = "read" | "append" | "deploy" | "certify" | "administer";
+
+export type ResourceKind = "cpu" | "memory" | "disk" | "network" | "timer" | "subprocess";
+
+export type LifecycleScope = "process" | "request" | "session" | "scheduled";
+
+export type ComponentScope =
+  "per-command" | "per-mission" | "per-session" | "per-workshop" | "per-fleet";
+
+export interface ScopeContext {
+  readonly scope: ComponentScope;
+  readonly missionId?: string;
+  readonly sessionId?: string;
+  readonly fleetId?: string;
+  readonly invocationId?: string;
+}
+
+export interface ScopedRegistry {
+  readonly context: ScopeContext;
+  register(manifest: ComponentDeclaration): void;
+  resolve(capabilityId: CapabilityId): ComponentDeclaration | null;
+  dispose(): void;
+  list(): ReadonlyArray<ComponentDeclaration>;
+  getScope(): ComponentScope;
+}
+
+export interface ScopeManager {
+  getRegistry(context: ScopeContext): ScopedRegistry;
+  disposeRegistry(context: ScopeContext): void;
+  resolveAcrossScopes(
+    capabilityId: CapabilityId,
+    context: ScopeContext,
+  ): ComponentDeclaration | null;
+  inspect(): ReadonlyArray<{
+    context: ScopeContext;
+    componentCount: number;
+    componentIds: ComponentId[];
+  }>;
+  adopt(componentId: ComponentId, targetContext: ScopeContext): void;
+  getScope(componentId: ComponentId): ComponentScope | null;
+}
+
+export const SCOPE_ERROR_CODES = {
+  SCOPE_01: "SCOPE-01",
+  SCOPE_02: "SCOPE-02",
+  SCOPE_03: "SCOPE-03",
+  SCOPE_04: "SCOPE-04",
+  SCOPE_05: "SCOPE-05",
+} as const;
+
+export interface CapabilityProvideV1 {
+  capability: CapabilityId;
+  version: string;
+  schemaHash: string;
+}
+
+export interface CapabilityRequireV1 {
+  capability: CapabilityId;
+  compatibility: string;
+  schemaHash: string | null;
+  optional: boolean;
+}
+
+export interface GrantRequestV1 {
+  scope: GrantScope;
+  resource: string;
+  attenuated: boolean;
+}
+
+export interface EffectDeclarationV1 {
+  effectClass: EffectClass;
+  description: string;
+  recoveryCommand: string | null;
+  commitMetadata: string | null;
+}
+
+/** RFC-1037: Probe type for compensation verification. */
+export type CompensationProbeType =
+  "dns-resolved" | "http-status" | "cdn-cleared" | "mirror-synced" | "custom";
+
+/** RFC-1037: A single verification probe that checks equivalence after compensation. */
+export interface CompensationProbe {
+  readonly type: CompensationProbeType;
+  readonly target: string;
+  readonly expected: string;
+  readonly timeoutMs: number;
+  readonly customVerifyCommand?: string;
+}
+
+/** RFC-1037: The compensating action with verification probes. */
+export interface CompensationAction {
+  readonly compensatingOperation: string;
+  readonly verificationProbes: readonly CompensationProbe[];
+  readonly verificationTimeoutMs: number;
+  readonly failureMode: "blocking" | "non-blocking";
+}
+
+/** RFC-1037: Result of a single probe execution. */
+export interface ProbeResult {
+  readonly probe: CompensationProbe;
+  readonly passed: boolean;
+  readonly actualValue?: string;
+  readonly latencyMs: number;
+}
+
+/** RFC-1037: Result of compensation verification. */
+export interface CompensationResult {
+  readonly operationHash: Sha256Digest;
+  readonly compensationHash: Sha256Digest;
+  readonly verified: boolean;
+  readonly probeResults: readonly ProbeResult[];
+  readonly verifiedAt: string;
+  readonly failureReason?: string;
+}
+
+/** RFC-1037: Extension of EffectDeclarationV1 with compensation verification contracts. */
+export interface EffectDeclarationExt extends EffectDeclarationV1 {
+  readonly compensation?: CompensationAction;
+  readonly commitBoundary?: string;
+}
+
+export interface IsolationRequirementV1 {
+  tier: IsolationTier;
+  adapterId: string | null;
+}
+
+export interface ResourceBoundV1 {
+  kind: ResourceKind;
+  limit: string;
+  owner: ComponentId;
+  lifecycle: LifecycleScope;
+}
+
+export interface ComponentDeclaration {
+  schema: "werkstatt/component-declaration@1";
+  /** Stable component ID — survives reconfiguration without losing identity. */
+  componentId: ComponentId;
+  version: string;
+  artifactHash: Sha256Digest;
+  scope: ComponentScope;
+  provides: CapabilityProvideV1[];
+  requires: CapabilityRequireV1[];
+  requestedGrants: GrantRequestV1[];
+  effects: EffectDeclarationV1[];
+  isolation: IsolationRequirementV1;
+  resources: ResourceBoundV1[];
+  /** Configuration overrides for this component instance. */
+  config?: Record<string, unknown>;
+  /** Priority — higher priority components override lower for the same capability. */
+  priority: number;
+  /** Whether this component is desired to be active. */
+  active: boolean;
+}
+
+export interface ResolvedComponentIdentityV1 {
+  componentId: ComponentId;
+  version: string;
+  artifactHash: string;
+}
+
+export interface ResolvedComponentSetV1 {
+  schema: "werkstatt/resolved-component-set@1";
+  profileId: string;
+  components: ResolvedComponentIdentityV1[];
+  dependencyGraphHash: string;
+  grantSetHash: string;
+  effectPolicyHash: string;
+  isolationPolicyHash: string;
+  setHash: string;
+}
+
+export interface ComponentContractViolation {
+  rule: string;
+  path: string;
+  message: string;
+}
+
+export interface ComponentContractResult<T> {
+  status: "pass" | "fail";
+  data: T | null;
+  violations: ComponentContractViolation[];
+}

package/src/component/index.ts

@@ -0,0 +1,11 @@
+/*
+<MODULE_CONTRACT>
+  <purpose>Barrel export for @warpgogol/werkstatt-shared/component sub-path. Re-exports component contract types (ComponentId, CapabilityId, EffectClass, IsolationTier, ComponentDeclaration) sunk from @warpgogol/werkstatt-engine per RFC-1104.</purpose>
+  <non-goals>Does not re-export engine component-runtime modules (identity, schemas, runtime registry).</non-goals>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-1104: initial barrel — component contracts sunk from werkstatt-engine.</item>
+</CHANGE_SUMMARY>
+*/
+
+export * from "./contracts.ts";

package/src/{share → content}/content-reference.ts

@@ -23,9 +23,9 @@ and resolves braceless collection.file.field references without astro:content (R
 
 import { readFileSync } from "node:fs";
 import { parse } from "yaml";
-import { substituteRefsDeep } from "./content/substitute-deep.ts";
-import { resolveFieldPath } from "./content/resolve-field-path.ts";
-import { scanFormulas, resolveFormula } from "./formula-eval.ts";
+import { substituteRefsDeep } from "./substitute-deep.ts";
+import { resolveFieldPath } from "./resolve-field-path.ts";
+import { scanFormulas, resolveFormula } from "../offers/formula-eval.ts";
 
 export interface ContentRefIndex {
   version: 1;

package/src/{share/content → content}/entity-id.ts

@@ -10,9 +10,12 @@ language codes from them. Shared across all apps in apps/*; no app-specific impo
 </non-goals>
 </MODULE_CONTRACT>
 <CHANGE_SUMMARY>
-  <item>Merged createDispatcherResolver from dispatch.ts (micro-module consolidation).</item>
-  <item>Tightened createDispatcherResolver typing: replaced any with generic T parameter.</item>
-  <item>Fixed JSDoc: removed references to non-existent callers (components-dispatcher, layouts-dispatcher, pages-dispatcher).</item>
+  <item>RFC-1097: step 6 — compass.migrate codemod run
+
+Mechanical v1 to v2 header migration across the workspace: 942 files rewritten — CHANGE_SUMMARY windows collapsed into history, forbidden v1 blocks stripped, KEY_DECISIONS seeded from @ai-invariant comments (5 files) or TODO placeholders (103 files), blocks reordered to canonical order.</item>
+  <item>RFC-1097: sweep — werkstatt-engine clean
+
+Sweep batch 4: 73 Compass headers on headerless engine files (certification, component-runtime, isolation, evolution, testing), real KEY_DECISIONS on 75 files (kernel, cache, dht, swim, gitmesh, runtime), ~80 purpose expansions (CONTRACT-02/PURPOSE-02), non-goals on 13 CONTRACT-03 files, CS-07 history literal fix repo-wide (253 files). Policy: .template.ts/.template.astro excludedPaths. werkstatt-engine now 0 diagnostics.</item>
 </CHANGE_SUMMARY>
 */
 

package/src/content/index.ts

@@ -13,6 +13,9 @@ markdown frontmatter utilities and system manifest loading (RFC-0868).</purpose>
 
 export { parseMarkdownFrontmatter, stringifyMarkdownFrontmatter } from "./markdown-frontmatter.ts";
 export type { ParsedFrontmatter } from "./markdown-frontmatter.ts";
+export * from "./entity-id.ts";
+export * from "./merge.ts";
+export * from "./resolve-field-path.ts";
 export {
   loadSystemManifest,
   loadSystemManifestSync,

package/src/{share/content → content}/merge.ts

@@ -7,7 +7,12 @@
 </MODULE_CONTRACT>
 <CHANGE_SUMMARY>
   <item>RFC-0133: backfilled MODULE_MAP and CHANGE_SUMMARY markers for compass.validate compliance.</item>
-  <item>Deepening: unified deepMergeEntryData and mergeComponentContent into one configurable deepMerge; old names kept as thin wrappers.</item>
+  <item>RFC-1097: step 6 — compass.migrate codemod run
+
+Mechanical v1 to v2 header migration across the workspace: 942 files rewritten — CHANGE_SUMMARY windows collapsed into history, forbidden v1 blocks stripped, KEY_DECISIONS seeded from @ai-invariant comments (5 files) or TODO placeholders (103 files), blocks reordered to canonical order.</item>
+  <item>RFC-1097: sweep — werkstatt-engine clean
+
+Sweep batch 4: 73 Compass headers on headerless engine files (certification, component-runtime, isolation, evolution, testing), real KEY_DECISIONS on 75 files (kernel, cache, dht, swim, gitmesh, runtime), ~80 purpose expansions (CONTRACT-02/PURPOSE-02), non-goals on 13 CONTRACT-03 files, CS-07 history literal fix repo-wide (253 files). Policy: .template.ts/.template.astro excludedPaths. werkstatt-engine now 0 diagnostics.</item>
 </CHANGE_SUMMARY>
 */
 

package/src/content/system-manifest.test.ts

@@ -0,0 +1,107 @@
+/*
+<MODULE_CONTRACT>
+<purpose>Tests for loadSystemManifest / loadSystemManifestSync — RFC-1106: loaders execute systemManifestSchema.parse() at load time, so a valid manifest returns the schema-inferred type with defaults materialized and an invalid manifest throws ZodError.</purpose>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-1106: created — pins the parse-at-load contract (AC-7).</item>
+  <item>RFC-1106: step 3 — sole SystemManifest definition, loaders parse()
+
+Delete the hand-written SystemManifest interface; content/system-manifest.ts re-exports the schema-inferred type. Both loaders switch from 'as unknown as' to systemManifestSchema.parse() — the schema now executes at load. system.manifest.validate catches ZodError and maps issues into structured diagnostics; the post-load safeParse was dead code. Zero consumer breaks: all growth/release/tagline readers were already optional-safe. New adjacent test pins parse-at-load (AC-7).</item>
+</CHANGE_SUMMARY>
+*/
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdtemp, writeFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { ZodError } from "zod";
+import { loadSystemManifest, loadSystemManifestSync } from "./system-manifest.ts";
+
+const VALID_SYSTEM_MD = `---
+app: test-app
+version: 1.0.0
+identity:
+  systemStar: sirius
+  biome: urban
+---
+
+# Test system
+`;
+
+const INVALID_SYSTEM_MD = `---
+app: INVALID APP
+version: not-semver
+identity:
+  systemStar: sirius
+---
+
+# Invalid system
+`;
+
+describe("loadSystemManifest", () => {
+  let contentDir: string;
+
+  beforeEach(async () => {
+    contentDir = await mkdtemp(join(tmpdir(), "system-manifest-"));
+  });
+
+  afterEach(async () => {
+    await rm(contentDir, { recursive: true, force: true });
+  });
+
+  it("parses a valid manifest and materializes schema defaults", async () => {
+    await writeFile(join(contentDir, "system.md"), VALID_SYSTEM_MD);
+
+    const result = await loadSystemManifest(contentDir);
+
+    expect(result.manifest.app).toBe("test-app");
+    expect(result.manifest.identity.systemStar).toBe("sirius");
+    // .default([]) materialized by parse — absent in source, present in output
+    expect(result.manifest.pages).toEqual([]);
+    expect(result.manifest.constellations).toEqual([]);
+    expect(result.manifest.clientEditable).toEqual([]);
+    expect(result.manifest.retiredRoutes).toEqual([]);
+    // optional fields stay absent
+    expect(result.manifest.growth).toBeUndefined();
+    expect(result.manifest.release).toBeUndefined();
+    expect(result.manifest.identity.tagline).toBeUndefined();
+    expect(result.source).toBe("system.md");
+  });
+
+  it("throws ZodError on an invalid manifest", async () => {
+    await writeFile(join(contentDir, "system.md"), INVALID_SYSTEM_MD);
+
+    await expect(loadSystemManifest(contentDir)).rejects.toBeInstanceOf(ZodError);
+  });
+
+  it("throws when system.md does not exist", async () => {
+    await expect(loadSystemManifest(contentDir)).rejects.toThrow();
+  });
+});
+
+describe("loadSystemManifestSync", () => {
+  let contentDir: string;
+
+  beforeEach(async () => {
+    contentDir = await mkdtemp(join(tmpdir(), "system-manifest-sync-"));
+  });
+
+  afterEach(async () => {
+    await rm(contentDir, { recursive: true, force: true });
+  });
+
+  it("parses a valid manifest synchronously", async () => {
+    await writeFile(join(contentDir, "system.md"), VALID_SYSTEM_MD);
+
+    const result = loadSystemManifestSync(contentDir);
+
+    expect(result.manifest.app).toBe("test-app");
+    expect(result.manifest.pages).toEqual([]);
+  });
+
+  it("throws ZodError on an invalid manifest", async () => {
+    await writeFile(join(contentDir, "system.md"), INVALID_SYSTEM_MD);
+
+    expect(() => loadSystemManifestSync(contentDir)).toThrow(ZodError);
+  });
+});

package/src/content/system-manifest.ts

@@ -10,6 +10,9 @@ Stack-agnostic utility used by both engine and site plugin (RFC-0868).</purpose>
 <CHANGE_SUMMARY>
   <item>RFC-0868: extracted from werkstatt-site/src/content/system-manifest.ts.</item>
   <item>RFC-0911: add seo?.anchorText?.extraStopPhrases for anchor-text stop-list extension.</item>
+  <item>RFC-1106: step 3 — sole SystemManifest definition, loaders parse()
+
+Delete the hand-written SystemManifest interface; content/system-manifest.ts re-exports the schema-inferred type. Both loaders switch from 'as unknown as' to systemManifestSchema.parse() — the schema now executes at load. system.manifest.validate catches ZodError and maps issues into structured diagnostics; the post-load safeParse was dead code. Zero consumer breaks: all growth/release/tagline readers were already optional-safe. New adjacent test pins parse-at-load (AC-7).</item>
 </CHANGE_SUMMARY>
 */
 
@@ -17,99 +20,14 @@ import { readFile, access } from "node:fs/promises";
 import { readFileSync, accessSync } from "node:fs";
 import { join } from "node:path";
 import { parseMarkdownFrontmatter } from "./markdown-frontmatter.ts";
+import { systemManifestSchema } from "../ontology/schemas/system/manifest.ts";
+import type { SystemManifest } from "../ontology/schemas/system/manifest.ts";
 
-export interface SystemManifest {
-  app: string;
-  version: string;
-  identity: {
-    systemStar: string;
-    biome: string;
-    tagline: string;
-    domain?: string;
-    /** RFC-0087: Per-app default CTA pageId for shared header and final-cta. */
-    ctaTarget?: string;
-    /** RFC-0096: Operator details consumed by legal.scaffold to fill Impressum / Datenschutz stubs. */
-    legal?: {
-      responsibleName?: string;
-      address?: string;
-      email?: string;
-    };
-  };
-  i18n?: {
-    default: string;
-    supported: Record<string, unknown>;
-  };
-  constellations: string[];
-  clientEditable: string[];
-  sharedContext?: {
-    requiredPageIds: string[];
-  };
-  pages: Array<{
-    pageId: string;
-    routes?: Record<string, string>;
-    route?: string;
-    /** RFC-0097: explicit locale opt-in; the page exists only in these locales. */
-    locales?: string[];
-    cosmicStar: string;
-    planets: Array<{
-      cosmicPlanet: string;
-      pin: string;
-    }>;
-  }>;
-  growth: {
-    vendor: {
-      adapter: string;
-      options: Record<string, unknown>;
-    };
-    funnels: unknown[];
-    experiments: unknown[];
-  };
-  release: {
-    passport: {
-      enabled: boolean;
-      indexable: boolean;
-      keyVersion: string;
-      heartbeatUrl: string;
-    };
-  };
-  /**
-   * RFC-0211 Content Knowledge Lifecycle policy. Mirrors the `knowledge` block in
-   * the ontology systemManifestSchema; declared here so the CKL kernel commands
-   * (content.freshness.validate RFC-0213, content.plan.build RFC-0216) read it
-   * with real types instead of structural casts.
-   */
-  knowledge?: {
-    freshness?: {
-      soonWindowDays?: number;
-      critical?: Array<{ match: string; criticality: "advisory" | "important" | "blocking" }>;
-    };
-    derivation?: {
-      critical?: Array<{ match: string; criticality: "advisory" | "important" | "blocking" }>;
-    };
-    plan?: {
-      leadTimeDays?: number;
-      defaultOwner?: string;
-      criticalityMap?: Array<{ match: string; criticality: "advisory" | "important" | "blocking" }>;
-    };
-  };
-  /** RFC-0487: Business model declaration. Closed enum — currently only "b2b-only". */
-  businessModel?: "b2b-only";
-  /** RFC-0487/RFC-0509: Retired page routes — 410 Gone tombstones or 301 redirects. */
-  retiredRoutes?: Array<{ slug: string; status: 410 } | { slug: string; status: 301; to: string }>;
-  /** UI-level rendering toggles for split-list column order. */
-  ui?: {
-    responsibilityBlock?: {
-      swapOrder?: boolean;
-    };
-  };
-  /** RFC-0911: SEO validator configuration extension point. */
-  seo?: {
-    anchorText?: {
-      /** Added to the built-in de/uk stop-list. */
-      extraStopPhrases?: Record<string, string[]>;
-    };
-  };
-}
+// RFC-1106: systemManifestSchema is the sole SystemManifest definition.
+// The inferred output type materializes .default()s (pages, constellations,
+// clientEditable, retiredRoutes, planets stay non-optional) and keeps
+// growth/release/tagline optional — the old interface lied about those.
+export type { SystemManifest };
 
 export interface SystemManifestLoadResult {
   manifest: SystemManifest;
@@ -132,7 +50,7 @@ export async function loadSystemManifest(
   const parsed = parseMarkdownFrontmatter(content);
 
   return {
-    manifest: parsed.data as unknown as SystemManifest,
+    manifest: systemManifestSchema.parse(parsed.data),
     source: "system.md",
     filePath: systemMdPath,
   };
@@ -151,7 +69,7 @@ export function loadSystemManifestSync(contentDirectory: string): SystemManifest
   const parsed = parseMarkdownFrontmatter(content);
 
   return {
-    manifest: parsed.data as unknown as SystemManifest,
+    manifest: systemManifestSchema.parse(parsed.data),
     source: "system.md",
     filePath: systemMdPath,
   };

package/src/{share → content}/tests/resolve-field-path.test.ts

@@ -1,5 +1,5 @@
 import { test, expect } from "vitest";
-import { resolveFieldPath } from "../content/resolve-field-path.ts";
+import { resolveFieldPath } from "../resolve-field-path.ts";
 
 test("resolveFieldPath resolves shallow field", () => {
   const result = resolveFieldPath({ companyName: "Warpgogol" }, ["companyName"]);