@manifesto-ai/sdk 3.18.1 → 5.0.0

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.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 {};