@loomwork/scaffold 0.0.0-stage → 0.1.0

package/dist/plugin.js

@@ -0,0 +1,1807 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SEAM_WIRING = exports.SEAM_SPI = exports.SEAM_KEYS = void 0;
+exports.joinNoun = joinNoun;
+exports.listSeams = listSeams;
+exports.usesNodeGlobals = usesNodeGlobals;
+exports.pluginFiles = pluginFiles;
+exports.pluginNextSteps = pluginNextSteps;
+const codegen_1 = require("./codegen");
+// ── Plugin scaffolding (used by `loom plugin new`) ───────────────────────────
+//
+// A Loom plugin is an ordinary package that implements an existing SPI and/or
+// exports a preset `(opts) => Partial<LoomConfig>` (or a singleton like a
+// StorageConfig), imported statically and passed to `defineConfig`. See ADR 0043
+// and docs/plugins.md. This module emits a ready-to-fill package for a chosen
+// seam, in either first-party (`@loomwork/plugin-*`, in `plugins/`) or third-party
+// (`loom-plugin-*`, standalone) shape.
+/**
+ * Join a plugin's name to a seam's noun WITHOUT repeating words: `cloudrun-sandbox` + `SandboxBackend`
+ * is `CloudrunSandboxBackend`, not `CloudrunSandboxSandboxBackend`. Words are compared as camel-case
+ * words, case-insensitively; the longest suffix of `base` that is a prefix of `noun` is shared, so
+ * `FooTimerStore` + `TimerStore` is `FooTimerStore` and a name sharing no words is plain concatenation.
+ */
+function joinNoun(base, noun) {
+    const words = (x) => x.split(/(?=[A-Z])/).map((w) => w.toLowerCase());
+    const b = words(base);
+    const n = words(noun);
+    for (let k = Math.min(b.length, n.length); k > 0; k--) {
+        if (b.slice(b.length - k).join("|") === n.slice(0, k).join("|")) {
+            return (base +
+                noun
+                    .split(/(?=[A-Z])/)
+                    .slice(k)
+                    .join(""));
+        }
+    }
+    return base + noun;
+}
+const SEAMS = {
+    store: {
+        key: "store",
+        spi: "EventStore",
+        title: "Durable storage backend (EventStore + SnapshotStore + ArchiveStore [+ BranchRegistry])",
+        wiring: "storage: <name>Storage({ /* … */ })",
+        spiDeps: ["@loomwork/event-runtime", "@loomwork/snapshot-runtime", "@loomwork/plugin-kit"],
+        conformance: [
+            "runEventStoreConformance",
+            "runSnapshotStoreConformance",
+            "runArchiveStoreConformance",
+        ],
+        index: (name) => {
+            const P = (0, codegen_1.pascal)(name);
+            const c = (0, codegen_1.camel)(name);
+            return [
+                "import type {",
+                "  ArchiveExecutionPage,",
+                "  ArchiveSegment,",
+                "  ArchiveSegmentHeader,",
+                "  ArchiveStore,",
+                "  EventStore,",
+                `} from "@loomwork/event-runtime";`,
+                `import type { SnapshotStore } from "@loomwork/snapshot-runtime";`,
+                `import type { CustomStorage } from "@loomwork/plugin-kit";`,
+                "",
+                `export interface ${joinNoun(P, "StorageOptions")} {`,
+                "  /** Whatever your backend needs — a URL, a directory, a token. */",
+                "  url: string;",
+                "  /** Also provision a branch registry for fork/branch (optional). */",
+                "  branching?: boolean;",
+                "}",
+                "",
+                "/**",
+                " * `defineConfig({ storage })` preset. Returns a `custom` storage descriptor with",
+                " * your stores constructed — so `@loomwork/app` never learns your backend exists and a",
+                " * third-party backend wires exactly like a first-party one (ADR 0043).",
+                " */",
+                `export function ${joinNoun(c, "Storage")}(options: ${joinNoun(P, "StorageOptions")}): CustomStorage {`,
+                "  return {",
+                '    kind: "custom",',
+                `    eventStore: new ${joinNoun(P, "EventStore")}(options.url),`,
+                `    snapshotStore: new ${joinNoun(P, "SnapshotStore")}(options.url),`,
+                "    // Compaction MOVES the events it removes here (ADR 0138): without it `compact` refuses.",
+                `    archiveStore: new ${joinNoun(P, "ArchiveStore")}(options.url),`,
+                `    // ...(options.branching === true && { branchRegistry: new ${joinNoun(P, "BranchRegistry")}(options.url) }),`,
+                "  };",
+                "}",
+                "",
+                "// --- Implement the SPIs against your backend; prove them with the conformance",
+                "// kit (see index.test.ts). These stubs exist only so the template type-checks. ---",
+                "",
+                `export class ${joinNoun(P, "EventStore")} implements EventStore {`,
+                "  constructor(private readonly url: string) {}",
+                "  append(): Promise<void> {",
+                "    throw new Error(`not implemented (${this.url})`);",
+                "  }",
+                "  read(): Promise<never[]> {",
+                '    throw new Error("not implemented");',
+                "  }",
+                "  readFrom(): Promise<never[]> {",
+                '    throw new Error("not implemented");',
+                "  }",
+                "  subscribe(): Promise<() => void> {",
+                '    throw new Error("not implemented");',
+                "  }",
+                "  close(): Promise<void> {",
+                "    return Promise.resolve();",
+                "  }",
+                "}",
+                "",
+                `export class ${joinNoun(P, "ArchiveStore")} implements ArchiveStore {`,
+                "  constructor(private readonly url: string) {}",
+                "  append(_executionId: string, _segment: ArchiveSegment): Promise<void> {",
+                "    throw new Error(`not implemented (${this.url})`);",
+                "  }",
+                "  headers(_executionId: string): Promise<ArchiveSegmentHeader[]> {",
+                '    throw new Error("not implemented");',
+                "  }",
+                "  read(_executionId: string): Promise<ArchiveSegment[]> {",
+                '    throw new Error("not implemented");',
+                "  }",
+                "  listExecutions(): Promise<ArchiveExecutionPage> {",
+                '    throw new Error("not implemented");',
+                "  }",
+                "  close(): Promise<void> {",
+                "    return Promise.resolve();",
+                "  }",
+                "}",
+                "",
+                `export class ${joinNoun(P, "SnapshotStore")} implements SnapshotStore {`,
+                "  constructor(private readonly url: string) {}",
+                "  save(): Promise<void> {",
+                "    throw new Error(`not implemented (${this.url})`);",
+                "  }",
+                "  loadLatest(): Promise<null> {",
+                '    throw new Error("not implemented");',
+                "  }",
+                "  loadAt(): Promise<null> {",
+                '    throw new Error("not implemented");',
+                "  }",
+                "  loadLatestBefore(): Promise<null> {",
+                '    throw new Error("not implemented");',
+                "  }",
+                "  close(): Promise<void> {",
+                "    return Promise.resolve();",
+                "  }",
+                "}",
+                "",
+            ].join("\n");
+        },
+        test: (name) => {
+            const P = (0, codegen_1.pascal)(name);
+            const c = (0, codegen_1.camel)(name);
+            return [
+                "// Prove your stores satisfy the SPI with the published conformance kit — this is",
+                '// what makes "plugin" a checkable category (ADR 0043). Wire real backends here.',
+                "//",
+                "// import {",
+                "//   runEventStoreConformance,",
+                "//   runSnapshotStoreConformance,",
+                "//   runArchiveStoreConformance,",
+                '// } from "@loomwork/conformance";',
+                `// import { ${joinNoun(P, "ArchiveStore")}, ${joinNoun(P, "EventStore")}, ${joinNoun(P, "SnapshotStore")} } from "./index";`,
+                "//",
+                `// runEventStoreConformance(() => new ${joinNoun(P, "EventStore")}(":memory:"));`,
+                `// runSnapshotStoreConformance(() => new ${joinNoun(P, "SnapshotStore")}(":memory:"));`,
+                `// runArchiveStoreConformance(() => new ${joinNoun(P, "ArchiveStore")}(":memory:"));`,
+                "",
+                'import { describe, expect, it } from "vitest";',
+                `import { ${joinNoun(c, "Storage")} } from "./index";`,
+                "",
+                `describe("${joinNoun(c, "Storage")} preset", () => {`,
+                '  it("returns a custom storage descriptor", () => {',
+                `    const s = ${joinNoun(c, "Storage")}({ url: ":memory:" });`,
+                '    expect(s.kind).toBe("custom");',
+                "    expect(s.eventStore).toBeDefined();",
+                "    expect(s.snapshotStore).toBeDefined();",
+                "    expect(s.archiveStore).toBeDefined();",
+                "  });",
+                "});",
+                "",
+            ].join("\n");
+        },
+    },
+    dispatcher: {
+        key: "dispatcher",
+        spi: "ExecutionDispatcher",
+        title: "Compute placement (ExecutionDispatcher)",
+        wiring: "execution: { dispatcher: new <Name>Dispatcher({ /* … */ }) }",
+        spiDeps: ["@loomwork/dispatcher"],
+        conformance: ["runExecutionDispatcherConformance"],
+        index: (name) => {
+            const P = (0, codegen_1.pascal)(name);
+            return [
+                "import type {",
+                "  DispatchMetadata,",
+                "  DispatcherHealth,",
+                "  ExecutionDispatcher,",
+                "  ExecutionPackage,",
+                "  ExecutionResult,",
+                `} from "@loomwork/dispatcher";`,
+                "",
+                `export interface ${joinNoun(P, "DispatcherOptions")} {`,
+                "  /** Where/how this dispatcher places work. */",
+                "  endpoint?: string;",
+                "}",
+                "",
+                "/** An `ExecutionDispatcher`: decides WHERE an execution runs. Wire as `dispatcher`. */",
+                `export class ${joinNoun(P, "Dispatcher")} implements ExecutionDispatcher {`,
+                `  constructor(private readonly options: ${joinNoun(P, "DispatcherOptions")} = {}) {}`,
+                "",
+                "  dispatch(pkg: ExecutionPackage, _meta?: DispatchMetadata): Promise<ExecutionResult> {",
+                "    throw new Error(`not implemented: dispatch ${pkg.executionId} to ${this.options.endpoint}`);",
+                "  }",
+                "",
+                "  cancel(_executionId: string): Promise<void> {",
+                "    return Promise.resolve();",
+                "  }",
+                "",
+                "  health(): Promise<DispatcherHealth> {",
+                '    throw new Error("not implemented");',
+                "  }",
+                "}",
+                "",
+            ].join("\n");
+        },
+        test: (name) => {
+            const P = (0, codegen_1.pascal)(name);
+            return [
+                "// Prove your dispatcher with the conformance kit once dispatch() is real:",
+                '// import { runExecutionDispatcherConformance } from "@loomwork/conformance";',
+                `// import { ${joinNoun(P, "Dispatcher")} } from "./index";`,
+                `// runExecutionDispatcherConformance(() => new ${joinNoun(P, "Dispatcher")}());`,
+                "",
+                'import { describe, expect, it } from "vitest";',
+                `import { ${joinNoun(P, "Dispatcher")} } from "./index";`,
+                "",
+                `describe("${joinNoun(P, "Dispatcher")}", () => {`,
+                '  it("constructs and cancel() is a safe no-op", async () => {',
+                `    const d = new ${joinNoun(P, "Dispatcher")}();`,
+                '    await expect(d.cancel("x")).resolves.toBeUndefined();',
+                "  });",
+                "});",
+                "",
+            ].join("\n");
+        },
+    },
+    telemetry: {
+        key: "telemetry",
+        spi: "TelemetryAdapter",
+        title: "Telemetry adapter (flow/step lifecycle hooks)",
+        wiring: "observability: { telemetry: [<name>Telemetry({ /* … */ })] }",
+        spiDeps: ["@loomwork/telemetry"],
+        conformance: [],
+        index: (name) => {
+            const P = (0, codegen_1.pascal)(name);
+            const c = (0, codegen_1.camel)(name);
+            return [
+                `import type { TelemetryAdapter } from "@loomwork/telemetry";`,
+                "",
+                `export interface ${joinNoun(P, "TelemetryOptions")} {`,
+                "  /** e.g. a sink URL, a logger, a sampling rate. */",
+                "  sink?: (line: string) => void;",
+                "}",
+                "",
+                "/**",
+                " * A `TelemetryAdapter`. Every hook is optional — implement the ones you care about.",
+                ` * Wire it as \`observability: { telemetry: [${joinNoun(c, "Telemetry")}()] }\`; \`defineConfig\` composes multiple.`,
+                " */",
+                `export function ${joinNoun(c, "Telemetry")}(options: ${joinNoun(P, "TelemetryOptions")} = {}): TelemetryAdapter {`,
+                "  const emit: (line: string) => void = options.sink ?? (() => {});",
+                "  return {",
+                "    onStepComplete(info) {",
+                "      emit(`step ${info.stepId} ${info.status} in ${info.durationMs ?? 0}ms`);",
+                "    },",
+                "    onStepFail(info) {",
+                "      emit(`step ${info.stepId} FAILED`);",
+                "    },",
+                "  };",
+                "}",
+                "",
+            ].join("\n");
+        },
+        test: (name) => {
+            const P = (0, codegen_1.pascal)(name);
+            const c = (0, codegen_1.camel)(name);
+            return [
+                'import { describe, expect, it } from "vitest";',
+                `import { ${joinNoun(c, "Telemetry")} } from "./index";`,
+                "",
+                `describe("${P} telemetry", () => {`,
+                '  it("emits on step completion", () => {',
+                "    const lines: string[] = [];",
+                `    const t = ${joinNoun(c, "Telemetry")}({ sink: (l) => lines.push(l) });`,
+                "    t.onStepComplete?.({",
+                '      executionId: "e",',
+                '      workflowId: "w",',
+                '      stepId: "s",',
+                "      attempt: 1,",
+                "      startedAt: 0,",
+                '      status: "completed",',
+                "      durationMs: 5,",
+                "    });",
+                '    expect(lines[0]).toContain("step s completed");',
+                "  });",
+                "});",
+                "",
+            ].join("\n");
+        },
+    },
+    middleware: {
+        key: "middleware",
+        spi: "EffectMiddleware",
+        title: "Effect middleware (wrap every effect execution)",
+        wiring: "execution: { effectMiddleware: [<name>Middleware({ /* … */ })] }",
+        spiDeps: ["@loomwork/effect-runtime"],
+        conformance: [],
+        index: (name) => {
+            const P = (0, codegen_1.pascal)(name);
+            const c = (0, codegen_1.camel)(name);
+            return [
+                `import type { EffectMiddleware } from "@loomwork/effect-runtime";`,
+                "",
+                `export interface ${joinNoun(P, "MiddlewareOptions")} {`,
+                "  /** your knobs here */",
+                "  label?: string;",
+                "}",
+                "",
+                "/**",
+                " * An `EffectMiddleware` — an onion layer over every effect. `middleware[0]` is",
+                " * outermost. It runs only for non-completed steps, so it is replay-safe. Wire as",
+                ` * \`execution: { effectMiddleware: [${joinNoun(c, "Middleware")}()] }\`; order is behavioural, so document where`,
+                " * yours belongs relative to retry/metering.",
+                " *",
+                " * STREAMING (ADR 0119): if this middleware REJECTS or REWRITES the effect's output after",
+                " * `next()`, a streamed delta would bypass it. It MUST then be marked `inspectsOutput: true`",
+                " * (the runtime then disables live streaming for the call, fail-closed) or provide a",
+                " * `deltaGuard` that checks the running text. Leave both unset only if you never alter or",
+                " * refuse the output.",
+                " */",
+                `export function ${joinNoun(c, "Middleware")}(options: ${joinNoun(P, "MiddlewareOptions")} = {}): EffectMiddleware {`,
+                `  const label = options.label ?? "${name}";`,
+                "  return async (ctx, input, next) => {",
+                "    // before: inspect ctx.stepId / ctx.attempt / ctx.emit(...)",
+                "    void label;",
+                "    const result = await next(input);",
+                "    // after: inspect / transform result",
+                "    return result;",
+                "  };",
+                "}",
+                "",
+            ].join("\n");
+        },
+        test: (name) => {
+            const P = (0, codegen_1.pascal)(name);
+            const c = (0, codegen_1.camel)(name);
+            return [
+                'import { describe, expect, it } from "vitest";',
+                `import { ${joinNoun(c, "Middleware")} } from "./index";`,
+                "",
+                `describe("${P} middleware", () => {`,
+                '  it("passes the effect result through", async () => {',
+                `    const mw = ${joinNoun(c, "Middleware")}();`,
+                "    const ctx = {",
+                '      executionId: "e",',
+                '      stepId: "s",',
+                '      workflowId: "w",',
+                "      attempt: 1,",
+                "      emit: () => {},",
+                "    };",
+                "    // biome-ignore lint/suspicious/noExplicitAny: minimal EffectContext for the test",
+                "    const out = await mw(ctx as any, 42, async (i) => i);",
+                "    expect(out).toBe(42);",
+                "  });",
+                "});",
+                "",
+            ].join("\n");
+        },
+    },
+    timer: {
+        key: "timer",
+        spi: "TimerStore",
+        title: "Durable timer store (T1 scheduled wakes)",
+        wiring: "timers: { store: new <Name>TimerStore() }",
+        spiDeps: ["@loomwork/event-runtime"],
+        conformance: ["runTimerStoreConformance"],
+        index: (name) => {
+            const P = (0, codegen_1.pascal)(name);
+            return [
+                'import type { TimerRecord, TimerStore } from "@loomwork/event-runtime";',
+                "",
+                "/** A `TimerStore` — the findable half of `ctx.sleep`. Wire as `timers: { store }`. */",
+                `export class ${joinNoun(P, "TimerStore")} implements TimerStore {`,
+                "  schedule(_timer: TimerRecord): Promise<void> {",
+                '    throw new Error("not implemented");',
+                "  }",
+                "  due(_now: number, _limit?: number): Promise<TimerRecord[]> {",
+                '    throw new Error("not implemented");',
+                "  }",
+                "  complete(_executionId: string, _wakeAt: number): Promise<void> {",
+                '    throw new Error("not implemented");',
+                "  }",
+                "  close(): Promise<void> {",
+                "    return Promise.resolve();",
+                "  }",
+                "}",
+                "",
+            ].join("\n");
+        },
+        test: (name) => {
+            const P = (0, codegen_1.pascal)(name);
+            return [
+                "// Prove your timer store with the conformance kit once the methods are real:",
+                '// import { runTimerStoreConformance } from "@loomwork/conformance";',
+                `// import { ${joinNoun(P, "TimerStore")} } from "./index";`,
+                `// runTimerStoreConformance(() => new ${joinNoun(P, "TimerStore")}());`,
+                "",
+                'import { describe, expect, it } from "vitest";',
+                `import { ${joinNoun(P, "TimerStore")} } from "./index";`,
+                "",
+                `describe("${joinNoun(P, "TimerStore")}", () => {`,
+                '  it("constructs", () => {',
+                `    expect(new ${joinNoun(P, "TimerStore")}()).toBeDefined();`,
+                "  });",
+                "});",
+                "",
+            ].join("\n");
+        },
+    },
+    lease: {
+        key: "lease",
+        spi: "LeaseStore",
+        title: "Execution ownership leases (#380 — claim before waking)",
+        wiring: 'timers: { store, leases: { store: new <Name>LeaseStore(), owner: "node-1" } }',
+        spiDeps: ["@loomwork/event-runtime"],
+        conformance: ["runLeaseStoreConformance"],
+        index: (name) => {
+            const P = (0, codegen_1.pascal)(name);
+            return [
+                'import type { Lease, LeaseStore } from "@loomwork/event-runtime";',
+                "",
+                "/**",
+                " * A `LeaseStore` — who owns an execution right now.",
+                " *",
+                " * The three return values carry the whole contract, and getting one of them wrong is",
+                " * how a lease store causes the split-brain it exists to prevent:",
+                " *",
+                " * - `acquire` returns `null` when ANOTHER owner holds an unexpired lease. Re-acquiring",
+                " *   one you already hold is a renewal, not a conflict — a node that restarts must be",
+                " *   able to take back its own work.",
+                " * - `renew` returns `false` when ownership was lost. Never resurrect a lease another",
+                " *   owner has taken: a caller that keeps working on `false` is the split-brain.",
+                " * - `expired` is the evidence an execution was orphaned — soonest-expired first.",
+                " *",
+                " * The optional `get` answers a different question from `expired`: *is anything watching",
+                " * this execution at all*. An execution that never had a lease is invisible to `expired`,",
+                " * and it is not orphaned — it is unwatched (`loom census` counts those separately).",
+                " *",
+                " * OPTIONAL batch methods (SPI 2.2.0): `acquireMany`, `renewMany` (returns the HELD set) and",
+                " * `releaseMany`. Implement all three or none; they are NOT emitted here (a throwing stub",
+                " * would advertise a capability this store does not have), so the conformance call below",
+                " * passes no `spiVersion`. `steal` is single-id `acquire` only (`acquireMany` rejects it).",
+                " *",
+                " * Implement against a store with an atomic compare-and-set; the first-party SQLite and",
+                " * Postgres stores each do it in ONE statement, because a read-then-write is exactly the",
+                " * race this is meant to close.",
+                " */",
+                `export class ${joinNoun(P, "LeaseStore")} implements LeaseStore {`,
+                "  acquire(",
+                "    _executionId: string,",
+                "    _owner: string,",
+                "    _ttlMs: number,",
+                "    _now?: number",
+                "  ): Promise<Lease | null> {",
+                '    throw new Error("not implemented");',
+                "  }",
+                "  renew(_executionId: string, _owner: string, _ttlMs: number, _now?: number): Promise<boolean> {",
+                '    throw new Error("not implemented");',
+                "  }",
+                "  expired(_now?: number, _limit?: number): Promise<Lease[]> {",
+                '    throw new Error("not implemented");',
+                "  }",
+                "  release(_executionId: string, _owner: string): Promise<void> {",
+                '    throw new Error("not implemented");',
+                "  }",
+                "  /** Optional. Omit it and `loom census` reports coverage as unknown rather than zero. */",
+                "  get(_executionId: string): Promise<Lease | null> {",
+                '    throw new Error("not implemented");',
+                "  }",
+                "  close(): Promise<void> {",
+                "    return Promise.resolve();",
+                "  }",
+                "}",
+                "",
+            ].join("\n");
+        },
+        test: (name) => {
+            const P = (0, codegen_1.pascal)(name);
+            return [
+                "// Prove your lease store with the conformance kit once the methods are real. Do not",
+                "// skip it: the kit covers the concurrent cases (two owners racing, renewal after",
+                "// expiry, release by a non-owner) that a hand-written test usually misses.",
+                '// import { runLeaseStoreConformance } from "@loomwork/conformance";',
+                `// import { ${joinNoun(P, "LeaseStore")} } from "./index";`,
+                `// runLeaseStoreConformance(() => new ${joinNoun(P, "LeaseStore")}());`,
+                "",
+                'import { describe, expect, it } from "vitest";',
+                `import { ${joinNoun(P, "LeaseStore")} } from "./index";`,
+                "",
+                `describe("${joinNoun(P, "LeaseStore")}", () => {`,
+                '  it("constructs", () => {',
+                `    expect(new ${joinNoun(P, "LeaseStore")}()).toBeDefined();`,
+                "  });",
+                "});",
+                "",
+            ].join("\n");
+        },
+    },
+    content: {
+        key: "content",
+        spi: "ContentStore",
+        title: "Content-addressed blob store (claim-check payloads)",
+        wiring: "claimCheckMiddleware({ store: new <Name>ContentStore(), inlineCapBytes: 16 * 1024 })",
+        spiDeps: ["@loomwork/plugin-content"],
+        conformance: ["runContentStoreConformance"],
+        index: (name) => {
+            const P = (0, codegen_1.pascal)(name);
+            return [
+                'import type { ContentRef, ContentStore } from "@loomwork/plugin-content";',
+                "",
+                "/**",
+                " * A `ContentStore` — where a claim-check payload actually lives (ADR 0046).",
+                " *",
+                " * Content-ADDRESSED: `put` is keyed by the hash of the bytes, so storing the same",
+                " * payload twice is one object and a retry is free. That is what makes the store safe",
+                " * to call from a replayed effect.",
+                " *",
+                " * `get` returns `null` for an absent ref and MUST NOT throw: a missing blob is a fact",
+                " * the caller handles (the log still has the digest), not an exception that aborts a",
+                " * replay. `delete` is idempotent PHYSICAL erasure — it is the K10 shredding path, so",
+                " * deleting what is already gone must succeed rather than object.",
+                " */",
+                `export class ${joinNoun(P, "ContentStore")} implements ContentStore {`,
+                "  put(_bytes: Uint8Array): Promise<ContentRef> {",
+                '    throw new Error("not implemented");',
+                "  }",
+                "  get(_ref: ContentRef): Promise<Uint8Array | null> {",
+                '    throw new Error("not implemented");',
+                "  }",
+                "  delete(_ref: ContentRef): Promise<void> {",
+                '    throw new Error("not implemented");',
+                "  }",
+                "  // Optional, and worth implementing where the backend has them natively:",
+                "  //   putStream(stream: AsyncIterable<Uint8Array>): Promise<ContentRef>  — ADR 0059",
+                "  //   getMany(refs: readonly ContentRef[]): Promise<(Uint8Array | null)[]> — ADR 0062",
+                "  //   deleteIfUntouchedSince(ref: ContentRef, cutoffMs: number): Promise<boolean>",
+                "  //   listPage(opts: ContentListPageOptions): Promise<ContentListPage>  — ADR 0055 D5/D6",
+                "  //   touchClock(): Promise<number>  — now, on the clock you stamp touch times with",
+                "  //   touch(addresses: readonly string[]): Promise<string[]>  — SPI 1.4.0: bump touch times",
+                "  //     WITHOUT a put (max); unknown addresses are a no-op, resolved as the missing list.",
+                "  //     `loom sweep content --orphans --apply` REFUSES a store without it (forks and appends",
+                "  //     that carry a ref call it).",
+                "  // Implement the first three TOGETHER (the kit fails a partial set), and then EVERY put must",
+                "  // bump the blob's touch time, never backwards, even for bytes you already hold",
+                "  // (ON CONFLICT DO UPDATE, not INSERT OR IGNORE): they make `loom sweep content`",
+                "  // race-safe and let it reclaim orphans.",
+                "  // Left out rather than stubbed: a throwing optional method is worse than an absent",
+                "  // one, because callers feature-detect it.",
+                "}",
+                "",
+            ].join("\n");
+        },
+        test: (name) => {
+            const P = (0, codegen_1.pascal)(name);
+            return [
+                "// Prove it with the kit once the methods are real — it covers the idempotence that",
+                "// content addressing depends on (same bytes twice, delete twice, get after delete):",
+                '// import { runContentStoreConformance } from "@loomwork/conformance";',
+                `// import { ${joinNoun(P, "ContentStore")} } from "./index";`,
+                `// runContentStoreConformance(() => new ${joinNoun(P, "ContentStore")}());`,
+                "",
+                'import { describe, expect, it } from "vitest";',
+                `import { ${joinNoun(P, "ContentStore")} } from "./index";`,
+                "",
+                `describe("${joinNoun(P, "ContentStore")}", () => {`,
+                '  it("constructs", () => {',
+                `    expect(new ${joinNoun(P, "ContentStore")}()).toBeDefined();`,
+                "  });",
+                "});",
+                "",
+            ].join("\n");
+        },
+    },
+    "durable-state": {
+        key: "durable-state",
+        spi: "DurableStateStore",
+        title: "Carry state across executions (compare-and-set)",
+        wiring: 'durableState({ id: "carry", version: 1, schema, store: new <Name>DurableStateStore() })',
+        spiDeps: ["@loomwork/plugin-durable-state"],
+        conformance: ["runDurableStateStoreConformance"],
+        index: (name) => {
+            const P = (0, codegen_1.pascal)(name);
+            return [
+                'import type { DurableStateRecord, DurableStateStore } from "@loomwork/plugin-durable-state";',
+                "",
+                "/**",
+                " * A `DurableStateStore` — state that OUTLIVES one execution (a sentinel's carry).",
+                " *",
+                " * `save` is a compare-and-set on `expectedRevision`, and that is the whole point: two",
+                " * nodes finishing the same sentinel run must not silently overwrite each other. A",
+                " * mismatch REJECTS rather than wins; the caller re-reads and decides. Implement it as",
+                " * one conditional statement, not read-then-write, or the race you are closing is the",
+                " * race you introduce.",
+                " *",
+                " * `load` returns `null` when the key was never written — distinct from a record whose",
+                " * payload happens to be empty.",
+                " */",
+                `export class ${joinNoun(P, "DurableStateStore")} implements DurableStateStore {`,
+                "  load(_key: string): Promise<DurableStateRecord | null> {",
+                '    throw new Error("not implemented");',
+                "  }",
+                "  save(",
+                "    _key: string,",
+                "    _value: { contractVersion: number; payload: unknown },",
+                "    _expectedRevision: number",
+                "  ): Promise<DurableStateRecord> {",
+                '    throw new Error("not implemented");',
+                "  }",
+                "  clear(_key: string): Promise<void> {",
+                '    throw new Error("not implemented");',
+                "  }",
+                "  close(): Promise<void> {",
+                "    return Promise.resolve();",
+                "  }",
+                "}",
+                "",
+            ].join("\n");
+        },
+        test: (name) => {
+            const P = (0, codegen_1.pascal)(name);
+            return [
+                "// The kit covers the concurrent compare-and-set cases a hand-written test misses:",
+                '// import { runDurableStateStoreConformance } from "@loomwork/conformance";',
+                `// import { ${joinNoun(P, "DurableStateStore")} } from "./index";`,
+                `// runDurableStateStoreConformance(() => new ${joinNoun(P, "DurableStateStore")}());`,
+                "",
+                'import { describe, expect, it } from "vitest";',
+                `import { ${joinNoun(P, "DurableStateStore")} } from "./index";`,
+                "",
+                `describe("${joinNoun(P, "DurableStateStore")}", () => {`,
+                '  it("constructs", () => {',
+                `    expect(new ${joinNoun(P, "DurableStateStore")}()).toBeDefined();`,
+                "  });",
+                "});",
+                "",
+            ].join("\n");
+        },
+    },
+    "read-model": {
+        key: "read-model",
+        spi: "ReadModelStore",
+        title: "Durable cross-execution query layer (ADR 0058)",
+        wiring: "new ReadModelService(new <Name>ReadModelStore())",
+        spiDeps: ["@loomwork/plugin-read-model"],
+        conformance: ["runReadModelStoreConformance"],
+        index: (name) => {
+            const P = (0, codegen_1.pascal)(name);
+            return [
+                "import type {",
+                "  ReadModelPage,",
+                "  ReadModelQuery,",
+                "  ReadModelRow,",
+                "  ReadModelStore,",
+                '} from "@loomwork/plugin-read-model";',
+                "",
+                "/**",
+                " * A `ReadModelStore` — the durable index behind cross-execution queries (ADR 0058).",
+                " *",
+                " * Two properties carry it, and both are about REPLAY rather than about querying:",
+                " *",
+                " * - `apply` is idempotent per `rowId`. A catch-up re-reads events the store already",
+                " *   saw, so applying the same row twice must leave one row, not two.",
+                " * - the watermark is MONOTONIC. `apply` advances it to `upToSequence` atomically with",
+                " *   the rows; if the rows land and the watermark does not, the next pass re-applies",
+                " *   them (fine), but the reverse loses them forever.",
+                " *",
+                " * `query` pages by KEYSET, not offset: a read model grows while you page through it.",
+                " */",
+                `export class ${joinNoun(P, "ReadModelStore")} implements ReadModelStore {`,
+                "  apply(",
+                "    _modelId: string,",
+                "    _executionId: string,",
+                "    _upToSequence: number,",
+                "    _rows: readonly ReadModelRow[]",
+                "  ): Promise<void> {",
+                '    throw new Error("not implemented");',
+                "  }",
+                "  watermark(_modelId: string, _executionId: string): Promise<number | null> {",
+                '    throw new Error("not implemented");',
+                "  }",
+                "  watermarkedExecutions(_modelId: string): Promise<string[]> {",
+                '    throw new Error("not implemented");',
+                "  }",
+                "  query(_modelId: string, _q?: ReadModelQuery): Promise<ReadModelPage> {",
+                '    throw new Error("not implemented");',
+                "  }",
+                "  clear(_modelId: string): Promise<void> {",
+                '    throw new Error("not implemented");',
+                "  }",
+                "  close(): Promise<void> {",
+                "    return Promise.resolve();",
+                "  }",
+                "}",
+                "",
+            ].join("\n");
+        },
+        test: (name) => {
+            const P = (0, codegen_1.pascal)(name);
+            return [
+                "// The kit covers idempotent re-apply and watermark monotonicity — the two things a",
+                "// read model is wrong about silently:",
+                '// import { runReadModelStoreConformance } from "@loomwork/conformance";',
+                `// import { ${joinNoun(P, "ReadModelStore")} } from "./index";`,
+                `// runReadModelStoreConformance(() => new ${joinNoun(P, "ReadModelStore")}());`,
+                "",
+                'import { describe, expect, it } from "vitest";',
+                `import { ${joinNoun(P, "ReadModelStore")} } from "./index";`,
+                "",
+                `describe("${joinNoun(P, "ReadModelStore")}", () => {`,
+                '  it("constructs", () => {',
+                `    expect(new ${joinNoun(P, "ReadModelStore")}()).toBeDefined();`,
+                "  });",
+                "});",
+                "",
+            ].join("\n");
+        },
+    },
+    keystore: {
+        key: "keystore",
+        spi: "KeyStore",
+        title: "Per-subject encryption keys (K10 crypto-shredding)",
+        wiring: "new EncryptingEventStore(inner, new <Name>KeyStore(), { sensitive })",
+        spiDeps: ["@loomwork/plugin-crypto"],
+        conformance: ["runKeyStoreConformance"],
+        index: (name) => {
+            const P = (0, codegen_1.pascal)(name);
+            return [
+                'import type { KeyStore } from "@loomwork/plugin-crypto";',
+                "",
+                "/**",
+                " * A `KeyStore` — one encryption key per subject, and therefore the erasure boundary.",
+                " *",
+                " * `destroy` is IRREVERSIBLE and is how loom honours an erasure request without",
+                " * rewriting an append-only log: destroy the key and the subject's events become",
+                " * undecryptable everywhere at once, including in backups you cannot reach. There is no",
+                " * undo, so back this with a KMS/HSM in production rather than with a table you might",
+                " * restore from a snapshot.",
+                " *",
+                " * `get` returns `null` both for a key never created AND for one destroyed — the caller",
+                " * cannot distinguish them, deliberately: after shredding there is nothing true to say.",
+                " *",
+                " * `getOrCreate` MUST be an ATOMIC create-if-absent across every caller and node (a conditional",
+                " * write, e.g. INSERT ... ON CONFLICT DO NOTHING then re-read), never get -> write: two racing",
+                " * first calls must get the SAME key, or an erasure destroys one and the other stays readable.",
+                " */",
+                `export class ${joinNoun(P, "KeyStore")} implements KeyStore {`,
+                "  getOrCreate(_subjectId: string): Promise<Buffer> {",
+                '    throw new Error("not implemented");',
+                "  }",
+                "  get(_subjectId: string): Promise<Buffer | null> {",
+                '    throw new Error("not implemented");',
+                "  }",
+                "  destroy(_subjectId: string): Promise<void> {",
+                '    throw new Error("not implemented");',
+                "  }",
+                "  // OPTIONAL, left out until implemented (conformance skips a store without it): true only",
+                "  // if THIS store destroyed the subject's key (persist the tombstone), so a retry can prove",
+                "  // destruction. Uncomment and implement it; do not stub it to return true.",
+                "  // wasDestroyed(_subjectId: string): Promise<boolean> {",
+                '  //   throw new Error("not implemented");',
+                "  // }",
+                "}",
+                "",
+            ].join("\n");
+        },
+        test: (name) => {
+            const P = (0, codegen_1.pascal)(name);
+            return [
+                "// The kit covers the irreversibility: get-after-destroy is null, and getOrCreate does",
+                "// NOT resurrect a shredded subject.",
+                '// import { runKeyStoreConformance } from "@loomwork/conformance";',
+                `// import { ${joinNoun(P, "KeyStore")} } from "./index";`,
+                `// runKeyStoreConformance(() => new ${joinNoun(P, "KeyStore")}());`,
+                "",
+                'import { describe, expect, it } from "vitest";',
+                `import { ${joinNoun(P, "KeyStore")} } from "./index";`,
+                "",
+                `describe("${joinNoun(P, "KeyStore")}", () => {`,
+                '  it("constructs", () => {',
+                `    expect(new ${joinNoun(P, "KeyStore")}()).toBeDefined();`,
+                "  });",
+                "});",
+                "",
+            ].join("\n");
+        },
+    },
+    memory: {
+        key: "memory",
+        spi: "MemoryStore",
+        title: "Agent memory store (scoped entries, optional relevance search)",
+        wiring: "memoryStore: new <Name>MemoryStore()",
+        spiDeps: ["@loomwork/memory"],
+        conformance: ["runMemoryStoreConformance"],
+        index: (name) => {
+            const P = (0, codegen_1.pascal)(name);
+            return [
+                'import type { MemoryEntry, MemoryStore } from "@loomwork/memory";',
+                "",
+                "/**",
+                " * A `MemoryStore` — durable agent memory. Wire as `memoryStore`.",
+                " *",
+                " * A key names an ORDERED LIST of entries. `read` returns them in APPEND order,",
+                " * not timestamp order: entries routinely share a timestamp (one turn written in",
+                " * one tick), so a backend needs an insertion key of its own. An absent key reads",
+                " * as `[]`, never a throw, and `clear` is idempotent.",
+                " *",
+                " * An entry may carry a caller-assigned `id`, and round-tripping it is REQUIRED —",
+                " * appended with one it reads back with the same one, appended without one it reads",
+                " * back with NONE (`{ content }` must not become `{ id: null, content }`). This is",
+                " * the field a backend that decomposes an entry into columns forgets, and the",
+                " * forgetting is silent: removal above the SPI matches on the id `read` gives back,",
+                " * so a dropped id turns a delete into a no-op rather than an error.",
+                " *",
+                " * The other four are OPTIONAL, and PRESENCE IS THE FEATURE FLAG:",
+                " * the runtime tests for the method and falls back when it is missing. A stub that",
+                " * throws is therefore worse than no stub at all — it would advertise a capability",
+                " * the store does not have. Add each one only when you implement it:",
+                " *",
+                " *   replace(key, entries)  atomic whole-list rewrite. Without it, eviction is",
+                " *                          clear-then-re-append, and a crash between the two loses",
+                " *                          the scope.",
+                " *   search(key, query, o)  relevance retrieval, best first — what separates memory",
+                " *                          from the tail of a conversation. Index",
+                " *                          `searchableText(entry)` and split terms with `tokenize`",
+                " *                          (both exported by @loomwork/memory), because what gets",
+                " *                          indexed and what counts as a term are the contract.",
+                " *   remove(key, ids)       delete named entries, survivors keeping append order.",
+                " *                          Idempotent; an entry with NO id is never removed by any",
+                " *                          list of ids. Without it, the runtime rewrites the whole",
+                " *                          key instead — correct, and O(scope) per document edit.",
+                " *   close()                release a handle or a pool.",
+                " *",
+                " * `runMemoryStoreConformance` covers the required verbs and skips the optional",
+                " * ones you have not added.",
+                " */",
+                `export class ${joinNoun(P, "MemoryStore")} implements MemoryStore {`,
+                "  append(_key: string, _entry: MemoryEntry): Promise<void> {",
+                '    throw new Error("not implemented");',
+                "  }",
+                "  read(_key: string): Promise<MemoryEntry[]> {",
+                '    throw new Error("not implemented");',
+                "  }",
+                "  clear(_key: string): Promise<void> {",
+                '    throw new Error("not implemented");',
+                "  }",
+                "}",
+                "",
+            ].join("\n");
+        },
+        test: (name) => {
+            const P = (0, codegen_1.pascal)(name);
+            return [
+                "// Prove your memory store with the conformance kit once the methods are real:",
+                '// import { runMemoryStoreConformance } from "@loomwork/conformance";',
+                `// import { ${joinNoun(P, "MemoryStore")} } from "./index";`,
+                `// runMemoryStoreConformance(() => new ${joinNoun(P, "MemoryStore")}());`,
+                "",
+                'import { describe, expect, it } from "vitest";',
+                `import { ${joinNoun(P, "MemoryStore")} } from "./index";`,
+                "",
+                `describe("${joinNoun(P, "MemoryStore")}", () => {`,
+                '  it("constructs", () => {',
+                `    expect(new ${joinNoun(P, "MemoryStore")}()).toBeDefined();`,
+                "  });",
+                "});",
+                "",
+            ].join("\n");
+        },
+    },
+    projection: {
+        key: "projection",
+        spi: "ProjectionRuntime",
+        title: "Projection runtime (custom read-model backend)",
+        wiring: "projectionRuntime: new <Name>ProjectionRuntime()",
+        spiDeps: ["@loomwork/core", "@loomwork/projection-runtime"],
+        conformance: ["runProjectionRuntimeConformance"],
+        index: (name) => {
+            const P = (0, codegen_1.pascal)(name);
+            return [
+                'import type { EventEnvelope } from "@loomwork/core";',
+                'import type { Projection, ProjectionRuntime } from "@loomwork/projection-runtime";',
+                "",
+                "/** A `ProjectionRuntime` — folds events into read-models. Wire as `projectionRuntime`. */",
+                `export class ${joinNoun(P, "ProjectionRuntime")} implements ProjectionRuntime {`,
+                "  register<TState>(_projection: Projection<TState>): void {",
+                '    throw new Error("not implemented");',
+                "  }",
+                "  getState<TState>(_projectionId: string, _executionId: string): TState {",
+                '    throw new Error("not implemented");',
+                "  }",
+                "  subscribe<TState>(",
+                "    _projectionId: string,",
+                "    _executionId: string,",
+                "    _handler: (state: TState) => void",
+                "  ): () => void {",
+                '    throw new Error("not implemented");',
+                "  }",
+                "  /**",
+                "   * Slice-scoped subscription (ADR 0068). Change-only, exactly like `subscribe`: it",
+                "   * does NOT fire on subscribe, and the last slice is seeded from current state so the",
+                "   * first handler call is the first genuine change.",
+                "   */",
+                "  subscribeSelector<TState, TSlice>(",
+                "    _projectionId: string,",
+                "    _executionId: string,",
+                "    _selector: (state: TState) => TSlice,",
+                "    _handler: (slice: TSlice) => void,",
+                "    _isEqual?: (a: TSlice, b: TSlice) => boolean",
+                "  ): () => void {",
+                '    throw new Error("not implemented");',
+                "  }",
+                "  handleEvent(_event: EventEnvelope): void {",
+                '    throw new Error("not implemented");',
+                "  }",
+                "  seedState(_projectionId: string, _executionId: string, _state: unknown): void {",
+                '    throw new Error("not implemented");',
+                "  }",
+                "}",
+                "",
+            ].join("\n");
+        },
+        test: (name) => {
+            const P = (0, codegen_1.pascal)(name);
+            return [
+                "// Prove your projection runtime with the conformance kit once methods are real:",
+                '// import { runProjectionRuntimeConformance } from "@loomwork/conformance";',
+                `// import { ${joinNoun(P, "ProjectionRuntime")} } from "./index";`,
+                `// runProjectionRuntimeConformance(() => new ${joinNoun(P, "ProjectionRuntime")}());`,
+                "",
+                'import { describe, expect, it } from "vitest";',
+                `import { ${joinNoun(P, "ProjectionRuntime")} } from "./index";`,
+                "",
+                `describe("${joinNoun(P, "ProjectionRuntime")}", () => {`,
+                '  it("constructs", () => {',
+                `    expect(new ${joinNoun(P, "ProjectionRuntime")}()).toBeDefined();`,
+                "  });",
+                "});",
+                "",
+            ].join("\n");
+        },
+    },
+    worker: {
+        key: "worker",
+        spi: "WorkerRuntime",
+        title: "Worker runtime (run an execution on some compute)",
+        wiring: "execution: { dispatcher: new LocalDispatcher(new <Name>Worker()) }",
+        spiDeps: ["@loomwork/worker-runtime"],
+        conformance: ["runWorkerRuntimeConformance"],
+        index: (name) => {
+            const P = (0, codegen_1.pascal)(name);
+            return [
+                "import type {",
+                "  ExecutionPackage,",
+                "  ExecutionResult,",
+                "  WorkerLease,",
+                "  WorkerRequest,",
+                "  WorkerRuntime,",
+                '} from "@loomwork/worker-runtime";',
+                "",
+                "/** A `WorkerRuntime` — runs an ExecutionPackage on some compute; wrap it in a dispatcher. */",
+                `export class ${joinNoun(P, "Worker")} implements WorkerRuntime {`,
+                "  allocate(request: WorkerRequest): Promise<WorkerLease> {",
+                "    return Promise.resolve({ leaseId: `lease-${request.executionId}` });",
+                "  }",
+                "  execute(_lease: WorkerLease, pkg: ExecutionPackage): Promise<ExecutionResult> {",
+                "    throw new Error(`not implemented: execute ${pkg.executionId}`);",
+                "  }",
+                "  release(_lease: WorkerLease): Promise<void> {",
+                "    return Promise.resolve();",
+                "  }",
+                "}",
+                "",
+            ].join("\n");
+        },
+        test: (name) => {
+            const P = (0, codegen_1.pascal)(name);
+            return [
+                "// Prove your worker with the conformance kit once execute() is real — it needs a",
+                "// package your worker can run, so the factory returns { worker, pkg }:",
+                '// import { runWorkerRuntimeConformance } from "@loomwork/conformance";',
+                `// import { ${joinNoun(P, "Worker")} } from "./index";`,
+                `// runWorkerRuntimeConformance(() => ({ worker: new ${joinNoun(P, "Worker")}(), pkg: /* runnable ExecutionPackage */ }));`,
+                "",
+                'import { describe, expect, it } from "vitest";',
+                `import { ${joinNoun(P, "Worker")} } from "./index";`,
+                "",
+                `describe("${joinNoun(P, "Worker")}", () => {`,
+                '  it("allocate returns a lease", async () => {',
+                `    const lease = await new ${joinNoun(P, "Worker")}().allocate({ executionId: "e" });`,
+                '    expect(typeof lease.leaseId).toBe("string");',
+                "  });",
+                "});",
+                "",
+            ].join("\n");
+        },
+    },
+    llm: {
+        key: "llm",
+        spi: "LlmProvider",
+        title: "LLM provider (model backend)",
+        wiring: "createLlmEffect({ provider: new <Name>Provider() })",
+        spiDeps: ["@loomwork/llm"],
+        conformance: ["runLlmProviderConformance"],
+        index: (name) => {
+            const P = (0, codegen_1.pascal)(name);
+            return [
+                'import { assertRequestSupported } from "@loomwork/llm";',
+                'import type { LlmCapabilities, LlmProvider, LlmRequest, LlmResponse } from "@loomwork/llm";',
+                "",
+                "/** An `LlmProvider` — wire via `createLlmEffect({ provider })` or an agent's `provider`. */",
+                `export class ${joinNoun(P, "Provider")} implements LlmProvider {`,
+                "  // Media this provider accepts (R5). ABSENT = text + tool calls only; declare e.g.",
+                '  // `{ image: ["image/png", "image/jpeg"] }` and map the parts in complete().',
+                "  readonly capabilities?: LlmCapabilities;",
+                "",
+                "  async complete(request: LlmRequest): Promise<LlmResponse> {",
+                "    // Fail closed on an undeclared modality BEFORE any network call.",
+                `    assertRequestSupported(request, this.capabilities, "${joinNoun(P, "Provider")}");`,
+                "    // Message content is `string | LlmContentPart[]` — read it with `textOf` / `toParts`.",
+                "    throw new Error(`not implemented: complete (${request.messages.length} messages)`);",
+                "  }",
+                "  // stream?(request: LlmRequest): AsyncIterable<LlmStreamChunk> — optional",
+                "  // warm?(): void | Promise<void> — optional advisory pre-warm",
+                "}",
+                "",
+            ].join("\n");
+        },
+        test: (name) => {
+            const P = (0, codegen_1.pascal)(name);
+            return [
+                "// Prove your provider with the conformance kit once complete() is real:",
+                '// import { runLlmProviderConformance } from "@loomwork/conformance";',
+                `// import { ${joinNoun(P, "Provider")} } from "./index";`,
+                "//",
+                "// A `toolRequest` this provider answers WITH a tool call is REQUIRED once it has",
+                "// `stream` — without one the kit fails (an unproven tool-call parity is a refusal,",
+                "// not a pass). A provider that never calls tools opts out with `toolRequest: null`.",
+                `// runLlmProviderConformance(() => new ${joinNoun(P, "Provider")}(), "${joinNoun(P, "Provider")}", { toolRequest: someToolRequest });`,
+                "",
+                'import { describe, expect, it } from "vitest";',
+                `import { ${joinNoun(P, "Provider")} } from "./index";`,
+                "",
+                `describe("${joinNoun(P, "Provider")}", () => {`,
+                '  it("constructs", () => {',
+                `    expect(new ${joinNoun(P, "Provider")}()).toBeDefined();`,
+                "  });",
+                "});",
+                "",
+            ].join("\n");
+        },
+    },
+    authorizer: {
+        key: "authorizer",
+        spi: "CapabilityAuthorizer",
+        title: "Capability authorizer (allow/deny each effect)",
+        wiring: "security: { authorizer: new <Name>Authorizer() }",
+        spiDeps: ["@loomwork/effect-runtime"],
+        conformance: ["runCapabilityAuthorizerConformance"],
+        index: (name) => {
+            const P = (0, codegen_1.pascal)(name);
+            return [
+                "import type {",
+                "  CapabilityAuthorizer,",
+                "  CapabilityDecision,",
+                "  CapabilityRequest,",
+                '} from "@loomwork/effect-runtime";',
+                "",
+                "/** A `CapabilityAuthorizer` — allow/deny each effect. Wire as `authorizer`. */",
+                `export class ${joinNoun(P, "Authorizer")} implements CapabilityAuthorizer {`,
+                "  authorize(req: CapabilityRequest): CapabilityDecision {",
+                "    // TODO: your policy. Default-deny is the safe placeholder.",
+                "    return { allowed: false, reason: `not implemented (${req.toolId})` };",
+                "  }",
+                "}",
+                "",
+            ].join("\n");
+        },
+        test: (name) => {
+            const P = (0, codegen_1.pascal)(name);
+            return [
+                "// Prove your authorizer with the conformance kit (decision shape + determinism):",
+                '// import { runCapabilityAuthorizerConformance } from "@loomwork/conformance";',
+                `// import { ${joinNoun(P, "Authorizer")} } from "./index";`,
+                `// runCapabilityAuthorizerConformance(() => new ${joinNoun(P, "Authorizer")}());`,
+                "",
+                'import { describe, expect, it } from "vitest";',
+                `import { ${joinNoun(P, "Authorizer")} } from "./index";`,
+                "",
+                `describe("${joinNoun(P, "Authorizer")}", () => {`,
+                '  it("returns a boolean decision", () => {',
+                `    const d = new ${joinNoun(P, "Authorizer")}().authorize({`,
+                '      toolId: "t",',
+                '      executionId: "e",',
+                '      workflowId: "w",',
+                '      stepId: "s",',
+                "    });",
+                '    expect(typeof d.allowed).toBe("boolean");',
+                "  });",
+                "});",
+                "",
+            ].join("\n");
+        },
+    },
+    "execution-authorizer": {
+        key: "execution-authorizer",
+        spi: "ExecutionAuthorizer",
+        title: "Execution-lifecycle authorizer (start/resume/cancel/query)",
+        wiring: "security: { executionAuthorizer: new <Name>ExecutionAuthorizer() }",
+        spiDeps: ["@loomwork/workflow-runtime"],
+        conformance: ["runExecutionAuthorizerConformance"],
+        index: (name) => {
+            const P = (0, codegen_1.pascal)(name);
+            return [
+                "import type {",
+                "  ExecutionAuthorizer,",
+                "  ExecutionAuthzRequest,",
+                "  ExecutionAuthzVerdict,",
+                '} from "@loomwork/workflow-runtime";',
+                "",
+                "/**",
+                " * An `ExecutionAuthorizer` — gates the execution LIFECYCLE, where a",
+                " * `CapabilityAuthorizer` gates individual effects. Consulted at the entry of",
+                " * `start`, `resume`, `cancel` and the public `loadState` (query).",
+                " *",
+                " * Answer every op: `cancel` and `query` are the two that get forgotten, and an",
+                " * authorizer that allows an op it never considered is a hole that looks like a policy.",
+                " * The verdict is SYNCHRONOUS — it is read before anything is appended, so there is no",
+                " * async escape hatch here by design.",
+                " *",
+                " * `request.principal` is OPTIONAL, and how to treat its absence is your decision:",
+                " * denying anonymous access and allowing it are both real policies; throwing is not,",
+                " * because the caller is left with no verdict to act on.",
+                " */",
+                `export class ${joinNoun(P, "ExecutionAuthorizer")} implements ExecutionAuthorizer {`,
+                "  authorize(request: ExecutionAuthzRequest): ExecutionAuthzVerdict {",
+                "    // TODO: your policy. Default-deny is the safe placeholder.",
+                "    return { allowed: false, reason: `not implemented (${request.op})` };",
+                "  }",
+                "}",
+                "",
+            ].join("\n");
+        },
+        test: (name) => {
+            const P = (0, codegen_1.pascal)(name);
+            return [
+                "// The kit checks every lifecycle op is answered, determinism, and that the verdict is",
+                "// synchronous — un-comment once your policy is real:",
+                '// import { runExecutionAuthorizerConformance } from "@loomwork/conformance";',
+                `// import { ${joinNoun(P, "ExecutionAuthorizer")} } from "./index";`,
+                `// runExecutionAuthorizerConformance(() => new ${joinNoun(P, "ExecutionAuthorizer")}());`,
+                "",
+                'import { describe, expect, it } from "vitest";',
+                `import { ${joinNoun(P, "ExecutionAuthorizer")} } from "./index";`,
+                "",
+                `describe("${joinNoun(P, "ExecutionAuthorizer")}", () => {`,
+                '  it("denies by default until a policy is written", () => {',
+                `    const verdict = new ${joinNoun(P, "ExecutionAuthorizer")}().authorize({`,
+                '      op: "start",',
+                '      executionId: "e",',
+                '      workflowId: "w",',
+                "    });",
+                "    expect(verdict.allowed).toBe(false);",
+                "  });",
+                "});",
+                "",
+            ].join("\n");
+        },
+    },
+    "resume-authenticator": {
+        key: "resume-authenticator",
+        spi: "ResumeAuthenticator",
+        title: "Resume authority (K12.2 — may this event reopen an execution?)",
+        wiring: "security: { resumeAuthenticator: new <Name>ResumeAuthenticator() }",
+        spiDeps: ["@loomwork/workflow-runtime"],
+        conformance: ["runResumeAuthenticatorConformance"],
+        index: (name) => {
+            const P = (0, codegen_1.pascal)(name);
+            return [
+                "import type {",
+                "  ResumeAuthenticator,",
+                "  ResumeEvent,",
+                "  ResumeVerdict,",
+                '} from "@loomwork/workflow-runtime";',
+                "",
+                "/**",
+                " * A `ResumeAuthenticator` — may this event REOPEN a suspended execution (K12.2)?",
+                " *",
+                " * The narrowest of loom's three authority rings, and the one an attacker reaches",
+                " * first: a resume arrives from OUTSIDE the process, where an effect call and a",
+                " * lifecycle call do not. A signed approval from your identity provider is verified",
+                " * here, before the event is appended.",
+                " *",
+                " * Three statuses, and the third is the one to get right:",
+                " *",
+                " * - `verified` — you checked, and it is genuine. Name the `actor` and what",
+                " *   `verifiedBy` them, because both land in the log as the record of WHO resumed.",
+                " * - `rejected` — refuse it. Carries a reason, which `ApprovalRejectedError` puts in",
+                " *   front of whoever tried.",
+                " * - `not-applicable` — *this event is not mine to judge*. The runtime treats it as no",
+                " *   opinion and lets the resume proceed. It is NOT a soft denial: returning it for an",
+                " *   event you meant to refuse has allowed that event.",
+                " */",
+                `export class ${joinNoun(P, "ResumeAuthenticator")} implements ResumeAuthenticator {`,
+                "  verify(event: ResumeEvent): ResumeVerdict {",
+                "    // TODO: verify the signature/token over the WHOLE event — `payload` AND, when present,",
+                "    // `discardLegacyAnswers` (ADR 0104: honoured only on a verified event, so a signature",
+                "    // over `payload` alone lets a caller attach it). Refusing by default is",
+                "    // the safe placeholder — `not-applicable` would let everything through.",
+                '    return { status: "rejected", reason: `not implemented (${event.eventType})` };',
+                "  }",
+                "}",
+                "",
+            ].join("\n");
+        },
+        test: (name) => {
+            const P = (0, codegen_1.pascal)(name);
+            return [
+                "// The kit checks the verdict is one of the three statuses, is deterministic, and that",
+                "// a rejection carries a non-empty reason:",
+                '// import { runResumeAuthenticatorConformance } from "@loomwork/conformance";',
+                `// import { ${joinNoun(P, "ResumeAuthenticator")} } from "./index";`,
+                `// runResumeAuthenticatorConformance(() => new ${joinNoun(P, "ResumeAuthenticator")}());`,
+                "",
+                'import { describe, expect, it } from "vitest";',
+                `import { ${joinNoun(P, "ResumeAuthenticator")} } from "./index";`,
+                "",
+                `describe("${joinNoun(P, "ResumeAuthenticator")}", () => {`,
+                '  it("refuses by default until the verification is written", () => {',
+                `    const verdict = new ${joinNoun(P, "ResumeAuthenticator")}().verify({`,
+                '      eventType: "Approved",',
+                "      payload: {},",
+                "    });",
+                '    expect(verdict.status).toBe("rejected");',
+                "  });",
+                "});",
+                "",
+            ].join("\n");
+        },
+    },
+    "timer-dispatcher": {
+        key: "timer-dispatcher",
+        spi: "TimerDispatcher",
+        title: "Where a due wake runs (#392 placement for timers)",
+        wiring: "timers: { store, dispatcher: new <Name>TimerDispatcher() }",
+        spiDeps: ["@loomwork/workflow-runtime"],
+        conformance: ["runTimerDispatcherConformance"],
+        index: (name) => {
+            const P = (0, codegen_1.pascal)(name);
+            return [
+                'import type { TimerDispatcher } from "@loomwork/workflow-runtime";',
+                "",
+                "/**",
+                " * A `TimerDispatcher` — where a due wake RUNS (#392).",
+                " *",
+                " * Without one, a timer resumes the execution inside whichever process happens to poll",
+                " * the store; with one, it runs on the lane the execution was STARTED on. That matters",
+                " * when a branch was given its own compute: it otherwise wakes up in the web server.",
+                " *",
+                " * The `target` is a HINT and may name a lane that no longer exists — a node is often",
+                " * recovering an execution precisely BECAUSE its lane went away. Fall back; never",
+                " * strand the wake, which would leave the execution suspended forever.",
+                " *",
+                " * Pass `resumeEvent` through UNCHANGED. The kernel owns the resume vocabulary (K7.5);",
+                " * a transport that reinterprets it changes what the log records.",
+                " */",
+                `export class ${joinNoun(P, "TimerDispatcher")} implements TimerDispatcher {`,
+                "  dispatch(",
+                "    _pkg: {",
+                "      executionId: string;",
+                "      workflowId: string;",
+                "      flowId: string;",
+                "      resumeEvent: { eventType: string; payload: unknown };",
+                "      metadata?: Record<string, unknown>;",
+                "    },",
+                "    _meta?: { target?: string }",
+                "  ): Promise<unknown> {",
+                '    throw new Error("not implemented");',
+                "  }",
+                "}",
+                "",
+            ].join("\n");
+        },
+        test: (name) => {
+            const P = (0, codegen_1.pascal)(name);
+            return [
+                "// The kit checks the two things a dispatcher is silently wrong about: an unknown",
+                "// target must not strand the wake, and the resume event must pass through unchanged.",
+                '// import { runTimerDispatcherConformance } from "@loomwork/conformance";',
+                `// import { ${joinNoun(P, "TimerDispatcher")} } from "./index";`,
+                `// runTimerDispatcherConformance(() => new ${joinNoun(P, "TimerDispatcher")}());`,
+                "",
+                'import { describe, expect, it } from "vitest";',
+                `import { ${joinNoun(P, "TimerDispatcher")} } from "./index";`,
+                "",
+                `describe("${joinNoun(P, "TimerDispatcher")}", () => {`,
+                '  it("constructs", () => {',
+                `    expect(new ${joinNoun(P, "TimerDispatcher")}()).toBeDefined();`,
+                "  });",
+                "});",
+                "",
+            ].join("\n");
+        },
+    },
+    policy: {
+        key: "policy",
+        spi: "Policy",
+        title: "Learned policy (choose an action from an observation)",
+        // The one seam that is NOT a defineConfig contributor. A policy is consumed
+        // from flow code, deliberately: ADR 0080 keeps the runtime unaware that a
+        // policy exists, so a learned choice can only ever reach a run through
+        // `ctx.decide` — recorded, replayable, auditable.
+        wiring: "decideWithPolicy(ctx, id, new <Name>Policy(), context, actions)  — flow code, NOT defineConfig",
+        spiDeps: ["@loomwork/learning"],
+        conformance: ["runPolicyConformance"],
+        index: (name) => {
+            const P = (0, codegen_1.pascal)(name);
+            return [
+                'import type { Policy, PolicyChoice, PolicyContext } from "@loomwork/learning";',
+                "",
+                "/**",
+                " * A `Policy` — given an observation, choose one of the offered actions.",
+                " *",
+                " * Consumed from flow code via `decideWithPolicy(ctx, id, policy, context, actions)`,",
+                " * which records the choice as a durable decision along with the context and the",
+                " * propensity. There is no `defineConfig` key: the runtime never learns a policy",
+                " * exists (ADR 0080).",
+                " *",
+                " * Two contracts to honour:",
+                " *  - `select` must be PURE and cheap. It runs before `ctx.decide`, so on replay it",
+                " *    is called and its answer discarded.",
+                " *  - `propensity` is `P(chosen | context)` and must be EXACT. Nothing downstream",
+                " *    can detect a misreported one, and it biases every later off-policy estimate.",
+                " *    Return 1 only if this policy is genuinely deterministic — a log written that",
+                " *    way holds no counterfactuals and can never evaluate the next candidate.",
+                " */",
+                `export class ${joinNoun(P, "Policy")}<A = string> implements Policy<A> {`,
+                `  readonly id = "${name}";`,
+                "  /** Bump when you retrain. A policy object is one immutable snapshot. */",
+                '  readonly version = "1";',
+                "",
+                "  select(context: PolicyContext, actions: readonly A[]): PolicyChoice<A> {",
+                "    if (actions.length === 0) {",
+                `      throw new Error("${joinNoun(P, "Policy")}: no actions to choose from");`,
+                "    }",
+                "    // Replace with your algorithm. Train offline from `trajectories(events)`",
+                "    // and ship the result as a NEW version.",
+                "    void context;",
+                "    return { action: actions[0] as A, propensity: 1 };",
+                "  }",
+                "}",
+                "",
+            ].join("\n");
+        },
+        test: (name) => {
+            const P = (0, codegen_1.pascal)(name);
+            return [
+                'import { runPolicyConformance } from "@loomwork/conformance";',
+                'import { describe, expect, it } from "vitest";',
+                `import { ${joinNoun(P, "Policy")} } from "./index";`,
+                "",
+                "// The SPI kit: proves the shape and the propensity contract, never the quality",
+                "// of what you choose. Pass observations representative of what you will see.",
+                "runPolicyConformance<string>(",
+                `  () => new ${joinNoun(P, "Policy")}<string>(),`,
+                '  ["a", "b", "c"],',
+                "  [{ feature: 0 }, { feature: 1 }]",
+                ");",
+                "",
+                `describe("${joinNoun(P, "Policy")}", () => {`,
+                '  it("chooses from the offered actions", () => {',
+                `    expect(["a", "b"]).toContain(new ${joinNoun(P, "Policy")}<string>().select({}, ["a", "b"]).action);`,
+                "  });",
+                "});",
+                "",
+            ].join("\n");
+        },
+    },
+    sandbox: {
+        key: "sandbox",
+        spi: "SandboxBackend",
+        title: "Sandbox backend (run model-written code in your own isolation boundary)",
+        // Like `policy`, not a defineConfig contributor: the effect is registered from flow code, where
+        // the content store that holds the scripts is in hand (ADR 0144 D6).
+        wiring: "registerSandboxBackend(effects, scripts, new <Name>SandboxBackend(), { … })  — flow code, NOT defineConfig",
+        spiDeps: ["@loomwork/sandbox"],
+        conformance: ["runSandboxBackendConformance"],
+        readmeWire: (name, packageName) => [
+            "```ts",
+            'import { registerSandboxBackend } from "@loomwork/sandbox";',
+            `import { ${joinNoun((0, codegen_1.pascal)(name), "SandboxBackend")} } from "${packageName}";`,
+            "",
+            "// Registered from flow code, next to the content store that holds the scripts.",
+            "// There is no defineConfig key for it.",
+            "const effect = registerSandboxBackend(",
+            "  effects,",
+            "  scripts,",
+            `  new ${joinNoun((0, codegen_1.pascal)(name), "SandboxBackend")}({ /* endpoint, image, … */ })`,
+            ");",
+            "await effect.warm(); // boot",
+            "await effect.close(); // shutdown",
+            "```",
+        ],
+        readmeExtra: () => [
+            "## Before you ship a remote backend",
+            "",
+            "The effect owns the limits, channels and replay rules. You own the isolation boundary, and",
+            "these are the things that make it one:",
+            "",
+            "- **No service account, no credentials.** The sandbox runs with no identity and no secrets",
+            "  of the platform that launches it.",
+            "- **Egress denied at the network layer**, not by the script's language. Declare",
+            '  `network: "none"` only if the network itself refuses.',
+            "- **One request per instance.** Nothing a script wrote survives to the next request",
+            "  (`freshPerRun: true`), which may belong to another tenant.",
+            "- **The request timeout is the hard kill.** Enforce `request.limits.wallClockMs` outside the",
+            '  script\'s own process (`wallClock: "hard"`).',
+            "- **Memory and CPU caps** on the instance (`memory: true`, `cpu: true`).",
+            "- **No shared writable state**: no shared volume, cache or temp directory between instances.",
+            "- Report what happened as a `SandboxOutcome`; never throw a typed failure, never return text",
+            "  you did not bound — the effect bounds it again, but a log is append-only.",
+            "",
+            'The generated backend declares the worst case (`network: "open"`, `freshPerRun: false`,',
+            '`wallClock: "soft"`, `memory: false`, `cpu: false`). Each stronger value must be earned by',
+            "`src/index.test.ts` (the conformance kit) passing with it; the kit passes the effect the",
+            "`allowNetwork` / `allowReusedEnvironment` opt-ins exactly when your declaration needs them.",
+            "",
+            "- **`memory: false` / `cpu: false` mean an in-process backend can exhaust the host.** Nothing",
+            "  caps a script's heap or CPU, so a runaway or allocation bomb takes down the process that runs",
+            "  the backend. Declare them `true` only for a backend that enforces the caps (an engine memory",
+            "  limit, or a separate process or instance); never run an uncapped backend inside your host.",
+            "",
+            "A non-JavaScript backend must pass its own `fixtures` to `runSandboxBackendConformance`",
+            "(model them on `SandboxFixtures` / `JAVASCRIPT_FIXTURES` in `@loomwork/conformance`).",
+            "",
+            "A backend that cold-starts an instance per run cannot finish the kit's `fresh per run` case",
+            "(16 sequential runs plus 8 concurrent) inside the default 60 s per-test timeout. Pass a larger",
+            "`timeoutMs` to `runSandboxBackendConformance` (e.g. `300_000`); it applies to every case, and",
+            "the run counts do not change.",
+        ],
+        index: (name) => {
+            const P = (0, codegen_1.pascal)(name);
+            return [
+                "import type {",
+                "  SandboxBackend,",
+                "  SandboxBackendCapabilities,",
+                "  SandboxOutcome,",
+                "  SandboxRequest,",
+                '} from "@loomwork/sandbox";',
+                "",
+                `export interface ${joinNoun(P, "SandboxBackendOptions")} {`,
+                "  /** Whatever your backend needs — a service URL, an image, a token source. */",
+                "  endpoint?: string;",
+                "}",
+                "",
+                "/**",
+                " * A `SandboxBackend` — the ENGINE: run one verified script against one bounded input and",
+                " * report what happened. Register it from flow code with `registerSandboxBackend(...)`;",
+                " * `SandboxEffect` owns the limits, content-address check, channels and replay form",
+                " * (ADR 0144), so do not re-implement any of them here.",
+                " *",
+                " * The capabilities below are the most conservative honest claims: they assume the WORST",
+                " * (open network, a reused environment, a soft clock, no memory or CPU cap). Each stronger",
+                " * value must be EARNED: change it only when the conformance kit (index.test.ts) passes with",
+                ' * it. The effect refuses `network` other than "none" and `freshPerRun: false` unless the',
+                " * operator opts in, and then is not `idempotent`.",
+                " */",
+                `export class ${joinNoun(P, "SandboxBackend")} implements SandboxBackend {`,
+                "  readonly capabilities: SandboxBackendCapabilities = {",
+                '    // "javascript" runs the kit\'s built-in fixtures. A backend for any OTHER language must',
+                "    // pass its own `fixtures` (one script per case) to runSandboxBackendConformance in",
+                "    // index.test.ts — model them on `SandboxFixtures` / `JAVASCRIPT_FIXTURES` in @loomwork/conformance.",
+                '    language: "javascript",',
+                '    network: "open",',
+                '    wallClock: "soft",',
+                "    memory: false,",
+                "    cpu: false,",
+                "    freshPerRun: false,",
+                "  };",
+                "",
+                `  constructor(private readonly options: ${joinNoun(P, "SandboxBackendOptions")} = {}) {}`,
+                "",
+                "  async evaluate(request: SandboxRequest): Promise<SandboxOutcome> {",
+                "    // TODO: run `request.script` with `request.inputJson` parsed as the script's `input`,",
+                "    // inside your isolation boundary, honouring `request.limits` and `request.signal`.",
+                "    // Report a closed outcome: { ok: true, value } | limit | threw | inputTooLarge | infrastructure.",
+                "    //",
+                "    // A REMOTE backend (uncomment and adapt; this is the shape, not live code):",
+                "    //",
+                "    //   const res = await fetch(this.options.endpoint, {",
+                '    //     method: "POST",',
+                "    //     body: JSON.stringify({ script: request.script, input: request.inputJson }),",
+                "    //     signal: request.signal, // the effect aborts through this; a hung call must stop",
+                "    //   });",
+                "    //   // Cap what you read: a log is append-only, never buffer an unbounded body.",
+                "    //   const bytes = await readAtMost(res, MAX_RESPONSE_BYTES); // your helper",
+                "    //   if (!res.ok || bytes === undefined) {",
+                "    //     // Any unexpected response is infrastructure, with a message YOU wrote —",
+                "    //     // never the response body (it is untrusted and may carry secrets).",
+                '    //     return { ok: false, kind: "infrastructure", message: `backend returned ${res.status}` };',
+                "    //   }",
+                "    //   return parseOutcome(bytes); // map to the closed SandboxOutcome set, or infrastructure",
+                "    void request;",
+                "    return {",
+                "      ok: false,",
+                '      kind: "infrastructure",',
+                '      message: `not implemented (${this.options.endpoint ?? "no endpoint"})`,',
+                "    };",
+                "  }",
+                "",
+                "  /** Optional: pre-warm pools or connections. */",
+                "  async warm(): Promise<void> {}",
+                "",
+                "  /** Optional: release pools, connections and instances. */",
+                "  async close(): Promise<void> {}",
+                "}",
+                "",
+            ].join("\n");
+        },
+        test: (name) => {
+            const P = (0, codegen_1.pascal)(name);
+            return [
+                'import { runSandboxBackendConformance } from "@loomwork/conformance";',
+                `import { ${joinNoun(P, "SandboxBackend")} } from "./index";`,
+                "",
+                "// The SPI kit: runs ADR 0064's security list through SandboxEffect — echo, throw, syntax",
+                "// error, runaway loop, allocation bomb, no network, fresh per run, abort, outcome hygiene.",
+                "// It fails until evaluate() is real.",
+                "// - A language other than JavaScript: pass `fixtures` (one script per case), modelled on",
+                "//   `SandboxFixtures` / `JAVASCRIPT_FIXTURES` in @loomwork/conformance.",
+                "// - A backend that cold-starts per run: pass a larger `timeoutMs` (e.g. 300_000) — the",
+                "//   `fresh per run` case makes 16 sequential + 8 concurrent runs under one timeout.",
+                `runSandboxBackendConformance(() => new ${joinNoun(P, "SandboxBackend")}(), { label: "${joinNoun(P, "SandboxBackend")}" });`,
+                "",
+            ].join("\n");
+        },
+    },
+};
+exports.SEAM_KEYS = Object.keys(SEAMS);
+/** seam key → SPI interface name. Consumed by the seam/doc coverage fitness test. */
+exports.SEAM_SPI = Object.fromEntries(Object.entries(SEAMS).map(([k, v]) => [k, v.spi]));
+/** seam key → the line that wires it. Consumed by the wiring fitness test. */
+exports.SEAM_WIRING = Object.fromEntries(Object.entries(SEAMS).map(([k, v]) => [k, v.wiring]));
+/** Human-readable seam list for `loom plugin seams`. */
+function listSeams() {
+    // Derived, not a constant: a seam key longer than the column silently breaks the alignment
+    // of every row, which is how `durable-state` landed mid-column the first time.
+    const width = Math.max(...exports.SEAM_KEYS.map((k) => k.length));
+    const rows = exports.SEAM_KEYS.map((k) => {
+        const s = SEAMS[k];
+        const conf = s.conformance.length > 0 ? " (conformance ✓)" : "";
+        return `  ${k.padEnd(width)} ${s.title}${conf}\n  ${" ".repeat(width)} wire: ${s.wiring}`;
+    });
+    return `Loom plugin seams (loom plugin new <seam> <name>):\n\n${rows.join("\n")}`;
+}
+function pluginPackageJson(seam, packageName, firstParty) {
+    // Per seam: only what the template imports (a peer dependency nothing imports is a
+    // constraint on the consumer for no reason).
+    const spi = [...new Set(seam.spiDeps)];
+    const version = firstParty ? "workspace:*" : "*";
+    const deps = {};
+    for (const d of spi)
+        deps[d] = version;
+    const devDeps = {};
+    if (seam.conformance.length > 0)
+        devDeps["@loomwork/conformance"] = version;
+    devDeps["@types/node"] = "^22.0.0";
+    devDeps.typescript = "^5.6.3";
+    devDeps.vitest = "^2.1.8";
+    // `@types/node` is always declared: a template that writes `Buffer` in a signature needs it
+    // to compile (which is how `loom plugin new keystore` once shipped code nobody could build),
+    // and vitest's config and any real backend reach for node's modules anyway.
+    const pkg = {
+        name: packageName,
+        version: "0.0.0",
+        ...(firstParty ? {} : { private: false }),
+        description: pluginDescription(seam),
+        keywords: firstParty ? ["loom", "loom-plugin"] : ["loom", "loom-plugin", `loom-${seam.key}`],
+        type: "commonjs",
+        main: "./dist/index.js",
+        types: "./dist/index.d.ts",
+        // `types` first (TypeScript matches conditions in order), `default` LAST — it is
+        // the fallback that any condition set matches, and without it an `import`, which
+        // offers ["node", "import"] and never "require", resolves nothing at all.
+        exports: {
+            ".": {
+                types: "./dist/index.d.ts",
+                require: "./dist/index.js",
+                default: "./dist/index.js",
+            },
+        },
+        ...(firstParty ? {} : { engines: { node: ">=20.0.0" }, files: ["dist"] }),
+        scripts: {
+            build: "tsc --build",
+            test: "vitest run",
+            clean: "rm -rf dist tsconfig.tsbuildinfo",
+            ...(firstParty ? { "typecheck:tests": "tsc -p tsconfig.test.json" } : {}),
+        },
+        ...(firstParty ? { dependencies: deps } : { peerDependencies: deps }),
+        devDependencies: firstParty ? devDeps : { ...deps, ...devDeps },
+    };
+    return `${JSON.stringify(pkg, null, 2)}\n`;
+}
+/** Node globals a template can reference that only `@types/node` declares. */
+const NODE_GLOBALS = /\b(Buffer|process|__dirname|NodeJS\.)/;
+/**
+ * Does this template's CODE use a node global?
+ *
+ * Comments are stripped first, and that is not a detail: two seams describe "the process" in
+ * their prose, and matching those would have added `@types/node` to packages whose code never
+ * touches it. A sweep that reads comments is measuring prose, not code.
+ */
+function usesNodeGlobals(source) {
+    const code = source.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/.*$/gm, "");
+    return NODE_GLOBALS.test(code);
+}
+/**
+ * One-line description, shared by package.json and the README. Several seam titles begin with the
+ * seam's own word ("Sandbox backend (…)"), which read back-to-back after "A Loom sandbox plugin —".
+ */
+function pluginDescription(seam) {
+    const norm = (x) => x.toLowerCase().replace(/-/g, " ");
+    return norm(seam.title).startsWith(norm(seam.key))
+        ? `A Loom plugin — ${seam.title}.`
+        : `A Loom ${seam.key} plugin — ${seam.title}.`;
+}
+function pluginVitestConfig(firstParty) {
+    if (firstParty) {
+        return 'import { loomTest } from "../../vitest.shared";\n\nexport default loomTest();\n';
+    }
+    return [
+        'import { defineConfig } from "vitest/config";',
+        "",
+        "export default defineConfig({",
+        '  resolve: { conditions: ["require", "default"] },',
+        '  test: { environment: "node" },',
+        "});",
+        "",
+    ].join("\n");
+}
+function pluginTsconfigTest() {
+    return [
+        "{",
+        '  "extends": "./tsconfig.json",',
+        '  "compilerOptions": {',
+        '    "noEmit": true,',
+        '    "composite": false,',
+        '    "declaration": false,',
+        '    "declarationMap": false,',
+        '    "sourceMap": false',
+        "  },",
+        '  "include": ["src/**/*.ts"],',
+        '  "exclude": ["node_modules", "dist"]',
+        "}",
+        "",
+    ].join("\n");
+}
+function pluginTsconfig(seam, firstParty) {
+    if (firstParty) {
+        const refs = [...new Set(seam.spiDeps)].map((d) => `    { "path": "../../packages/${d.replace("@loomwork/", "")}" }`);
+        return [
+            "{",
+            '  "extends": "../../tsconfig.base.json",',
+            '  "compilerOptions": { "rootDir": "src", "outDir": "dist" },',
+            '  "include": ["src/**/*"],',
+            '  "exclude": ["node_modules", "dist", "**/*.test.ts"],',
+            '  "references": [',
+            refs.join(",\n"),
+            "  ]",
+            "}",
+            "",
+        ].join("\n");
+    }
+    return [
+        "{",
+        '  "compilerOptions": {',
+        '    "target": "ES2022",',
+        '    "module": "CommonJS",',
+        '    "moduleResolution": "node",',
+        '    "declaration": true,',
+        '    "strict": true,',
+        '    "esModuleInterop": true,',
+        '    "skipLibCheck": true,',
+        '    "rootDir": "src",',
+        '    "outDir": "dist"',
+        "  },",
+        '  "include": ["src/**/*"],',
+        '  "exclude": ["node_modules", "dist", "**/*.test.ts"]',
+        "}",
+        "",
+    ].join("\n");
+}
+function pluginReadme(seam, name, packageName, firstParty) {
+    const wire = seam.wiring
+        .replace(/<name>/g, (0, codegen_1.camel)(name))
+        .replace(/<Name>([A-Za-z]*)/g, (_m, noun) => joinNoun((0, codegen_1.pascal)(name), noun));
+    const wireBlock = seam.readmeWire !== undefined
+        ? seam.readmeWire(name, packageName)
+        : [
+            "```ts",
+            'import { defineConfig } from "@loomwork/app";',
+            `// import { … } from "${packageName}";`,
+            "",
+            `export const app = defineConfig({ ${wire} });`,
+            "```",
+        ];
+    return [
+        `# ${packageName}`,
+        "",
+        pluginDescription(seam).replace(/^A Loom (\S+) plugin/, "A Loom **$1** plugin"),
+        "",
+        "## Wire it",
+        "",
+        ...wireBlock,
+        "",
+        ...(seam.readmeExtra !== undefined ? [...seam.readmeExtra(name), ""] : []),
+        "## Contract",
+        "",
+        "- Implement the SPI; keep the preset a pure function.",
+        "- Contribute only to existing seams — no kernel hook, no reducer into the replay fold.",
+        "- Prove it with `@loomwork/conformance` (see `src/index.test.ts`).",
+        firstParty
+            ? "- First-party: lives in `plugins/`, conformance-gated in Loom CI."
+            : "- Third-party: publish under `loom-plugin-*`, keyword `loom-plugin`; you own the supply-chain trust.",
+        "",
+        "See https://github.com/chhetrisushil/loom/blob/main/docs/plugins.md",
+        "",
+    ].join("\n");
+}
+/**
+ * Scaffold a plugin package for `seam`, named `name`, in first- or third-party
+ * shape. Returns a map of relative path → file contents (pure — the CLI writes).
+ */
+function pluginFiles(seamKey, name, opts) {
+    const seam = SEAMS[seamKey];
+    if (seam === undefined) {
+        throw new Error(`unknown seam "${seamKey}" — expected ${exports.SEAM_KEYS.join(" | ")}`);
+    }
+    // `name` is interpolated straight into a path AND a package name, and the caller writes
+    // every returned key to disk. Unvalidated, `loom plugin new store ../../x` scaffolds
+    // outside the target directory. A plugin name is a single npm-style token; anything with
+    // a separator or a leading dot is a mistake at best.
+    if (!/^[a-z0-9][a-z0-9-]*$/.test(name)) {
+        throw new Error(`invalid plugin name "${name}" — use lowercase letters, digits and hyphens (no slashes, dots, or leading hyphen)`);
+    }
+    const dir = opts.firstParty ? `plugins/${name}` : `loom-plugin-${name}`;
+    const packageName = opts.firstParty ? `@loomwork/plugin-${name}` : `loom-plugin-${name}`;
+    return {
+        [`${dir}/package.json`]: pluginPackageJson(seam, packageName, opts.firstParty),
+        [`${dir}/tsconfig.json`]: pluginTsconfig(seam, opts.firstParty),
+        [`${dir}/vitest.config.ts`]: pluginVitestConfig(opts.firstParty),
+        ...(opts.firstParty ? { [`${dir}/tsconfig.test.json`]: pluginTsconfigTest() } : {}),
+        [`${dir}/src/index.ts`]: seam.index(name),
+        [`${dir}/src/index.test.ts`]: seam.test(name),
+        [`${dir}/README.md`]: pluginReadme(seam, name, packageName, opts.firstParty),
+    };
+}
+/**
+ * The "next:" guidance `loom plugin new` prints, derived from what was generated so it cannot
+ * drift from it: whether the conformance test is live or commented out is read from the test file
+ * itself, and a third-party author is told which `@loomwork/*` packages need resolving.
+ */
+function pluginNextSteps(files, opts) {
+    const testKey = Object.keys(files).find((f) => f.endsWith("src/index.test.ts")) ?? "";
+    const test = files[testKey] ?? "";
+    const live = /^(?!\s*\/\/).*\brun\w+Conformance\(/m.test(test);
+    const lines = [
+        "",
+        live
+            ? `next: implement the SPI in ${opts.root}/src/index.ts (the conformance test in src/index.test.ts is`
+            : `next: implement the SPI in ${opts.root}/src/index.ts, un-comment the conformance test in`,
+        live
+            ? "      already wired and fails until you do), and run your formatter (e.g. biome/prettier)."
+            : "      src/index.test.ts, and run your formatter (e.g. biome/prettier) to tidy the scaffold.",
+    ];
+    if (!opts.firstParty) {
+        const pkgKey = Object.keys(files).find((f) => f.endsWith("package.json")) ?? "";
+        const pkg = JSON.parse(files[pkgKey] ?? "{}");
+        const loom = [
+            ...new Set([
+                ...Object.keys(pkg.peerDependencies ?? {}),
+                ...Object.keys(pkg.devDependencies ?? {}),
+            ].filter((d) => d.startsWith("@loomwork/"))),
+        ].sort();
+        lines.push("", `this plugin depends on: ${loom.join(", ")}`, "      If you consume an unpublished Loom checkout, your workspace needs a pnpm override", "      (a `link:` path into your Loom checkout) for each of them, e.g.", '      "@loomwork/<name>": "link:../loom/packages/<dir>" under pnpm.overrides in the root package.json.');
+    }
+    return lines;
+}
+//# sourceMappingURL=plugin.js.map