@manifesto-ai/lineage 0.1.1 → 3.1.0

package/README.md

@@ -1,44 +1,48 @@
 # @manifesto-ai/lineage
 
-> Split-native lineage protocol for identity, history, and sealing.
+> Seal-aware continuity for the ADR-017 decorator runtime.
 
-`@manifesto-ai/lineage` is the package to use when you need deterministic world identity, branch history, and snapshot sealing directly. It is the lower substrate that `@manifesto-ai/governance` and `@manifesto-ai/world` build on.
+`@manifesto-ai/lineage` is the package that adds time, history, and restore to a composable manifesto.
 
-> **Current Contract Note:** The current public package contract is documented in [docs/lineage-SPEC-2.0.0v.md](docs/lineage-SPEC-2.0.0v.md). The v1.x lineage docs remain available as historical split-era baselines.
+> **Current Contract Note:** The truthful current package contract is [docs/lineage-SPEC-v3.0.0-draft.md](docs/lineage-SPEC-v3.0.0-draft.md). The v2 lineage spec remains as the historical service-first baseline.
 
 ## What This Package Owns
 
-- snapshot and world identity computation
-- branch, head, and epoch reads
-- seal protocol and prepared commits
-- lineage persistence and replay
-- in-memory lineage storage
+- `withLineage(createManifesto(...), config).activate()`
+- lineage-aware `dispatchAsync` that seals before publication
+- restore, head, branch, and world queries on the activated runtime
+- `LineageStore`, `LineageService`, and sealing substrate
+- deterministic world identity, branch semantics, and restore normalization
 
-## When to Use It
+## Canonical Path
 
-Use `@manifesto-ai/lineage` directly when you want:
+```ts
+import { createManifesto } from "@manifesto-ai/sdk";
+import { withLineage, createInMemoryLineageStore } from "@manifesto-ai/lineage";
 
-- world history without governance
-- deterministic identity and resume support
-- custom persistence or replay tooling
-- isolated tests for hashing, branch, and sealing behavior
+const manifesto = createManifesto<CounterDomain>(schema, effects);
+const world = withLineage(manifesto, {
+  store: createInMemoryLineageStore(),
+}).activate();
 
-## Quick Start
+await world.dispatchAsync(
+  world.createIntent(world.MEL.actions.increment),
+);
 
-```typescript
-import {
-  createInMemoryLineageStore,
-  createLineageService,
-} from "@manifesto-ai/lineage";
-
-const store = createInMemoryLineageStore();
-const lineage = createLineageService(store);
+const head = await world.getLatestHead();
+if (head) {
+  await world.restore(head.worldId);
+}
 ```
 
+## Low-Level Usage
+
+`LineageService` and `LineageStore` remain public. Use them directly when you need hashing, prepared commits, branch inspection, or custom persistence without the activated runtime wrapper.
+
 ## Docs
 
 - [Docs Landing](docs/README.md)
 - [Lineage Guide](docs/GUIDE.md)
-- [Lineage Specification](docs/lineage-SPEC-2.0.0v.md)
-- [Historical v1 Baseline](docs/lineage-SPEC-1.0.1v.md)
+- [Lineage Specification](docs/lineage-SPEC-v3.0.0-draft.md)
+- [Historical v2 Service-First SPEC](docs/lineage-SPEC-2.0.0v.md)
 - [VERSION-INDEX](docs/VERSION-INDEX.md)

package/dist/chunk-Q3WY563K.js

@@ -0,0 +1,269 @@
+// src/internal.ts
+import {
+  DisposedError,
+  ManifestoError
+} from "@manifesto-ai/sdk";
+var LINEAGE_DECORATION = /* @__PURE__ */ Symbol("manifesto-lineage.decoration");
+function attachLineageDecoration(manifesto, decoration) {
+  Object.defineProperty(manifesto, LINEAGE_DECORATION, {
+    enumerable: false,
+    configurable: false,
+    writable: false,
+    value: decoration
+  });
+  return manifesto;
+}
+function getLineageDecoration(manifesto) {
+  const internal = manifesto;
+  return internal[LINEAGE_DECORATION] ?? null;
+}
+function createLineageRuntimeController(kernel, service, config) {
+  let readiness = null;
+  let currentBranchId = null;
+  let currentCompletedWorldId = null;
+  async function ensureReady() {
+    if (readiness) {
+      return readiness;
+    }
+    readiness = bootstrapLineage().catch((error) => {
+      readiness = null;
+      throw error;
+    });
+    return readiness;
+  }
+  async function bootstrapLineage() {
+    const branches = await service.getBranches();
+    if (branches.length === 0) {
+      if (config.branchId) {
+        throw new ManifestoError(
+          "LINEAGE_BRANCH_NOT_FOUND",
+          `Configured branch "${config.branchId}" does not exist in the lineage store`
+        );
+      }
+      const genesisSnapshot = kernel.getVisibleCoreSnapshot();
+      const prepared = await service.prepareSealGenesis({
+        schemaHash: kernel.schema.hash,
+        terminalSnapshot: genesisSnapshot,
+        createdAt: genesisSnapshot.meta.timestamp
+      });
+      await service.commitPrepared(prepared);
+      currentBranchId = prepared.branchId;
+      currentCompletedWorldId = prepared.worldId;
+      return;
+    }
+    const branch = await bindInitialBranch(config.branchId);
+    currentBranchId = branch.id;
+    currentCompletedWorldId = branch.head;
+    const restored = await service.restore(branch.head);
+    kernel.setVisibleSnapshot(restored, { notify: false });
+  }
+  async function bindInitialBranch(branchId) {
+    if (!branchId) {
+      return service.getActiveBranch();
+    }
+    const branch = await service.getBranch(branchId);
+    if (!branch) {
+      throw new ManifestoError(
+        "LINEAGE_BRANCH_NOT_FOUND",
+        `Configured branch "${branchId}" does not exist in the lineage store`
+      );
+    }
+    const activeBranch = await service.getActiveBranch();
+    if (activeBranch.id !== branch.id) {
+      await service.switchActiveBranch(branch.id);
+    }
+    return branch;
+  }
+  async function sealIntent(intent, options) {
+    if (kernel.isDisposed()) {
+      throw new DisposedError();
+    }
+    const enrichedIntent = kernel.ensureIntentId(intent);
+    const runSeal = async () => {
+      if (kernel.isDisposed()) {
+        throw new DisposedError();
+      }
+      await ensureReady();
+      if (!kernel.isActionAvailable(enrichedIntent.type)) {
+        return kernel.rejectUnavailable(enrichedIntent);
+      }
+      let result;
+      try {
+        result = await kernel.executeHost(enrichedIntent);
+      } catch (error) {
+        kernel.restoreVisibleSnapshot();
+        throw toError(error);
+      }
+      if (!currentBranchId || !currentCompletedWorldId) {
+        kernel.restoreVisibleSnapshot();
+        throw new ManifestoError(
+          "LINEAGE_STATE_ERROR",
+          "Lineage runtime has no active branch continuity after bootstrap"
+        );
+      }
+      let prepared;
+      try {
+        prepared = await service.prepareSealNext({
+          schemaHash: kernel.schema.hash,
+          baseWorldId: currentCompletedWorldId,
+          branchId: currentBranchId,
+          terminalSnapshot: result.snapshot,
+          createdAt: result.snapshot.meta.timestamp,
+          ...options?.proposalRef ? { proposalRef: options.proposalRef } : {},
+          ...options?.decisionRef ? { decisionRef: options.decisionRef } : {}
+        });
+        await service.commitPrepared(prepared);
+      } catch (error) {
+        kernel.restoreVisibleSnapshot();
+        throw toError(error);
+      }
+      if (prepared.branchChange.headAdvanced) {
+        currentCompletedWorldId = prepared.worldId;
+      }
+      if (prepared.branchChange.headAdvanced && options?.publishOnCompleted !== false) {
+        return {
+          intent: enrichedIntent,
+          hostResult: result,
+          preparedCommit: prepared,
+          publishedSnapshot: kernel.setVisibleSnapshot(result.snapshot)
+        };
+      }
+      kernel.restoreVisibleSnapshot();
+      return {
+        intent: enrichedIntent,
+        hostResult: result,
+        preparedCommit: prepared
+      };
+    };
+    if (options?.assumeEnqueued) {
+      return runSeal();
+    }
+    return kernel.enqueue(runSeal);
+  }
+  async function getWorld(worldId) {
+    await ensureReady();
+    return service.getWorld(worldId);
+  }
+  async function getLatestHead() {
+    await ensureReady();
+    return service.getLatestHead();
+  }
+  async function getHeads() {
+    await ensureReady();
+    return service.getHeads();
+  }
+  async function getBranches() {
+    await ensureReady();
+    return service.getBranches();
+  }
+  async function getActiveBranch() {
+    await ensureReady();
+    if (currentBranchId) {
+      const branch = await service.getBranch(currentBranchId);
+      if (branch) {
+        return branch;
+      }
+    }
+    return service.getActiveBranch();
+  }
+  async function getCurrentBranchId() {
+    return (await getActiveBranch()).id;
+  }
+  async function getCurrentCompletedWorldId() {
+    await ensureReady();
+    if (!currentCompletedWorldId) {
+      throw new ManifestoError(
+        "LINEAGE_STATE_ERROR",
+        "Lineage runtime has no completed world continuity"
+      );
+    }
+    return currentCompletedWorldId;
+  }
+  async function restore(worldId) {
+    if (kernel.isDisposed()) {
+      throw new DisposedError();
+    }
+    await kernel.enqueue(async () => {
+      if (kernel.isDisposed()) {
+        throw new DisposedError();
+      }
+      await ensureReady();
+      const restored = await service.restore(worldId);
+      kernel.setVisibleSnapshot(restored);
+      currentCompletedWorldId = worldId;
+      const branches = await service.getBranches();
+      const matchingBranch = branches.find((branch) => branch.head === worldId);
+      if (matchingBranch) {
+        currentBranchId = matchingBranch.id;
+      }
+    });
+  }
+  async function switchActiveBranch(branchId) {
+    if (kernel.isDisposed()) {
+      throw new DisposedError();
+    }
+    return kernel.enqueue(async () => {
+      if (kernel.isDisposed()) {
+        throw new DisposedError();
+      }
+      await ensureReady();
+      const result = await service.switchActiveBranch(branchId);
+      const branch = await service.getBranch(branchId);
+      if (!branch) {
+        throw new ManifestoError(
+          "LINEAGE_BRANCH_NOT_FOUND",
+          `Cannot switch to unknown branch "${branchId}"`
+        );
+      }
+      const restored = await service.restore(branch.head);
+      kernel.setVisibleSnapshot(restored);
+      currentBranchId = branch.id;
+      currentCompletedWorldId = branch.head;
+      return result;
+    });
+  }
+  async function createBranch(name, fromWorldId) {
+    if (kernel.isDisposed()) {
+      throw new DisposedError();
+    }
+    return kernel.enqueue(async () => {
+      if (kernel.isDisposed()) {
+        throw new DisposedError();
+      }
+      await ensureReady();
+      const headWorldId = fromWorldId ?? currentCompletedWorldId;
+      if (!headWorldId) {
+        throw new ManifestoError(
+          "LINEAGE_STATE_ERROR",
+          "Cannot create a branch before lineage continuity is bootstrapped"
+        );
+      }
+      return service.createBranch(name, headWorldId);
+    });
+  }
+  return {
+    ensureReady,
+    sealIntent,
+    getWorld,
+    getLatestHead,
+    getHeads,
+    getBranches,
+    getActiveBranch,
+    getCurrentBranchId,
+    getCurrentCompletedWorldId,
+    restore,
+    switchActiveBranch,
+    createBranch
+  };
+}
+function toError(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+
+export {
+  LINEAGE_DECORATION,
+  attachLineageDecoration,
+  getLineageDecoration,
+  createLineageRuntimeController
+};
+//# sourceMappingURL=chunk-Q3WY563K.js.map

package/dist/chunk-Q3WY563K.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internal.ts"],"sourcesContent":["import {\n  DisposedError,\n  ManifestoError,\n  type BaseLaws,\n  type ComposableManifesto,\n  type LineageLaws,\n  type ManifestoDomainShape,\n  type Snapshot,\n} from \"@manifesto-ai/sdk\";\nimport type { RuntimeKernel } from \"@manifesto-ai/sdk/internal\";\nimport type { Intent } from \"@manifesto-ai/core\";\n\nimport type { LineageConfig } from \"./runtime-types.js\";\nimport type {\n  BranchId,\n  BranchInfo,\n  BranchSwitchResult,\n  LineageService,\n  PreparedNextCommit,\n  World,\n  WorldHead,\n  WorldId,\n} from \"./types.js\";\n\nexport const LINEAGE_DECORATION = Symbol(\"manifesto-lineage.decoration\");\n\nexport type ResolvedLineageConfig = LineageConfig & {\n  readonly service: LineageService;\n};\n\nexport type LineageDecoration = {\n  readonly service: LineageService;\n  readonly config: ResolvedLineageConfig;\n};\n\nexport type InternalLineageComposableManifesto<\n  T extends ManifestoDomainShape,\n  Laws extends BaseLaws,\n> = ComposableManifesto<T, Laws & LineageLaws> & {\n  readonly [LINEAGE_DECORATION]: LineageDecoration;\n};\n\nexport type SealIntentOptions = {\n  readonly proposalRef?: string;\n  readonly decisionRef?: string;\n  readonly publishOnCompleted?: boolean;\n  readonly assumeEnqueued?: boolean;\n};\n\nexport type SealedIntentResult<T extends ManifestoDomainShape> = {\n  readonly intent: Intent;\n  readonly hostResult: Awaited<ReturnType<RuntimeKernel<T>[\"executeHost\"]>>;\n  readonly preparedCommit: PreparedNextCommit;\n  readonly publishedSnapshot?: Snapshot<T[\"state\"]>;\n};\n\nexport interface LineageRuntimeController<T extends ManifestoDomainShape> {\n  ensureReady(): Promise<void>;\n  sealIntent(\n    intent: Intent,\n    options?: SealIntentOptions,\n  ): Promise<SealedIntentResult<T>>;\n  getWorld(worldId: WorldId): Promise<World | null>;\n  getLatestHead(): Promise<WorldHead | null>;\n  getHeads(): Promise<readonly WorldHead[]>;\n  getBranches(): Promise<readonly BranchInfo[]>;\n  getActiveBranch(): Promise<BranchInfo>;\n  getCurrentBranchId(): Promise<BranchId>;\n  getCurrentCompletedWorldId(): Promise<WorldId>;\n  restore(worldId: WorldId): Promise<void>;\n  switchActiveBranch(branchId: BranchId): Promise<BranchSwitchResult>;\n  createBranch(name: string, fromWorldId?: WorldId): Promise<BranchId>;\n}\n\nexport function attachLineageDecoration<\n  T extends ManifestoDomainShape,\n  Laws extends BaseLaws,\n>(\n  manifesto: ComposableManifesto<T, Laws & LineageLaws>,\n  decoration: LineageDecoration,\n): InternalLineageComposableManifesto<T, Laws> {\n  Object.defineProperty(manifesto, LINEAGE_DECORATION, {\n    enumerable: false,\n    configurable: false,\n    writable: false,\n    value: decoration,\n  });\n\n  return manifesto as InternalLineageComposableManifesto<T, Laws>;\n}\n\nexport function getLineageDecoration<\n  T extends ManifestoDomainShape,\n  Laws extends BaseLaws,\n>(\n  manifesto: ComposableManifesto<T, Laws>,\n): LineageDecoration | null {\n  const internal = manifesto as Partial<InternalLineageComposableManifesto<T, Laws>>;\n  return internal[LINEAGE_DECORATION] ?? null;\n}\n\nexport function createLineageRuntimeController<T extends ManifestoDomainShape>(\n  kernel: RuntimeKernel<T>,\n  service: LineageService,\n  config: ResolvedLineageConfig,\n): LineageRuntimeController<T> {\n  let readiness: Promise<void> | null = null;\n  let currentBranchId: string | null = null;\n  let currentCompletedWorldId: WorldId | null = null;\n\n  async function ensureReady(): Promise<void> {\n    if (readiness) {\n      return readiness;\n    }\n\n    readiness = bootstrapLineage().catch((error) => {\n      readiness = null;\n      throw error;\n    });\n\n    return readiness;\n  }\n\n  async function bootstrapLineage(): Promise<void> {\n    const branches = await service.getBranches();\n    if (branches.length === 0) {\n      if (config.branchId) {\n        throw new ManifestoError(\n          \"LINEAGE_BRANCH_NOT_FOUND\",\n          `Configured branch \"${config.branchId}\" does not exist in the lineage store`,\n        );\n      }\n\n      const genesisSnapshot = kernel.getVisibleCoreSnapshot();\n      const prepared = await service.prepareSealGenesis({\n        schemaHash: kernel.schema.hash,\n        terminalSnapshot: genesisSnapshot,\n        createdAt: genesisSnapshot.meta.timestamp,\n      });\n      await service.commitPrepared(prepared);\n      currentBranchId = prepared.branchId;\n      currentCompletedWorldId = prepared.worldId;\n      return;\n    }\n\n    const branch = await bindInitialBranch(config.branchId);\n    currentBranchId = branch.id;\n    currentCompletedWorldId = branch.head;\n    const restored = await service.restore(branch.head);\n    kernel.setVisibleSnapshot(restored, { notify: false });\n  }\n\n  async function bindInitialBranch(branchId?: string): Promise<BranchInfo> {\n    if (!branchId) {\n      return service.getActiveBranch();\n    }\n\n    const branch = await service.getBranch(branchId);\n    if (!branch) {\n      throw new ManifestoError(\n        \"LINEAGE_BRANCH_NOT_FOUND\",\n        `Configured branch \"${branchId}\" does not exist in the lineage store`,\n      );\n    }\n\n    const activeBranch = await service.getActiveBranch();\n    if (activeBranch.id !== branch.id) {\n      await service.switchActiveBranch(branch.id);\n    }\n\n    return branch;\n  }\n\n  async function sealIntent(\n    intent: Intent,\n    options?: SealIntentOptions,\n  ): Promise<SealedIntentResult<T>> {\n    if (kernel.isDisposed()) {\n      throw new DisposedError();\n    }\n\n    const enrichedIntent = kernel.ensureIntentId(intent);\n\n    const runSeal = async () => {\n      if (kernel.isDisposed()) {\n        throw new DisposedError();\n      }\n\n      await ensureReady();\n\n      if (!kernel.isActionAvailable(enrichedIntent.type as keyof T[\"actions\"])) {\n        return kernel.rejectUnavailable(enrichedIntent);\n      }\n\n      let result: Awaited<ReturnType<RuntimeKernel<T>[\"executeHost\"]>>;\n      try {\n        result = await kernel.executeHost(enrichedIntent);\n      } catch (error) {\n        kernel.restoreVisibleSnapshot();\n        throw toError(error);\n      }\n\n      if (!currentBranchId || !currentCompletedWorldId) {\n        kernel.restoreVisibleSnapshot();\n        throw new ManifestoError(\n          \"LINEAGE_STATE_ERROR\",\n          \"Lineage runtime has no active branch continuity after bootstrap\",\n        );\n      }\n\n      let prepared: PreparedNextCommit;\n      try {\n        prepared = await service.prepareSealNext({\n          schemaHash: kernel.schema.hash,\n          baseWorldId: currentCompletedWorldId,\n          branchId: currentBranchId,\n          terminalSnapshot: result.snapshot,\n          createdAt: result.snapshot.meta.timestamp,\n          ...(options?.proposalRef ? { proposalRef: options.proposalRef } : {}),\n          ...(options?.decisionRef ? { decisionRef: options.decisionRef } : {}),\n        });\n        await service.commitPrepared(prepared);\n      } catch (error) {\n        kernel.restoreVisibleSnapshot();\n        throw toError(error);\n      }\n\n      if (prepared.branchChange.headAdvanced) {\n        currentCompletedWorldId = prepared.worldId;\n      }\n\n      if (prepared.branchChange.headAdvanced && options?.publishOnCompleted !== false) {\n        return {\n          intent: enrichedIntent,\n          hostResult: result,\n          preparedCommit: prepared,\n          publishedSnapshot: kernel.setVisibleSnapshot(result.snapshot),\n        };\n      }\n\n      kernel.restoreVisibleSnapshot();\n      return {\n        intent: enrichedIntent,\n        hostResult: result,\n        preparedCommit: prepared,\n      };\n    };\n\n    if (options?.assumeEnqueued) {\n      return runSeal();\n    }\n\n    return kernel.enqueue(runSeal);\n  }\n\n  async function getWorld(worldId: WorldId): Promise<World | null> {\n    await ensureReady();\n    return service.getWorld(worldId);\n  }\n\n  async function getLatestHead(): Promise<WorldHead | null> {\n    await ensureReady();\n    return service.getLatestHead();\n  }\n\n  async function getHeads(): Promise<readonly WorldHead[]> {\n    await ensureReady();\n    return service.getHeads();\n  }\n\n  async function getBranches(): Promise<readonly BranchInfo[]> {\n    await ensureReady();\n    return service.getBranches();\n  }\n\n  async function getActiveBranch(): Promise<BranchInfo> {\n    await ensureReady();\n    if (currentBranchId) {\n      const branch = await service.getBranch(currentBranchId);\n      if (branch) {\n        return branch;\n      }\n    }\n    return service.getActiveBranch();\n  }\n\n  async function getCurrentBranchId(): Promise<BranchId> {\n    return (await getActiveBranch()).id;\n  }\n\n  async function getCurrentCompletedWorldId(): Promise<WorldId> {\n    await ensureReady();\n    if (!currentCompletedWorldId) {\n      throw new ManifestoError(\n        \"LINEAGE_STATE_ERROR\",\n        \"Lineage runtime has no completed world continuity\",\n      );\n    }\n    return currentCompletedWorldId;\n  }\n\n  async function restore(worldId: WorldId): Promise<void> {\n    if (kernel.isDisposed()) {\n      throw new DisposedError();\n    }\n\n    await kernel.enqueue(async () => {\n      if (kernel.isDisposed()) {\n        throw new DisposedError();\n      }\n\n      await ensureReady();\n      const restored = await service.restore(worldId);\n      kernel.setVisibleSnapshot(restored);\n      currentCompletedWorldId = worldId;\n\n      const branches = await service.getBranches();\n      const matchingBranch = branches.find((branch) => branch.head === worldId);\n      if (matchingBranch) {\n        currentBranchId = matchingBranch.id;\n      }\n    });\n  }\n\n  async function switchActiveBranch(branchId: string): Promise<BranchSwitchResult> {\n    if (kernel.isDisposed()) {\n      throw new DisposedError();\n    }\n\n    return kernel.enqueue(async () => {\n      if (kernel.isDisposed()) {\n        throw new DisposedError();\n      }\n\n      await ensureReady();\n      const result = await service.switchActiveBranch(branchId);\n      const branch = await service.getBranch(branchId);\n\n      if (!branch) {\n        throw new ManifestoError(\n          \"LINEAGE_BRANCH_NOT_FOUND\",\n          `Cannot switch to unknown branch \"${branchId}\"`,\n        );\n      }\n\n      const restored = await service.restore(branch.head);\n      kernel.setVisibleSnapshot(restored);\n      currentBranchId = branch.id;\n      currentCompletedWorldId = branch.head;\n      return result;\n    });\n  }\n\n  async function createBranch(name: string, fromWorldId?: WorldId): Promise<BranchId> {\n    if (kernel.isDisposed()) {\n      throw new DisposedError();\n    }\n\n    return kernel.enqueue(async () => {\n      if (kernel.isDisposed()) {\n        throw new DisposedError();\n      }\n\n      await ensureReady();\n      const headWorldId = fromWorldId ?? currentCompletedWorldId;\n      if (!headWorldId) {\n        throw new ManifestoError(\n          \"LINEAGE_STATE_ERROR\",\n          \"Cannot create a branch before lineage continuity is bootstrapped\",\n        );\n      }\n\n      return service.createBranch(name, headWorldId);\n    });\n  }\n\n  return {\n    ensureReady,\n    sealIntent,\n    getWorld,\n    getLatestHead,\n    getHeads,\n    getBranches,\n    getActiveBranch,\n    getCurrentBranchId,\n    getCurrentCompletedWorldId,\n    restore,\n    switchActiveBranch,\n    createBranch,\n  };\n}\n\nfunction toError(error: unknown): Error {\n  return error instanceof Error\n    ? error\n    : new Error(String(error));\n}\n"],"mappings":"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","names":[]}

package/dist/index.d.ts

@@ -1,201 +1,8 @@
-import { Snapshot, Patch, ErrorValue, Requirement } from '@manifesto-ai/core';
+import { W as WorldId, T as TerminalStatus, C as CurrentErrorSignature, S as SnapshotHashInput, a as World, b as WorldEdge, B as BranchId, c as SealGenesisInput, d as SealAttempt, e as SealNextInput, P as PersistedBranchEntry, f as BranchInfo, g as WorldHead, L as LineageStore, h as WorldLineage, i as PreparedBranchMutation, j as PreparedLineageCommit, k as LineageService, l as BranchSwitchResult, m as LineageConfig, n as LineageComposableManifesto } from './runtime-types-CXAjv1Op.js';
+export { q as ArtifactRef, A as AttemptId, y as LineageInstance, s as PersistedBranchState, r as PersistedPatchDeltaV2, t as PreparedBranchBootstrap, u as PreparedBranchChange, w as PreparedGenesisCommit, v as PreparedLineageRecords, x as PreparedNextCommit, p as ProvenanceRef, o as SchemaHash } from './runtime-types-CXAjv1Op.js';
+import { Snapshot, ErrorValue, Requirement } from '@manifesto-ai/core';
 export { Patch, Snapshot } from '@manifesto-ai/core';
-
-type WorldId = string;
-type BranchId = string;
-type SchemaHash = string;
-type ProvenanceRef = string;
-type AttemptId = string;
-interface ArtifactRef {
-    readonly uri: string;
-    readonly hash: string;
-}
-type TerminalStatus = "completed" | "failed";
-interface CurrentErrorSignature {
-    readonly code: string;
-    readonly source: {
-        readonly actionId: string;
-        readonly nodePath: string;
-    };
-}
-interface SnapshotHashInput {
-    readonly data: Record<string, unknown>;
-    readonly system: {
-        readonly terminalStatus: TerminalStatus;
-        readonly currentError: CurrentErrorSignature | null;
-        readonly pendingDigest: string;
-    };
-}
-interface World {
-    readonly worldId: WorldId;
-    readonly schemaHash: SchemaHash;
-    readonly snapshotHash: string;
-    readonly parentWorldId: WorldId | null;
-    readonly terminalStatus: TerminalStatus;
-}
-interface WorldEdge {
-    readonly edgeId: string;
-    readonly from: WorldId;
-    readonly to: WorldId;
-}
-interface WorldLineage {
-    readonly genesis: WorldId;
-    readonly worlds: ReadonlyMap<WorldId, World>;
-    readonly edges: ReadonlyMap<string, WorldEdge>;
-}
-interface PersistedPatchDeltaV2 {
-    readonly _patchFormat: 2;
-    readonly patches: readonly Patch[];
-}
-interface SealGenesisInput {
-    readonly schemaHash: SchemaHash;
-    readonly terminalSnapshot: Snapshot;
-    readonly createdAt: number;
-    readonly branchName?: string;
-    readonly proposalRef?: ProvenanceRef;
-    readonly traceRef?: ArtifactRef;
-}
-interface SealNextInput {
-    readonly schemaHash: SchemaHash;
-    readonly baseWorldId: WorldId;
-    readonly branchId: BranchId;
-    readonly terminalSnapshot: Snapshot;
-    readonly createdAt: number;
-    readonly patchDelta?: PersistedPatchDeltaV2;
-    readonly proposalRef?: ProvenanceRef;
-    readonly decisionRef?: ProvenanceRef;
-    readonly traceRef?: ArtifactRef;
-}
-interface BranchInfo {
-    readonly id: BranchId;
-    readonly name: string;
-    readonly head: WorldId;
-    readonly tip: WorldId;
-    readonly headAdvancedAt: number;
-    readonly epoch: number;
-    readonly schemaHash: SchemaHash;
-    readonly createdAt: number;
-}
-interface PersistedBranchEntry {
-    readonly id: BranchId;
-    readonly name: string;
-    readonly head: WorldId;
-    readonly tip: WorldId;
-    readonly headAdvancedAt: number;
-    readonly epoch: number;
-    readonly schemaHash: SchemaHash;
-    readonly createdAt: number;
-}
-interface PersistedBranchState {
-    readonly branches: readonly PersistedBranchEntry[];
-    readonly activeBranchId: BranchId;
-}
-interface WorldHead {
-    readonly worldId: WorldId;
-    readonly branchId: BranchId;
-    readonly branchName: string;
-    readonly createdAt: number;
-    readonly schemaHash: SchemaHash;
-}
-interface BranchSwitchResult {
-    readonly previousBranchId: BranchId;
-    readonly targetBranchId: BranchId;
-    readonly sourceBranchEpochAfter: number;
-}
-interface PreparedBranchMutation {
-    readonly kind: "advance";
-    readonly branchId: BranchId;
-    readonly expectedHead: WorldId;
-    readonly nextHead: WorldId;
-    readonly headAdvanced: boolean;
-    readonly expectedTip: WorldId;
-    readonly nextTip: WorldId;
-    readonly headAdvancedAt: number | null;
-    readonly expectedEpoch: number;
-    readonly nextEpoch: number;
-}
-interface PreparedBranchBootstrap {
-    readonly kind: "bootstrap";
-    readonly branch: PersistedBranchEntry;
-    readonly activeBranchId: BranchId;
-}
-type PreparedBranchChange = PreparedBranchMutation | PreparedBranchBootstrap;
-interface SealAttempt {
-    readonly attemptId: AttemptId;
-    readonly worldId: WorldId;
-    readonly branchId: BranchId;
-    readonly baseWorldId: WorldId | null;
-    readonly parentWorldId: WorldId | null;
-    readonly proposalRef?: ProvenanceRef;
-    readonly decisionRef?: ProvenanceRef;
-    readonly createdAt: number;
-    readonly traceRef?: ArtifactRef;
-    readonly patchDelta?: PersistedPatchDeltaV2;
-    readonly reused: boolean;
-}
-interface PreparedLineageRecords {
-    readonly worldId: WorldId;
-    readonly world: World;
-    readonly terminalSnapshot: Snapshot;
-    readonly hashInput: SnapshotHashInput;
-    readonly attempt: SealAttempt;
-}
-interface PreparedGenesisCommit extends PreparedLineageRecords {
-    readonly kind: "genesis";
-    readonly branchId: BranchId;
-    readonly terminalStatus: "completed";
-    readonly edge: null;
-    readonly branchChange: PreparedBranchBootstrap;
-}
-interface PreparedNextCommit extends PreparedLineageRecords {
-    readonly kind: "next";
-    readonly branchId: BranchId;
-    readonly terminalStatus: TerminalStatus;
-    readonly edge: WorldEdge;
-    readonly forkCreated: boolean;
-    readonly branchChange: PreparedBranchMutation;
-}
-type PreparedLineageCommit = PreparedGenesisCommit | PreparedNextCommit;
-interface LineageStore {
-    putWorld(world: World): Promise<void>;
-    getWorld(worldId: WorldId): Promise<World | null>;
-    putSnapshot(worldId: WorldId, snapshot: Snapshot): Promise<void>;
-    getSnapshot(worldId: WorldId): Promise<Snapshot | null>;
-    putAttempt(attempt: SealAttempt): Promise<void>;
-    getAttempts(worldId: WorldId): Promise<readonly SealAttempt[]>;
-    getAttemptsByBranch(branchId: BranchId): Promise<readonly SealAttempt[]>;
-    putHashInput?(snapshotHash: string, input: SnapshotHashInput): Promise<void>;
-    getHashInput?(snapshotHash: string): Promise<SnapshotHashInput | null>;
-    putEdge(edge: WorldEdge): Promise<void>;
-    getEdges(worldId: WorldId): Promise<readonly WorldEdge[]>;
-    getBranchHead(branchId: BranchId): Promise<WorldId | null>;
-    getBranchTip(branchId: BranchId): Promise<WorldId | null>;
-    getBranchEpoch(branchId: BranchId): Promise<number>;
-    mutateBranch(mutation: PreparedBranchMutation): Promise<void>;
-    putBranch(branch: PersistedBranchEntry): Promise<void>;
-    getBranches(): Promise<readonly PersistedBranchEntry[]>;
-    getActiveBranchId(): Promise<BranchId | null>;
-    switchActiveBranch(sourceBranchId: BranchId, targetBranchId: BranchId): Promise<void>;
-    commitPrepared(prepared: PreparedLineageCommit): Promise<void>;
-}
-interface LineageService {
-    prepareSealGenesis(input: SealGenesisInput): Promise<PreparedGenesisCommit>;
-    prepareSealNext(input: SealNextInput): Promise<PreparedNextCommit>;
-    commitPrepared(prepared: PreparedLineageCommit): Promise<void>;
-    createBranch(name: string, headWorldId: WorldId): Promise<BranchId>;
-    getBranch(branchId: BranchId): Promise<BranchInfo | null>;
-    getBranches(): Promise<readonly BranchInfo[]>;
-    getActiveBranch(): Promise<BranchInfo>;
-    switchActiveBranch(targetBranchId: BranchId): Promise<BranchSwitchResult>;
-    getWorld(worldId: WorldId): Promise<World | null>;
-    getSnapshot(worldId: WorldId): Promise<Snapshot | null>;
-    getAttempts(worldId: WorldId): Promise<readonly SealAttempt[]>;
-    getAttemptsByBranch(branchId: BranchId): Promise<readonly SealAttempt[]>;
-    getLineage(): Promise<WorldLineage>;
-    getHeads(): Promise<readonly WorldHead[]>;
-    getLatestHead(): Promise<WorldHead | null>;
-    restore(worldId: WorldId): Promise<Snapshot>;
-}
+import { ManifestoDomainShape, BaseLaws, ComposableManifesto } from '@manifesto-ai/sdk';
 
 declare function computeHash(value: unknown): string;
 declare function isPlatformNamespace(key: string): boolean;
@@ -408,4 +215,6 @@ declare class DefaultLineageService implements LineageService {
 }
 declare function createLineageService(store: LineageStore): LineageService;
 
-export { type ArtifactRef, type AttemptId, type BranchId, type BranchInfo, type BranchSwitchResult, type CurrentErrorSignature, DefaultLineageService, InMemoryLineageStore, type LineageService, type LineageStore, type PersistedBranchEntry, type PersistedBranchState, type PersistedPatchDeltaV2, type PreparedBranchBootstrap, type PreparedBranchChange, type PreparedBranchMutation, type PreparedGenesisCommit, type PreparedLineageCommit, type PreparedLineageRecords, type PreparedNextCommit, type ProvenanceRef, type SchemaHash, type SealAttempt, type SealGenesisInput, type SealNextInput, type SnapshotHashInput, type TerminalStatus, type World, type WorldEdge, type WorldHead, type WorldId, type WorldLineage, type WorldRecordResult, buildWorldLineage, computeHash, computePendingDigest, computeSnapshotHash, computeWorldId, createGenesisBranchEntry, createInMemoryLineageStore, createLineageService, createSealGenesisAttempt, createSealNextAttempt, createSnapshotHashInput, createWorldEdge, createWorldRecord, deriveTerminalStatus, getHeadsFromStore, isPlatformNamespace, normalizeContext, restoreSnapshot, selectLatestHead, stripPlatformNamespaces, toBranchInfo, toCurrentErrorSignature, toWorldHead };
+declare function withLineage<T extends ManifestoDomainShape, Laws extends BaseLaws>(manifesto: ComposableManifesto<T, Laws>, config?: LineageConfig): LineageComposableManifesto<T, Laws>;
+
+export { BranchId, BranchInfo, BranchSwitchResult, CurrentErrorSignature, DefaultLineageService, InMemoryLineageStore, LineageComposableManifesto, LineageConfig, LineageService, LineageStore, PersistedBranchEntry, PreparedBranchMutation, PreparedLineageCommit, SealAttempt, SealGenesisInput, SealNextInput, SnapshotHashInput, TerminalStatus, World, WorldEdge, WorldHead, WorldId, WorldLineage, type WorldRecordResult, buildWorldLineage, computeHash, computePendingDigest, computeSnapshotHash, computeWorldId, createGenesisBranchEntry, createInMemoryLineageStore, createLineageService, createSealGenesisAttempt, createSealNextAttempt, createSnapshotHashInput, createWorldEdge, createWorldRecord, deriveTerminalStatus, getHeadsFromStore, isPlatformNamespace, normalizeContext, restoreSnapshot, selectLatestHead, stripPlatformNamespaces, toBranchInfo, toCurrentErrorSignature, toWorldHead, withLineage };