@manifesto-ai/sdk 2.2.0 → 3.1.0

package/README.md

@@ -1,53 +1,79 @@
 # @manifesto-ai/sdk
 
-> Thin direct-dispatch entry point for Manifesto applications.
+> Activation-first entry point for Manifesto applications.
 
-`@manifesto-ai/sdk` is the default package for applications that start with `createManifesto()`. It stays thin and only re-exports the governed world assembly surface needed for explicit composition.
+`@manifesto-ai/sdk` is the default package for applications that start with `createManifesto()`.
+
+> **Current Contract Note:** The truthful current SDK contract is the ADR-017 activation model documented in [docs/sdk-SPEC-v3.0.0-draft.md](docs/sdk-SPEC-v3.0.0-draft.md). The filename still says `draft` because the wider ADR-017 landing across Lineage, Governance, and World is still in progress.
 
 ## What This Package Owns
 
 - `createManifesto()`
-- `dispatchAsync()`
-- `defineOps()`
-- typed operation helpers
-- thin world re-exports for `createWorld()` and `createInMemoryWorldStore()`
+- the activation boundary via `activate()`
+- the present-only base runtime returned after activation
+- SDK error types
+- selected Core pass-through types used by SDK signatures
 
 ## When to Use It
 
 Use the SDK when you want:
 
-- the shortest path to direct-dispatch execution
-- subscriptions and snapshot reads without manual governed wiring
-- thin access to the governed world assembler, while keeping full governance and lineage APIs in `@manifesto-ai/world`
+- the shortest path to a running base world
+- typed intent creation through `MEL.actions.*`
+- `dispatchAsync`, subscriptions, availability queries, and snapshot reads in one package
+- a clear boundary between law composition and runtime execution
 
-## Direct Dispatch
+## Activation Lifecycle
 
 ```typescript
-import { createIntent, createManifesto, dispatchAsync } from "@manifesto-ai/sdk";
+import { createManifesto } from "@manifesto-ai/sdk";
+
+const manifesto = createManifesto<CounterDomain>(counterSchema, {});
+const world = manifesto.activate();
 
-const manifesto = createManifesto({
-  schema: counterSchema,
-  effects: {},
-});
+const intent = world.createIntent(world.MEL.actions.increment);
+await world.dispatchAsync(intent);
 
-await dispatchAsync(manifesto, createIntent("increment", "intent-1"));
+world.isActionAvailable("increment");
+world.getAvailableActions();
+world.getSnapshot();
 ```
 
-## Governed Composition
+The canonical SDK lifecycle is:
 
-```typescript
-import {
-  createInMemoryWorldStore,
-  createWorld,
-} from "@manifesto-ai/sdk";
-```
+1. build a composable manifesto with `createManifesto(schema, effects)`
+2. open it once with `activate()`
+3. create typed intents from `world.MEL.actions.*`
+4. execute with instance-owned `dispatchAsync()`
+5. observe through `subscribe()` / `on()` and read through `getSnapshot()`
+
+## Base Runtime Surface
+
+The activated base runtime exposes:
+
+- `createIntent`
+- `dispatchAsync`
+- `subscribe`
+- `on`
+- `getSnapshot`
+- `getAvailableActions`
+- `isActionAvailable`
+- `MEL`
+- `dispose`
+
+## Governed Composition Direction
+
+SDK no longer re-exports the old World facade or its bootstrap helpers.
+
+The public direction under ADR-017 is:
 
-These are the thin re-exports from top-level `@manifesto-ai/world`.
+`createManifesto() -> withLineage() -> withGovernance() -> activate()`
 
-For the full governed surface, including `createGovernanceService()`, `createLineageService()`, and `createGovernanceEventDispatcher()`, import `@manifesto-ai/world` directly.
+Those governed runtime contracts land in the owning `@manifesto-ai/lineage` and `@manifesto-ai/governance` packages. Older world-facade docs are historical tombstones rather than current guidance.
 
 ## Docs
 
 - [SDK Guide](docs/GUIDE.md)
-- [SDK Specification](docs/sdk-SPEC-v2.0.0.md)
+- [SDK Specification v3](docs/sdk-SPEC-v3.0.0-draft.md)
+- [SDK Specification v2](docs/sdk-SPEC-v2.0.0.md)
 - [VERSION-INDEX](docs/VERSION-INDEX.md)

package/dist/chunk-CMZQTFX2.js

@@ -0,0 +1,332 @@
+// src/internal.ts
+import {
+  getAvailableActions as queryAvailableActions,
+  isActionAvailable as queryActionAvailable
+} from "@manifesto-ai/core";
+
+// src/errors.ts
+var ManifestoError = class extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message, options);
+    this.name = "ManifestoError";
+    this.code = code;
+  }
+};
+var ReservedEffectError = class extends ManifestoError {
+  effectType;
+  constructor(effectType) {
+    super(
+      "RESERVED_EFFECT",
+      `Effect type "${effectType}" is reserved and cannot be overridden`
+    );
+    this.name = "ReservedEffectError";
+    this.effectType = effectType;
+  }
+};
+var CompileError = class extends ManifestoError {
+  diagnostics;
+  constructor(diagnostics, formattedMessage) {
+    super("COMPILE_ERROR", formattedMessage);
+    this.name = "CompileError";
+    this.diagnostics = diagnostics;
+  }
+};
+var DisposedError = class extends ManifestoError {
+  constructor() {
+    super("DISPOSED", "Cannot use a disposed Manifesto runtime");
+    this.name = "DisposedError";
+  }
+};
+var AlreadyActivatedError = class extends ManifestoError {
+  constructor() {
+    super("ALREADY_ACTIVATED", "ComposableManifesto.activate() may only be called once");
+    this.name = "AlreadyActivatedError";
+  }
+};
+
+// src/internal.ts
+var ACTION_PARAM_NAMES = /* @__PURE__ */ Symbol("manifesto-sdk.action-param-names");
+var RUNTIME_KERNEL_FACTORY = /* @__PURE__ */ Symbol("manifesto-sdk.runtime-kernel-factory");
+function attachRuntimeKernelFactory(manifesto, factory) {
+  Object.defineProperty(manifesto, RUNTIME_KERNEL_FACTORY, {
+    enumerable: false,
+    configurable: false,
+    writable: false,
+    value: factory
+  });
+  return manifesto;
+}
+function getRuntimeKernelFactory(manifesto) {
+  const internal = manifesto;
+  const factory = internal[RUNTIME_KERNEL_FACTORY];
+  if (typeof factory !== "function") {
+    throw new ManifestoError(
+      "SCHEMA_ERROR",
+      "ComposableManifesto is missing its runtime kernel factory"
+    );
+  }
+  return factory;
+}
+function createRuntimeKernel({
+  schema,
+  host,
+  MEL,
+  createIntent
+}) {
+  const initialSnapshot = host.getSnapshot();
+  if (!initialSnapshot) {
+    throw new ManifestoError("SCHEMA_ERROR", "Host failed to initialize its genesis snapshot");
+  }
+  let visibleSnapshot = initialSnapshot;
+  let dispatchQueue = Promise.resolve();
+  let disposed = false;
+  const subscribers = /* @__PURE__ */ new Set();
+  const eventListeners = /* @__PURE__ */ new Map();
+  function subscribe(selector, listener) {
+    if (disposed) {
+      return () => {
+      };
+    }
+    let lastValue;
+    let initialized = false;
+    try {
+      lastValue = selector(snapshotForSelector(visibleSnapshot));
+      initialized = true;
+    } catch {
+      lastValue = void 0;
+      initialized = false;
+    }
+    const subscriber = {
+      selector,
+      listener,
+      lastValue,
+      initialized
+    };
+    subscribers.add(subscriber);
+    return () => {
+      subscribers.delete(subscriber);
+    };
+  }
+  function on(event, handler) {
+    if (disposed) {
+      return () => {
+      };
+    }
+    let listeners = eventListeners.get(event);
+    if (!listeners) {
+      listeners = /* @__PURE__ */ new Set();
+      eventListeners.set(
+        event,
+        listeners
+      );
+    }
+    listeners.add(handler);
+    return () => {
+      listeners?.delete(handler);
+    };
+  }
+  function getSnapshot() {
+    return freezeSnapshot(visibleSnapshot);
+  }
+  function getAvailableActions() {
+    return queryAvailableActions(schema, visibleSnapshot);
+  }
+  function isActionAvailable(name) {
+    return queryActionAvailable(schema, visibleSnapshot, String(name));
+  }
+  function dispose() {
+    if (disposed) {
+      return;
+    }
+    disposed = true;
+    subscribers.clear();
+    eventListeners.clear();
+  }
+  function setVisibleSnapshot(snapshot, options) {
+    visibleSnapshot = structuredClone(snapshot);
+    host.reset(visibleSnapshot);
+    const publishedSnapshot = freezeSnapshot(visibleSnapshot);
+    if (options?.notify !== false) {
+      notifySubscribers(publishedSnapshot);
+    }
+    return publishedSnapshot;
+  }
+  function restoreVisibleSnapshot() {
+    host.reset(visibleSnapshot);
+  }
+  function emitEvent(event, payload) {
+    const listeners = eventListeners.get(event);
+    if (!listeners) {
+      return;
+    }
+    for (const handler of listeners) {
+      try {
+        handler(payload);
+      } catch {
+      }
+    }
+  }
+  function enqueue(task) {
+    const result = dispatchQueue.catch(() => {
+    }).then(task);
+    dispatchQueue = result.then(() => void 0, () => void 0);
+    return result;
+  }
+  function ensureIntentId(intent) {
+    if (intent.intentId && intent.intentId.length > 0) {
+      return intent;
+    }
+    return {
+      ...intent,
+      intentId: generateUUID()
+    };
+  }
+  async function executeHost(intent) {
+    return host.dispatch(intent);
+  }
+  function rejectUnavailable(intent) {
+    const error = new ManifestoError(
+      "ACTION_UNAVAILABLE",
+      `Action "${intent.type}" is unavailable against the current visible snapshot`
+    );
+    emitEvent("dispatch:rejected", {
+      intentId: intent.intentId ?? "",
+      intent,
+      reason: error.message
+    });
+    throw error;
+  }
+  function notifySubscribers(snapshot) {
+    for (const subscriber of subscribers) {
+      let selected;
+      try {
+        selected = subscriber.selector(snapshot);
+      } catch {
+        continue;
+      }
+      if (subscriber.initialized && Object.is(subscriber.lastValue, selected)) {
+        continue;
+      }
+      subscriber.lastValue = selected;
+      subscriber.initialized = true;
+      try {
+        subscriber.listener(selected);
+      } catch {
+      }
+    }
+  }
+  return {
+    schema,
+    MEL,
+    createIntent,
+    subscribe,
+    on,
+    getSnapshot,
+    getAvailableActions,
+    isActionAvailable,
+    dispose,
+    isDisposed: () => disposed,
+    getVisibleCoreSnapshot: () => structuredClone(visibleSnapshot),
+    setVisibleSnapshot,
+    restoreVisibleSnapshot,
+    emitEvent,
+    enqueue,
+    ensureIntentId,
+    executeHost,
+    rejectUnavailable
+  };
+}
+function createBaseRuntimeInstance(kernel) {
+  async function processIntent(intent) {
+    if (kernel.isDisposed()) {
+      throw new DisposedError();
+    }
+    if (!kernel.isActionAvailable(intent.type)) {
+      return kernel.rejectUnavailable(intent);
+    }
+    let result;
+    try {
+      result = await kernel.executeHost(intent);
+    } catch (error) {
+      const failure = toError(error);
+      kernel.emitEvent("dispatch:failed", {
+        intentId: intent.intentId ?? "",
+        intent,
+        error: failure
+      });
+      throw failure;
+    }
+    if (result.status === "error") {
+      const publishedSnapshot2 = kernel.setVisibleSnapshot(result.snapshot);
+      const failure = result.error ?? new ManifestoError("HOST_ERROR", "Host dispatch failed");
+      kernel.emitEvent("dispatch:failed", {
+        intentId: intent.intentId ?? "",
+        intent,
+        error: failure,
+        snapshot: publishedSnapshot2
+      });
+      throw failure;
+    }
+    const publishedSnapshot = kernel.setVisibleSnapshot(result.snapshot);
+    kernel.emitEvent("dispatch:completed", {
+      intentId: intent.intentId ?? "",
+      intent,
+      snapshot: publishedSnapshot
+    });
+    return publishedSnapshot;
+  }
+  function dispatchAsync(intent) {
+    if (kernel.isDisposed()) {
+      return Promise.reject(new DisposedError());
+    }
+    const enrichedIntent = kernel.ensureIntentId(intent);
+    return kernel.enqueue(() => processIntent(enrichedIntent));
+  }
+  return {
+    createIntent: kernel.createIntent,
+    dispatchAsync,
+    subscribe: kernel.subscribe,
+    on: kernel.on,
+    getSnapshot: kernel.getSnapshot,
+    getAvailableActions: kernel.getAvailableActions,
+    isActionAvailable: kernel.isActionAvailable,
+    MEL: kernel.MEL,
+    schema: kernel.schema,
+    dispose: kernel.dispose
+  };
+}
+function snapshotForSelector(snapshot) {
+  return freezeSnapshot(snapshot);
+}
+function freezeSnapshot(snapshot) {
+  return Object.freeze(structuredClone(snapshot));
+}
+function toError(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+function generateUUID() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (char) => {
+    const random = Math.random() * 16 | 0;
+    const value = char === "x" ? random : random & 3 | 8;
+    return value.toString(16);
+  });
+}
+
+export {
+  ManifestoError,
+  ReservedEffectError,
+  CompileError,
+  DisposedError,
+  AlreadyActivatedError,
+  ACTION_PARAM_NAMES,
+  RUNTIME_KERNEL_FACTORY,
+  attachRuntimeKernelFactory,
+  getRuntimeKernelFactory,
+  createRuntimeKernel,
+  createBaseRuntimeInstance
+};
+//# sourceMappingURL=chunk-CMZQTFX2.js.map

package/dist/chunk-CMZQTFX2.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internal.ts","../src/errors.ts"],"sourcesContent":["import {\n  getAvailableActions as queryAvailableActions,\n  isActionAvailable as queryActionAvailable,\n  type DomainSchema,\n  type Intent,\n  type Snapshot as CoreSnapshot,\n} from \"@manifesto-ai/core\";\nimport type { HostResult, ManifestoHost } from \"@manifesto-ai/host\";\n\nimport {\n  DisposedError,\n  ManifestoError,\n} from \"./errors.js\";\nimport type {\n  BaseLaws,\n  ComposableManifesto,\n  ManifestoBaseInstance,\n  ManifestoDomainShape,\n  ManifestoEvent,\n  ManifestoEventMap,\n  Selector,\n  Snapshot,\n  TypedCreateIntent,\n  TypedMEL,\n  TypedOn,\n  TypedSubscribe,\n  Unsubscribe,\n} from \"./types.js\";\n\nexport const ACTION_PARAM_NAMES = Symbol(\"manifesto-sdk.action-param-names\");\nexport const RUNTIME_KERNEL_FACTORY = Symbol(\"manifesto-sdk.runtime-kernel-factory\");\n\ninterface Subscriber<TState, R> {\n  readonly selector: Selector<TState, R>;\n  readonly listener: (value: R) => void;\n  lastValue: R | undefined;\n  initialized: boolean;\n}\n\nexport interface RuntimeKernel<T extends ManifestoDomainShape> {\n  readonly schema: DomainSchema;\n  readonly MEL: TypedMEL<T>;\n  readonly createIntent: TypedCreateIntent<T>;\n  readonly subscribe: TypedSubscribe<T>;\n  readonly on: TypedOn<T>;\n  readonly getSnapshot: () => Snapshot<T[\"state\"]>;\n  readonly getAvailableActions: () => readonly (keyof T[\"actions\"])[];\n  readonly isActionAvailable: (name: keyof T[\"actions\"]) => boolean;\n  readonly dispose: () => void;\n  readonly isDisposed: () => boolean;\n  readonly getVisibleCoreSnapshot: () => CoreSnapshot;\n  readonly setVisibleSnapshot: (\n    snapshot: CoreSnapshot,\n    options?: { readonly notify?: boolean },\n  ) => Snapshot<T[\"state\"]>;\n  readonly restoreVisibleSnapshot: () => void;\n  readonly emitEvent: <K extends ManifestoEvent>(\n    event: K,\n    payload: ManifestoEventMap<T>[K],\n  ) => void;\n  readonly enqueue: <R>(task: () => Promise<R>) => Promise<R>;\n  readonly ensureIntentId: (intent: Intent) => Intent;\n  readonly executeHost: (intent: Intent) => Promise<HostResult>;\n  readonly rejectUnavailable: (intent: Intent) => never;\n}\n\nexport type RuntimeKernelFactory<T extends ManifestoDomainShape> = () => RuntimeKernel<T>;\n\nexport type InternalComposableManifesto<\n  T extends ManifestoDomainShape,\n  Laws extends BaseLaws,\n> = ComposableManifesto<T, Laws> & {\n  readonly [RUNTIME_KERNEL_FACTORY]: RuntimeKernelFactory<T>;\n};\n\ntype RuntimeKernelOptions<T extends ManifestoDomainShape> = {\n  readonly schema: DomainSchema;\n  readonly host: ManifestoHost;\n  readonly MEL: TypedMEL<T>;\n  readonly createIntent: TypedCreateIntent<T>;\n};\n\nexport function attachRuntimeKernelFactory<\n  T extends ManifestoDomainShape,\n  Laws extends BaseLaws,\n>(\n  manifesto: ComposableManifesto<T, Laws>,\n  factory: RuntimeKernelFactory<T>,\n): InternalComposableManifesto<T, Laws> {\n  Object.defineProperty(manifesto, RUNTIME_KERNEL_FACTORY, {\n    enumerable: false,\n    configurable: false,\n    writable: false,\n    value: factory,\n  });\n\n  return manifesto as InternalComposableManifesto<T, Laws>;\n}\n\nexport function getRuntimeKernelFactory<\n  T extends ManifestoDomainShape,\n  Laws extends BaseLaws,\n>(\n  manifesto: ComposableManifesto<T, Laws>,\n): RuntimeKernelFactory<T> {\n  const internal = manifesto as Partial<InternalComposableManifesto<T, Laws>>;\n  const factory = internal[RUNTIME_KERNEL_FACTORY];\n\n  if (typeof factory !== \"function\") {\n    throw new ManifestoError(\n      \"SCHEMA_ERROR\",\n      \"ComposableManifesto is missing its runtime kernel factory\",\n    );\n  }\n\n  return factory;\n}\n\nexport function createRuntimeKernel<T extends ManifestoDomainShape>({\n  schema,\n  host,\n  MEL,\n  createIntent,\n}: RuntimeKernelOptions<T>): RuntimeKernel<T> {\n  const initialSnapshot = host.getSnapshot();\n  if (!initialSnapshot) {\n    throw new ManifestoError(\"SCHEMA_ERROR\", \"Host failed to initialize its genesis snapshot\");\n  }\n\n  let visibleSnapshot: CoreSnapshot = initialSnapshot;\n  let dispatchQueue: Promise<void> = Promise.resolve();\n  let disposed = false;\n\n  const subscribers = new Set<Subscriber<T[\"state\"], unknown>>();\n  const eventListeners = new Map<\n    ManifestoEvent,\n    Set<(payload: ManifestoEventMap<T>[ManifestoEvent]) => void>\n  >();\n\n  function subscribe<R>(\n    selector: Selector<T[\"state\"], R>,\n    listener: (value: R) => void,\n  ): Unsubscribe {\n    if (disposed) {\n      return () => {};\n    }\n\n    let lastValue: R | undefined;\n    let initialized = false;\n\n    try {\n      lastValue = selector(snapshotForSelector<T[\"state\"]>(visibleSnapshot));\n      initialized = true;\n    } catch {\n      lastValue = undefined;\n      initialized = false;\n    }\n\n    const subscriber: Subscriber<T[\"state\"], R> = {\n      selector,\n      listener,\n      lastValue,\n      initialized,\n    };\n\n    subscribers.add(subscriber as Subscriber<T[\"state\"], unknown>);\n    return () => {\n      subscribers.delete(subscriber as Subscriber<T[\"state\"], unknown>);\n    };\n  }\n\n  function on<K extends ManifestoEvent>(\n    event: K,\n    handler: (payload: ManifestoEventMap<T>[K]) => void,\n  ): Unsubscribe {\n    if (disposed) {\n      return () => {};\n    }\n\n    let listeners = eventListeners.get(event);\n    if (!listeners) {\n      listeners = new Set();\n      eventListeners.set(\n        event,\n        listeners as Set<(payload: ManifestoEventMap<T>[ManifestoEvent]) => void>,\n      );\n    }\n\n    listeners.add(handler as (payload: ManifestoEventMap<T>[ManifestoEvent]) => void);\n    return () => {\n      listeners?.delete(handler as (payload: ManifestoEventMap<T>[ManifestoEvent]) => void);\n    };\n  }\n\n  function getSnapshot(): Snapshot<T[\"state\"]> {\n    return freezeSnapshot(visibleSnapshot) as Snapshot<T[\"state\"]>;\n  }\n\n  function getAvailableActions(): readonly (keyof T[\"actions\"])[] {\n    return queryAvailableActions(schema, visibleSnapshot) as readonly (keyof T[\"actions\"])[];\n  }\n\n  function isActionAvailable(name: keyof T[\"actions\"]): boolean {\n    return queryActionAvailable(schema, visibleSnapshot, String(name));\n  }\n\n  function dispose(): void {\n    if (disposed) {\n      return;\n    }\n\n    disposed = true;\n    subscribers.clear();\n    eventListeners.clear();\n  }\n\n  function setVisibleSnapshot(\n    snapshot: CoreSnapshot,\n    options?: { readonly notify?: boolean },\n  ): Snapshot<T[\"state\"]> {\n    visibleSnapshot = structuredClone(snapshot);\n    host.reset(visibleSnapshot);\n\n    const publishedSnapshot = freezeSnapshot(visibleSnapshot) as Snapshot<T[\"state\"]>;\n    if (options?.notify !== false) {\n      notifySubscribers(publishedSnapshot);\n    }\n    return publishedSnapshot;\n  }\n\n  function restoreVisibleSnapshot(): void {\n    host.reset(visibleSnapshot);\n  }\n\n  function emitEvent<K extends ManifestoEvent>(\n    event: K,\n    payload: ManifestoEventMap<T>[K],\n  ): void {\n    const listeners = eventListeners.get(event);\n    if (!listeners) {\n      return;\n    }\n\n    for (const handler of listeners) {\n      try {\n        handler(payload);\n      } catch {\n        // Event handler failures are isolated from runtime semantics.\n      }\n    }\n  }\n\n  function enqueue<R>(task: () => Promise<R>): Promise<R> {\n    const result = dispatchQueue\n      .catch(() => {})\n      .then(task);\n\n    dispatchQueue = result.then(() => undefined, () => undefined);\n    return result;\n  }\n\n  function ensureIntentId(intent: Intent): Intent {\n    if (intent.intentId && intent.intentId.length > 0) {\n      return intent;\n    }\n\n    return {\n      ...intent,\n      intentId: generateUUID(),\n    };\n  }\n\n  async function executeHost(intent: Intent): Promise<HostResult> {\n    return host.dispatch(intent);\n  }\n\n  function rejectUnavailable(intent: Intent): never {\n    const error = new ManifestoError(\n      \"ACTION_UNAVAILABLE\",\n      `Action \"${intent.type}\" is unavailable against the current visible snapshot`,\n    );\n    emitEvent(\"dispatch:rejected\", {\n      intentId: intent.intentId ?? \"\",\n      intent,\n      reason: error.message,\n    });\n    throw error;\n  }\n\n  function notifySubscribers(snapshot: Snapshot<T[\"state\"]>): void {\n    for (const subscriber of subscribers) {\n      let selected: unknown;\n      try {\n        selected = subscriber.selector(snapshot);\n      } catch {\n        continue;\n      }\n\n      if (subscriber.initialized && Object.is(subscriber.lastValue, selected)) {\n        continue;\n      }\n\n      subscriber.lastValue = selected;\n      subscriber.initialized = true;\n\n      try {\n        subscriber.listener(selected);\n      } catch {\n        // Listener failures are isolated from runtime semantics.\n      }\n    }\n  }\n\n  return {\n    schema,\n    MEL,\n    createIntent,\n    subscribe,\n    on,\n    getSnapshot,\n    getAvailableActions,\n    isActionAvailable,\n    dispose,\n    isDisposed: () => disposed,\n    getVisibleCoreSnapshot: () => structuredClone(visibleSnapshot),\n    setVisibleSnapshot,\n    restoreVisibleSnapshot,\n    emitEvent,\n    enqueue,\n    ensureIntentId,\n    executeHost,\n    rejectUnavailable,\n  };\n}\n\nexport function createBaseRuntimeInstance<T extends ManifestoDomainShape>(\n  kernel: RuntimeKernel<T>,\n): ManifestoBaseInstance<T> {\n  async function processIntent(intent: Intent): Promise<Snapshot<T[\"state\"]>> {\n    if (kernel.isDisposed()) {\n      throw new DisposedError();\n    }\n\n    if (!kernel.isActionAvailable(intent.type as keyof T[\"actions\"])) {\n      return kernel.rejectUnavailable(intent);\n    }\n\n    let result: HostResult;\n    try {\n      result = await kernel.executeHost(intent);\n    } catch (error) {\n      const failure = toError(error);\n      kernel.emitEvent(\"dispatch:failed\", {\n        intentId: intent.intentId ?? \"\",\n        intent,\n        error: failure,\n      });\n      throw failure;\n    }\n\n    if (result.status === \"error\") {\n      const publishedSnapshot = kernel.setVisibleSnapshot(result.snapshot);\n      const failure = result.error ?? new ManifestoError(\"HOST_ERROR\", \"Host dispatch failed\");\n      kernel.emitEvent(\"dispatch:failed\", {\n        intentId: intent.intentId ?? \"\",\n        intent,\n        error: failure,\n        snapshot: publishedSnapshot,\n      });\n      throw failure;\n    }\n\n    const publishedSnapshot = kernel.setVisibleSnapshot(result.snapshot);\n    kernel.emitEvent(\"dispatch:completed\", {\n      intentId: intent.intentId ?? \"\",\n      intent,\n      snapshot: publishedSnapshot,\n    });\n    return publishedSnapshot;\n  }\n\n  function dispatchAsync(intent: Intent): Promise<Snapshot<T[\"state\"]>> {\n    if (kernel.isDisposed()) {\n      return Promise.reject(new DisposedError());\n    }\n\n    const enrichedIntent = kernel.ensureIntentId(intent);\n    return kernel.enqueue(() => processIntent(enrichedIntent));\n  }\n\n  return {\n    createIntent: kernel.createIntent,\n    dispatchAsync,\n    subscribe: kernel.subscribe,\n    on: kernel.on,\n    getSnapshot: kernel.getSnapshot,\n    getAvailableActions: kernel.getAvailableActions,\n    isActionAvailable: kernel.isActionAvailable,\n    MEL: kernel.MEL,\n    schema: kernel.schema,\n    dispose: kernel.dispose,\n  };\n}\n\nfunction snapshotForSelector<TState>(snapshot: CoreSnapshot): Snapshot<TState> {\n  return freezeSnapshot(snapshot) as Snapshot<TState>;\n}\n\nfunction freezeSnapshot<TData = unknown>(snapshot: CoreSnapshot): Snapshot<TData> {\n  return Object.freeze(structuredClone(snapshot)) as Snapshot<TData>;\n}\n\nfunction toError(error: unknown): Error {\n  return error instanceof Error\n    ? error\n    : new Error(String(error));\n}\n\nfunction generateUUID(): string {\n  if (typeof crypto !== \"undefined\" && typeof crypto.randomUUID === \"function\") {\n    return crypto.randomUUID();\n  }\n\n  return \"xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx\".replace(/[xy]/g, (char) => {\n    const random = (Math.random() * 16) | 0;\n    const value = char === \"x\" ? random : (random & 0x3) | 0x8;\n    return value.toString(16);\n  });\n}\n","export class ManifestoError extends Error {\n  readonly code: string;\n\n  constructor(code: string, message: string, options?: ErrorOptions) {\n    super(message, options);\n    this.name = \"ManifestoError\";\n    this.code = code;\n  }\n}\n\nexport class ReservedEffectError extends ManifestoError {\n  readonly effectType: string;\n\n  constructor(effectType: string) {\n    super(\n      \"RESERVED_EFFECT\",\n      `Effect type \"${effectType}\" is reserved and cannot be overridden`,\n    );\n    this.name = \"ReservedEffectError\";\n    this.effectType = effectType;\n  }\n}\n\nexport interface CompileDiagnostic {\n  readonly severity: \"error\" | \"warning\" | \"info\";\n  readonly code: string;\n  readonly message: string;\n  readonly location: {\n    readonly start: { readonly line: number; readonly column: number; readonly offset: number };\n    readonly end: { readonly line: number; readonly column: number; readonly offset: number };\n  };\n  readonly source?: string;\n  readonly suggestion?: string;\n}\n\nexport class CompileError extends ManifestoError {\n  readonly diagnostics: readonly CompileDiagnostic[];\n\n  constructor(diagnostics: readonly CompileDiagnostic[], formattedMessage: string) {\n    super(\"COMPILE_ERROR\", formattedMessage);\n    this.name = \"CompileError\";\n    this.diagnostics = diagnostics;\n  }\n}\n\nexport class DisposedError extends ManifestoError {\n  constructor() {\n    super(\"DISPOSED\", \"Cannot use a disposed Manifesto runtime\");\n    this.name = \"DisposedError\";\n  }\n}\n\nexport class AlreadyActivatedError extends ManifestoError {\n  constructor() {\n    super(\"ALREADY_ACTIVATED\", \"ComposableManifesto.activate() may only be called once\");\n    this.name = \"AlreadyActivatedError\";\n  }\n}\n"],"mappings":"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","names":["publishedSnapshot"]}