@manifesto-ai/sdk 3.18.1 → 5.1.0

package/dist/provider.js

@@ -1 +1 @@
-import{a as c}from"./chunk-JM42OG2H.js";import{k as e,l as t,m as n,n as a,p as r,q as o,r as i}from"./chunk-BSGOCNTO.js";import"./chunk-BDIXNUQ3.js";export{i as activateComposable,o as assertComposableNotActivated,a as attachExtensionKernel,t as attachRuntimeKernelFactory,c as createBaseRuntimeInstance,e as createRuntimeKernel,r as getActivationState,n as getRuntimeKernelFactory};
+import{a as s}from"./chunk-OW22XF26.js";import{j as e,k as t,l as a,m as n,n as o,o as r,q as i,r as l,s as m}from"./chunk-DPFMD6LR.js";import"./chunk-TG2UPPZN.js";export{m as activateComposable,l as assertComposableNotActivated,r as attachExtensionKernel,n as attachRuntimeKernelFactory,s as createBaseRuntimeInstance,e as createRuntimeKernel,i as getActivationState,o as getRuntimeKernelFactory,a as mapBlockedAdmission,t as toBlocker};

package/dist/runtime/action-payload.d.ts

@@ -0,0 +1,9 @@
+import { ManifestoError } from "../errors.js";
+export declare function cloneAndFreezeActionPayload<T>(value: T): T;
+export declare function tryCloneAndFreezeActionPayload<T>(value: T): {
+    readonly ok: true;
+    readonly value: T;
+} | {
+    readonly ok: false;
+    readonly error: ManifestoError;
+};

package/dist/runtime/admission-failure.d.ts

@@ -0,0 +1,16 @@
+import type { AdmissionFailure, Blocker, DispatchBlocker } from "../types.js";
+/**
+ * Shared admission-failure mapping for runtime surfaces.
+ *
+ * The base, lineage, and governance runtimes expose the same
+ * action-candidate admission contract; this module is the single source
+ * for narrowing a blocked kernel admission into the public
+ * AdmissionFailure shape (previously triplicated across the three
+ * runtime files).
+ */
+export declare function toBlocker(blocker: DispatchBlocker, code: Blocker["code"]): Blocker;
+export declare function mapBlockedAdmission<Name extends string>(actionName: Name, admission: {
+    readonly failure: {
+        readonly kind: string;
+    };
+}, fallbackMessage?: string): AdmissionFailure<Name>;

package/dist/runtime/admission.d.ts

@@ -1,5 +1,5 @@
-import { type DomainSchema, type Snapshot as CoreSnapshot } from "@manifesto-ai/core";
-import type { CanonicalSnapshot, ManifestoDomainShape, ManifestoEventMap, Snapshot, TypedIntent } from "../types.js";
+import { type ActionAvailabilityEvaluation, type ActionDispatchabilityEvaluation, type DomainSchema, type Snapshot as CoreSnapshot } from "@manifesto-ai/core";
+import type { CanonicalSnapshot, ManifestoDomainShape, ProjectedSnapshot, TypedIntent } from "../types.js";
 import type { RuntimeAdmission, RuntimeSimulateSync } from "./facets.js";
 type RuntimeAdmissionOptions<T extends ManifestoDomainShape> = {
     readonly schema: DomainSchema;
@@ -7,9 +7,10 @@ type RuntimeAdmissionOptions<T extends ManifestoDomainShape> = {
     readonly getAvailableActionsFor: (snapshot: CanonicalSnapshot<T["state"]>) => readonly (keyof T["actions"])[];
     readonly isActionAvailableFor: (snapshot: CanonicalSnapshot<T["state"]>, name: keyof T["actions"]) => boolean;
     readonly isIntentDispatchableFor: (snapshot: CanonicalSnapshot<T["state"]>, intent: TypedIntent<T>) => boolean;
-    readonly projectSnapshotFromCanonical: (snapshot: CoreSnapshot) => Snapshot<T["state"]>;
+    readonly evaluateActionAvailabilityFor: (snapshot: CanonicalSnapshot<T["state"]>, name: keyof T["actions"]) => ActionAvailabilityEvaluation;
+    readonly evaluateIntentDispatchabilityFor: (snapshot: CanonicalSnapshot<T["state"]>, intent: TypedIntent<T>) => ActionDispatchabilityEvaluation;
+    readonly projectSnapshotFromCanonical: (snapshot: CoreSnapshot) => ProjectedSnapshot<T>;
     readonly getSimulateSync: () => RuntimeSimulateSync<T>;
-    readonly emitEvent: <K extends keyof ManifestoEventMap<T>>(event: K, payload: ManifestoEventMap<T>[K]) => void;
 };
-export declare function createRuntimeAdmission<T extends ManifestoDomainShape>({ schema, ensureIntentId, getAvailableActionsFor, isActionAvailableFor, isIntentDispatchableFor, projectSnapshotFromCanonical, getSimulateSync, emitEvent, }: RuntimeAdmissionOptions<T>): RuntimeAdmission<T>;
+export declare function createRuntimeAdmission<T extends ManifestoDomainShape>({ schema, ensureIntentId, getAvailableActionsFor, isActionAvailableFor, evaluateActionAvailabilityFor, evaluateIntentDispatchabilityFor, projectSnapshotFromCanonical, getSimulateSync, }: RuntimeAdmissionOptions<T>): RuntimeAdmission<T>;
 export {};

package/dist/runtime/base-dispatch.d.ts

@@ -1,8 +1,7 @@
-import type { DispatchReport, ExecutionDiagnostics, ExecutionFailureInfo, ExecutionOutcome, IntentAdmission, ManifestoDomainShape, Snapshot, TypedIntent } from "../types.js";
+import type { DispatchReport, ExecutionDiagnostics, ExecutionFailureInfo, DispatchExecutionOutcome, IntentAdmission, ManifestoDomainShape, ProjectedSnapshot, TypedIntent } from "../types.js";
 import type { ExtensionKernel } from "../extensions-types.js";
 import type { RuntimeKernel } from "../compat/internal.js";
 import { ManifestoError } from "../errors.js";
-import { emitDispatchRejectedEvent } from "./events.js";
 import type { RuntimePublicationHelpers } from "./facets.js";
 type RejectedAttempt<T extends ManifestoDomainShape> = {
     readonly kind: "rejected";
@@ -10,9 +9,12 @@ type RejectedAttempt<T extends ManifestoDomainShape> = {
     readonly admission: Extract<IntentAdmission<T>, {
         readonly kind: "blocked";
     }>;
-    readonly beforeSnapshot: Snapshot<T["state"]>;
+    readonly beforeSnapshot: ProjectedSnapshot<T>;
     readonly beforeCanonicalSnapshot: ReturnType<RuntimeKernel<T>["getCanonicalSnapshot"]>;
-    readonly rejection: ReturnType<typeof emitDispatchRejectedEvent<T>>;
+    readonly rejection: {
+        readonly code: "ACTION_UNAVAILABLE" | "INTENT_NOT_DISPATCHABLE" | "INVALID_INPUT";
+        readonly reason: string;
+    };
     readonly rejectionError: ManifestoError;
 };
 type FailedAttempt<T extends ManifestoDomainShape> = {
@@ -21,13 +23,13 @@ type FailedAttempt<T extends ManifestoDomainShape> = {
     readonly admission: Extract<IntentAdmission<T>, {
         readonly kind: "admitted";
     }>;
-    readonly beforeSnapshot: Snapshot<T["state"]>;
+    readonly beforeSnapshot: ProjectedSnapshot<T>;
     readonly beforeCanonicalSnapshot: ReturnType<RuntimeKernel<T>["getCanonicalSnapshot"]>;
     readonly failure: Error;
     readonly errorInfo: ExecutionFailureInfo;
     readonly published: boolean;
     readonly diagnostics?: ExecutionDiagnostics;
-    readonly outcome?: ExecutionOutcome<T>;
+    readonly outcome?: DispatchExecutionOutcome<T>;
 };
 type CompletedAttempt<T extends ManifestoDomainShape> = {
     readonly kind: "completed";
@@ -35,12 +37,12 @@ type CompletedAttempt<T extends ManifestoDomainShape> = {
     readonly admission: Extract<IntentAdmission<T>, {
         readonly kind: "admitted";
     }>;
-    readonly publishedSnapshot: Snapshot<T["state"]>;
-    readonly outcome: ExecutionOutcome<T>;
+    readonly publishedSnapshot: ProjectedSnapshot<T>;
+    readonly outcome: DispatchExecutionOutcome<T>;
     readonly diagnostics: ExecutionDiagnostics;
 };
 export type BaseDispatchAttemptResult<T extends ManifestoDomainShape = ManifestoDomainShape> = RejectedAttempt<T> | FailedAttempt<T> | CompletedAttempt<T>;
-export declare function runBaseDispatchAttempt<T extends ManifestoDomainShape>(kernel: RuntimeKernel<T>, extensionKernel: Pick<ExtensionKernel<T>, "projectSnapshot">, publication: Pick<RuntimePublicationHelpers<T>, "publishCompletedHostResult" | "publishFailedHostResult">, intent: TypedIntent<T>): Promise<BaseDispatchAttemptResult<T>>;
-export declare function attemptToDispatchAsyncResult<T extends ManifestoDomainShape>(attempt: BaseDispatchAttemptResult<T>): Snapshot<T["state"]>;
+export declare function runBaseDispatchAttempt<T extends ManifestoDomainShape>(kernel: RuntimeKernel<T>, extensionKernel: Pick<ExtensionKernel<T>, "projectSnapshot">, publication: Pick<RuntimePublicationHelpers<T>, "publishCompletedHostResult" | "publishFailedHostResult">, intent: TypedIntent<T>, context: ReturnType<RuntimeKernel<T>["createComputeContext"]>): Promise<BaseDispatchAttemptResult<T>>;
+export declare function attemptToDispatchAsyncResult<T extends ManifestoDomainShape>(attempt: BaseDispatchAttemptResult<T>): ProjectedSnapshot<T>;
 export declare function attemptToDispatchReport<T extends ManifestoDomainShape>(attempt: BaseDispatchAttemptResult<T>): DispatchReport<T>;
 export {};

package/dist/runtime/base-runtime.d.ts

@@ -1,3 +1,10 @@
-import type { ManifestoBaseInstance, ManifestoDomainShape } from "../types.js";
+import type { ManifestoApp, ManifestoDomainShape, PreviewDiagnosticsMode, SubmitReportMode } from "../types.js";
 import { type RuntimeKernel } from "../compat/internal.js";
-export declare function createBaseRuntimeInstance<T extends ManifestoDomainShape>(kernel: RuntimeKernel<T>): ManifestoBaseInstance<T>;
+type BaseMode = "base";
+type RuntimeExecutionView<T extends ManifestoDomainShape> = {
+    readonly context?: ReturnType<RuntimeKernel<T>["getExternalContext"]>;
+    readonly diagnostics?: PreviewDiagnosticsMode;
+    readonly report?: SubmitReportMode;
+};
+export declare function createBaseRuntimeInstance<T extends ManifestoDomainShape>(kernel: RuntimeKernel<T>, view?: RuntimeExecutionView<T>, isView?: boolean): ManifestoApp<T, BaseMode>;
+export {};

package/dist/runtime/context.d.ts

@@ -0,0 +1,4 @@
+import { type DomainSchema } from "@manifesto-ai/core";
+import type { DomainExternalContext, ManifestoDomainShape } from "../types.js";
+export declare function materializeExternalContext<T extends ManifestoDomainShape>(schema: DomainSchema, value: unknown, source: string): DomainExternalContext<T>;
+export declare function captureExternalContext<T extends ManifestoDomainShape>(schema: DomainSchema, current: DomainExternalContext<T>, override: unknown, source: string): DomainExternalContext<T>;

package/dist/runtime/facets.d.ts

@@ -1,24 +1,24 @@
-import type { ComputeStatus, Patch, Requirement, Snapshot as CoreSnapshot, SystemDelta } from "@manifesto-ai/core";
+import type { Context, ComputeStatus, Patch, Requirement, Snapshot as CoreSnapshot, SystemDelta } from "@manifesto-ai/core";
 import type { HostResult } from "@manifesto-ai/host";
-import type { DispatchBlocker, CanonicalSnapshot, ExecutionDiagnostics, ExecutionFailureInfo, ExecutionOutcome, IntentAdmission, IntentExplanation, ManifestoDomainShape, ManifestoEvent, ManifestoEventMap, SimulationDiagnostics, Snapshot, TypedIntent, TypedOn, TypedSubscribe } from "../types.js";
+import type { DispatchBlocker, CanonicalSnapshot, DomainExternalContext, DispatchExecutionOutcome, ExecutionDiagnostics, ExecutionFailureInfo, IntentAdmission, IntentExplanation, ManifestoDomainShape, ManifestoEvent, ManifestoEventPayloadMap, ProjectedSnapshot, SimulationDiagnostics, TypedIntent, TypedOn, TypedSubscribe } from "../types.js";
 import type { ManifestoError } from "../errors.js";
 export interface RuntimeStateStore<T extends ManifestoDomainShape> {
     readonly subscribe: TypedSubscribe<T>;
     readonly on: TypedOn<T>;
-    readonly getSnapshot: () => Snapshot<T["state"]>;
+    readonly getSnapshot: () => ProjectedSnapshot<T>;
     readonly getCanonicalSnapshot: () => CanonicalSnapshot<T["state"]>;
     readonly getVisibleCoreSnapshot: () => CoreSnapshot;
     readonly setVisibleSnapshot: (snapshot: CoreSnapshot, options?: {
         readonly notify?: boolean;
-    }) => Snapshot<T["state"]>;
+    }) => ProjectedSnapshot<T>;
     readonly restoreVisibleSnapshot: () => void;
-    readonly emitEvent: <K extends ManifestoEvent>(event: K, payload: ManifestoEventMap<T>[K]) => void;
+    readonly emitEvent: <K extends ManifestoEvent>(event: K, payload: ManifestoEventPayloadMap[K]) => void;
     readonly enqueue: <R>(task: () => Promise<R>) => Promise<R>;
     readonly dispose: () => void;
     readonly isDisposed: () => boolean;
 }
 export interface RuntimeReportHelpers<T extends ManifestoDomainShape> {
-    readonly deriveExecutionOutcome: (beforeSnapshot: CanonicalSnapshot<T["state"]>, afterSnapshot: CanonicalSnapshot<T["state"]>) => ExecutionOutcome<T>;
+    readonly deriveExecutionOutcome: (beforeSnapshot: CanonicalSnapshot<T["state"]>, afterSnapshot: CanonicalSnapshot<T["state"]>) => DispatchExecutionOutcome<T>;
     readonly classifyExecutionFailure: (error: unknown, stage: "host" | "seal") => ExecutionFailureInfo;
     readonly createExecutionDiagnostics: (result: HostResult) => ExecutionDiagnostics;
 }
@@ -49,7 +49,10 @@ export type RuntimeSimulationResult<T extends ManifestoDomainShape = ManifestoDo
     readonly requirements: readonly Requirement[];
     readonly diagnostics?: SimulationDiagnostics;
 };
-export type RuntimeSimulateSync<T extends ManifestoDomainShape = ManifestoDomainShape> = (snapshot: CanonicalSnapshot<T["state"]>, intent: TypedIntent<T>) => RuntimeSimulationResult<T>;
+export type RuntimeSimulateSync<T extends ManifestoDomainShape = ManifestoDomainShape> = (snapshot: CanonicalSnapshot<T["state"]>, intent: TypedIntent<T>, options?: {
+    readonly externalContext?: DomainExternalContext<T>;
+    readonly context?: Context;
+}) => RuntimeSimulationResult<T>;
 export interface RuntimeAdmission<T extends ManifestoDomainShape> {
     readonly getIntentBlockersFor: (snapshot: CanonicalSnapshot<T["state"]>, intent: TypedIntent<T>) => readonly DispatchBlocker[];
     readonly validateIntentInputFor: (snapshot: CanonicalSnapshot<T["state"]>, intent: TypedIntent<T>) => ManifestoError | null;
@@ -63,12 +66,12 @@ export interface RuntimeAdmission<T extends ManifestoDomainShape> {
     readonly rejectNotDispatchable: (intent: TypedIntent<T>) => never;
 }
 export type PublishedRuntimeSnapshot<T extends ManifestoDomainShape = ManifestoDomainShape> = {
-    readonly publishedSnapshot: Snapshot<T["state"]>;
+    readonly publishedSnapshot: ProjectedSnapshot<T>;
     readonly publishedCanonicalSnapshot: CanonicalSnapshot<T["state"]>;
 };
 export interface RuntimePublicationHelpers<T extends ManifestoDomainShape> {
     readonly replaceVisibleSnapshot: RuntimeStateStore<T>["setVisibleSnapshot"];
     readonly restoreVisibleSnapshot: RuntimeStateStore<T>["restoreVisibleSnapshot"];
-    readonly publishCompletedHostResult: (intent: TypedIntent<T>, snapshot: CoreSnapshot) => PublishedRuntimeSnapshot<T>;
-    readonly publishFailedHostResult: (intent: TypedIntent<T>, error: Error, snapshot: CoreSnapshot) => PublishedRuntimeSnapshot<T>;
+    readonly publishCompletedHostResult: (snapshot: CoreSnapshot) => PublishedRuntimeSnapshot<T>;
+    readonly publishFailedHostResult: (snapshot: CoreSnapshot) => PublishedRuntimeSnapshot<T>;
 }

package/dist/runtime/kernel-contract.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Runtime kernel contract: the full kernel interface, its facet
+ * decomposition, and the decorator-facing kernel aliases (#421).
+ *
+ * This file is the design home of the seam types. The facet aliases
+ * (LineageRuntimeKernel, GovernanceRuntimeKernel,
+ * WaitForProposalRuntimeKernel) are the primary dependency surfaces for
+ * decorator and provider code; the broad RuntimeKernel aggregate exists
+ * for kernel assembly and compatibility, not as the unit new code should
+ * depend on. compat/internal re-exports everything here unchanged, so
+ * the provider seam stays source-compatible.
+ */
+import { type ComputeStatus, type DomainSchema, type JsonValue, type Patch, type Requirement, type Snapshot as CoreSnapshot, type SystemDelta } from "@manifesto-ai/core";
+import type { HostContextProvider, HostResult, ManifestoHost } from "@manifesto-ai/host";
+import type { Context } from "@manifesto-ai/core";
+import type { ActionAnnotation, CanonicalSnapshot, ContextUpdater, DispatchExecutionOutcome, DispatchBlocker, DomainExternalContext, ExternalContext, ExecutionDiagnostics, ExecutionFailureInfo, IntentAdmission, ManifestoDomainShape, ManifestoEvent, ManifestoEventPayloadMap, ProjectedSnapshot, SchemaGraph, SimulationDiagnostics, TypedCreateIntent, TypedDomainRefs, TypedGetActionMetadata, TypedGetIntentBlockers, TypedIntent, TypedIsIntentDispatchable, TypedMEL, TypedOn, TypedSimulate, TypedSimulateIntent, TypedSubscribe } from "../types.js";
+import type { SnapshotProjectionPlan } from "../projection/snapshot-projection.js";
+import type { IntentLegalityEvaluation } from "./facets.js";
+import type { ManifestoError } from "../errors.js";
+import type { ExtensionKernel } from "../extensions-types.js";
+import { EXTENSION_KERNEL } from "../compat/runtime-symbols.js";
+export type HostDispatchOptions = NonNullable<Parameters<ManifestoHost["dispatch"]>[1]>;
+export type SimulateResult<T extends ManifestoDomainShape = ManifestoDomainShape> = {
+    readonly snapshot: CanonicalSnapshot<T["state"]>;
+    readonly patches: readonly Patch[];
+    readonly systemDelta: Readonly<SystemDelta>;
+    readonly status: ComputeStatus;
+    readonly requirements: readonly Requirement[];
+    readonly diagnostics?: SimulationDiagnostics;
+};
+export interface RuntimeKernel<T extends ManifestoDomainShape> {
+    readonly schema: DomainSchema;
+    readonly refs: TypedDomainRefs<T>;
+    /** @deprecated Use refs. */
+    readonly MEL: TypedMEL<T>;
+    readonly createIntent: TypedCreateIntent<T>;
+    readonly subscribe: TypedSubscribe<T>;
+    readonly on: TypedOn<T>;
+    readonly getSnapshot: () => ProjectedSnapshot<T>;
+    readonly getCanonicalSnapshot: () => CanonicalSnapshot<T["state"]>;
+    readonly getAvailableActionsFor: (snapshot: CanonicalSnapshot<T["state"]>) => readonly (keyof T["actions"])[];
+    readonly getAvailableActions: () => readonly (keyof T["actions"])[];
+    readonly getIntentBlockersFor: (snapshot: CanonicalSnapshot<T["state"]>, intent: TypedIntent<T>) => readonly DispatchBlocker[];
+    readonly getActionMetadata: TypedGetActionMetadata<T>;
+    readonly isActionAvailableFor: (snapshot: CanonicalSnapshot<T["state"]>, name: keyof T["actions"]) => boolean;
+    readonly isActionAvailable: (name: keyof T["actions"]) => boolean;
+    readonly isIntentDispatchableFor: (snapshot: CanonicalSnapshot<T["state"]>, intent: TypedIntent<T>) => boolean;
+    readonly isIntentDispatchable: TypedIsIntentDispatchable<T>;
+    readonly getIntentBlockers: TypedGetIntentBlockers<T>;
+    readonly getSchemaGraph: () => SchemaGraph;
+    readonly simulateSync: (snapshot: CanonicalSnapshot<T["state"]>, intent: TypedIntent<T>, options?: {
+        readonly externalContext?: DomainExternalContext<T>;
+        readonly context?: Context;
+    }) => SimulateResult<T>;
+    readonly simulate: TypedSimulate<T>;
+    readonly simulateIntent: TypedSimulateIntent<T>;
+    readonly dispose: () => void;
+    readonly isDisposed: () => boolean;
+    readonly getVisibleCoreSnapshot: () => CoreSnapshot;
+    readonly setVisibleSnapshot: (snapshot: CoreSnapshot, options?: {
+        readonly notify?: boolean;
+    }) => ProjectedSnapshot<T>;
+    readonly rehydrateSnapshot: (snapshot: CoreSnapshot) => CoreSnapshot;
+    readonly restoreVisibleSnapshot: () => void;
+    readonly emitEvent: <K extends ManifestoEvent>(event: K, payload: ManifestoEventPayloadMap[K]) => void;
+    readonly enqueue: <R>(task: () => Promise<R>) => Promise<R>;
+    readonly ensureIntentId: (intent: TypedIntent<T>) => TypedIntent<T>;
+    readonly executeHost: (intent: TypedIntent<T>, options?: HostDispatchOptions) => Promise<HostResult>;
+    readonly createComputeContext: (intent: TypedIntent<T>, externalContext?: ExternalContext) => Context;
+    readonly getExternalContext: () => DomainExternalContext<T>;
+    readonly replaceExternalContext: (next: DomainExternalContext<T>) => DomainExternalContext<T>;
+    readonly updateExternalContext: (updater: ContextUpdater<DomainExternalContext<T>>) => DomainExternalContext<T>;
+    readonly captureExternalContext: (override?: ExternalContext) => DomainExternalContext<T>;
+    readonly validateIntentInputFor: (snapshot: CanonicalSnapshot<T["state"]>, intent: TypedIntent<T>) => ManifestoError | null;
+    readonly evaluateIntentLegalityFor: (snapshot: CanonicalSnapshot<T["state"]>, intent: TypedIntent<T>) => IntentLegalityEvaluation<T>;
+    readonly deriveIntentAdmission: (snapshot: CanonicalSnapshot<T["state"]>, legality: IntentLegalityEvaluation<T>) => IntentAdmission<T>;
+    readonly deriveExecutionOutcome: (beforeSnapshot: CanonicalSnapshot<T["state"]>, afterSnapshot: CanonicalSnapshot<T["state"]>) => DispatchExecutionOutcome<T>;
+    readonly classifyExecutionFailure: (error: unknown, stage: "host" | "seal") => ExecutionFailureInfo;
+    readonly createExecutionDiagnostics: (result: HostResult) => ExecutionDiagnostics;
+    readonly createUnavailableError: (intent: TypedIntent<T>) => ManifestoError;
+    readonly createNotDispatchableError: (intent: TypedIntent<T>) => ManifestoError;
+    readonly rejectInvalidInput: (intent: TypedIntent<T>, message: string) => never;
+    readonly rejectUnavailable: (intent: TypedIntent<T>) => never;
+    readonly rejectNotDispatchable: (intent: TypedIntent<T>) => never;
+    readonly [EXTENSION_KERNEL]: ExtensionKernel<T>;
+}
+export type RuntimePublicReadFacet<T extends ManifestoDomainShape> = Pick<RuntimeKernel<T>, "schema" | "MEL" | "createIntent" | "subscribe" | "on" | "getSnapshot" | "getCanonicalSnapshot" | "getAvailableActionsFor" | "getAvailableActions" | "isIntentDispatchable" | "getIntentBlockers" | "getActionMetadata" | "isActionAvailable" | "getSchemaGraph" | "simulateSync" | "simulate" | "simulateIntent" | "getExternalContext" | "replaceExternalContext" | "updateExternalContext" | "captureExternalContext">;
+export type RuntimeLifecycleFacet<T extends ManifestoDomainShape> = Pick<RuntimeKernel<T>, "dispose" | "isDisposed" | "enqueue">;
+export type RuntimeExecutionFacet<T extends ManifestoDomainShape> = Pick<RuntimeKernel<T>, "ensureIntentId" | "executeHost" | "createComputeContext" | "captureExternalContext">;
+export type RuntimeSealAdmissionFacet<T extends ManifestoDomainShape> = Pick<RuntimeKernel<T>, "isActionAvailable" | "isActionAvailableFor" | "validateIntentInputFor" | "isIntentDispatchableFor" | "rejectUnavailable" | "rejectInvalidInput" | "rejectNotDispatchable">;
+export type RuntimeReportAdmissionFacet<T extends ManifestoDomainShape> = Pick<RuntimeKernel<T>, "evaluateIntentLegalityFor" | "deriveIntentAdmission" | "createUnavailableError" | "createNotDispatchableError">;
+export type RuntimePublicationFacet<T extends ManifestoDomainShape> = Pick<RuntimeKernel<T>, "getVisibleCoreSnapshot" | "setVisibleSnapshot" | "rehydrateSnapshot" | "restoreVisibleSnapshot">;
+export type RuntimeReportingFacet<T extends ManifestoDomainShape> = Pick<RuntimeKernel<T>, "deriveExecutionOutcome" | "classifyExecutionFailure" | "createExecutionDiagnostics">;
+export type RuntimeDispatchEventsFacet<T extends ManifestoDomainShape> = Pick<RuntimeKernel<T>, "emitEvent">;
+export type RuntimeExtensionFacet<T extends ManifestoDomainShape> = Pick<RuntimeKernel<T>, typeof EXTENSION_KERNEL>;
+export type LineageRuntimeKernel<T extends ManifestoDomainShape> = RuntimePublicReadFacet<T> & RuntimeLifecycleFacet<T> & RuntimeExecutionFacet<T> & RuntimeSealAdmissionFacet<T> & RuntimeReportAdmissionFacet<T> & RuntimePublicationFacet<T> & RuntimeReportingFacet<T> & RuntimeDispatchEventsFacet<T> & RuntimeExtensionFacet<T>;
+export type LineageRuntimeKernelFactory<T extends ManifestoDomainShape> = () => LineageRuntimeKernel<T>;
+export type GovernanceRuntimeKernel<T extends ManifestoDomainShape> = RuntimePublicReadFacet<T> & RuntimeLifecycleFacet<T> & RuntimeExecutionFacet<T> & RuntimeSealAdmissionFacet<T> & RuntimeReportAdmissionFacet<T> & RuntimePublicationFacet<T> & Pick<RuntimeKernel<T>, "deriveExecutionOutcome"> & RuntimeDispatchEventsFacet<T> & RuntimeExtensionFacet<T>;
+export type GovernanceRuntimeKernelFactory<T extends ManifestoDomainShape> = () => GovernanceRuntimeKernel<T>;
+export type WaitForProposalRuntimeKernel<T extends ManifestoDomainShape> = Pick<RuntimeKernel<T>, "isDisposed" | "deriveExecutionOutcome">;
+export type RuntimeKernelFactory<T extends ManifestoDomainShape> = () => RuntimeKernel<T>;
+export type RuntimeKernelOptions<T extends ManifestoDomainShape> = {
+    readonly schema: DomainSchema;
+    readonly projectionPlan: SnapshotProjectionPlan;
+    readonly actionAnnotations: Readonly<Record<string, ActionAnnotation>>;
+    readonly host: ManifestoHost;
+    readonly hostContextProvider: HostContextProvider;
+    readonly MEL: TypedMEL<T>;
+    readonly createIntent: TypedCreateIntent<T>;
+    readonly initialContext?: Record<string, JsonValue>;
+};

package/dist/runtime/kernel.d.ts

@@ -1,3 +1,3 @@
 import type { ManifestoDomainShape } from "../types.js";
 import type { RuntimeKernel, RuntimeKernelOptions } from "../compat/internal.js";
-export declare function createRuntimeKernel<T extends ManifestoDomainShape>({ schema, projectionPlan, host, hostContextProvider, MEL, createIntent, }: RuntimeKernelOptions<T>): RuntimeKernel<T>;
+export declare function createRuntimeKernel<T extends ManifestoDomainShape>({ schema, projectionPlan, actionAnnotations, host, hostContextProvider, MEL, createIntent, initialContext, }: RuntimeKernelOptions<T>): RuntimeKernel<T>;

package/dist/runtime/publication.d.ts

@@ -1,13 +1,12 @@
 import type { Snapshot as CoreSnapshot } from "@manifesto-ai/core";
-import type { CanonicalSnapshot, ManifestoDomainShape, ManifestoEventMap, Snapshot } from "../types.js";
+import type { CanonicalSnapshot, ManifestoDomainShape, ProjectedSnapshot } from "../types.js";
 import type { RuntimePublicationHelpers } from "./facets.js";
 type RuntimePublicationOptions<T extends ManifestoDomainShape> = {
     readonly setVisibleSnapshot: (snapshot: CoreSnapshot, options?: {
         readonly notify?: boolean;
-    }) => Snapshot<T["state"]>;
+    }) => ProjectedSnapshot<T>;
     readonly restoreVisibleSnapshot: () => void;
     readonly getCanonicalSnapshot: () => CanonicalSnapshot<T["state"]>;
-    readonly emitEvent: <K extends keyof ManifestoEventMap<T>>(event: K, payload: ManifestoEventMap<T>[K]) => void;
 };
-export declare function createRuntimePublication<T extends ManifestoDomainShape>({ setVisibleSnapshot, restoreVisibleSnapshot, getCanonicalSnapshot, emitEvent, }: RuntimePublicationOptions<T>): RuntimePublicationHelpers<T>;
+export declare function createRuntimePublication<T extends ManifestoDomainShape>({ setVisibleSnapshot, restoreVisibleSnapshot, getCanonicalSnapshot, }: RuntimePublicationOptions<T>): RuntimePublicationHelpers<T>;
 export {};

package/dist/runtime/reports.d.ts

@@ -1,10 +1,10 @@
 import type { Snapshot as CoreSnapshot } from "@manifesto-ai/core";
-import type { CanonicalSnapshot, ManifestoDomainShape, Snapshot } from "../types.js";
+import type { CanonicalSnapshot, ChangedPath, ManifestoDomainShape, ProjectedSnapshot, Snapshot } from "../types.js";
 import type { RuntimeReportHelpers } from "./facets.js";
 type RuntimeReportHelperOptions<T extends ManifestoDomainShape> = {
     readonly getAvailableActionsFor: (snapshot: CanonicalSnapshot<T["state"]>) => readonly (keyof T["actions"])[];
-    readonly projectSnapshotFromCanonical: (snapshot: CoreSnapshot) => Snapshot<T["state"]>;
+    readonly projectSnapshotFromCanonical: (snapshot: CoreSnapshot) => ProjectedSnapshot<T>;
 };
 export declare function createRuntimeReportHelpers<T extends ManifestoDomainShape>({ getAvailableActionsFor, projectSnapshotFromCanonical, }: RuntimeReportHelperOptions<T>): RuntimeReportHelpers<T>;
-export declare function diffProjectedPaths<T>(left: Snapshot<T>, right: Snapshot<T>): readonly string[];
+export declare function diffProjectedPaths<T>(left: Snapshot<T>, right: Snapshot<T>): readonly ChangedPath[];
 export {};

package/dist/runtime/simulation.d.ts

@@ -9,7 +9,7 @@ type RuntimeSimulationOptions<T extends ManifestoDomainShape> = {
     readonly evaluateIntentLegalityFor: (snapshot: CanonicalSnapshot<T["state"]>, intent: TypedIntent<T>) => IntentLegalityEvaluation<T>;
 };
 export declare function createRuntimeSimulation<T extends ManifestoDomainShape>({ schema, hostContextProvider, evaluateIntentLegalityFor, }: RuntimeSimulationOptions<T>): Readonly<{
-    withHostIntentSlot: (snapshot: CoreSnapshot, intent: TypedIntent<T>, context: ReturnType<HostContextProvider["createFrozenContext"]>) => CoreSnapshot;
+    withHostIntentSlot: (snapshot: CoreSnapshot, intent: TypedIntent<T>) => CoreSnapshot;
     createSimulationUnavailableError: (intent: TypedIntent<T>) => ManifestoError;
     createSimulationNotDispatchableError: (intent: TypedIntent<T>) => ManifestoError;
     simulateSync: RuntimeSimulateSync<T>;

package/dist/runtime/state-store.d.ts

@@ -5,7 +5,7 @@ import type { RuntimeStateStore } from "./facets.js";
 type RuntimeStateStoreOptions<T extends ManifestoDomainShape> = {
     readonly host: ManifestoHost;
     readonly initialCanonicalSnapshot: CoreSnapshot;
-    readonly projectSnapshotFromCanonical: (snapshot: CoreSnapshot) => Snapshot<T["state"]>;
+    readonly projectSnapshotFromCanonical: (snapshot: CoreSnapshot) => Snapshot<T["state"], T["computed"]>;
 };
 export declare function createRuntimeStateStore<T extends ManifestoDomainShape>({ host, initialCanonicalSnapshot, projectSnapshotFromCanonical, }: RuntimeStateStoreOptions<T>): RuntimeStateStore<T>;
 export {};