@lite-fsm/core 2.0.5 → 2.1.0-alpha.0

package/dist/pluginTypes.d.cts

@@ -0,0 +1,102 @@
+import type { AnyEvent, MachinesState, MachineStore, ManagerAction, ReadonlyManagerAction } from "./types";
+export type RouteResolverResult = string | readonly string[];
+export type RouteResolverContext<Key extends string = string> = {
+    readonly key: Key;
+    readonly action: ReadonlyManagerAction<AnyEvent>;
+    readonly meta: Readonly<Record<string, unknown>>;
+};
+export type RouteResolver<Key extends string = string> = (value: unknown, ctx: RouteResolverContext<Key>) => RouteResolverResult;
+export type RoutingRegistry = {
+    registerRouteMeta<Key extends string>(key: Key, resolver: RouteResolver<Key>, owner?: string): void;
+};
+export type DispatchContext = {
+    readonly options: unknown;
+    readonly runtime: Map<string, unknown>;
+    readonly originalAction: ReadonlyManagerAction<AnyEvent>;
+    readonly action: ReadonlyManagerAction<AnyEvent>;
+    readonly skipDelivery: boolean;
+    reportError(error: unknown): void;
+};
+export type ActionInterceptorResult = void | {
+    readonly action?: ManagerAction<AnyEvent>;
+    readonly skipDelivery?: boolean;
+    readonly stopInterceptors?: boolean;
+};
+export type ActionInterceptor = (ctx: DispatchContext) => ActionInterceptorResult;
+export type DispatchHook = (ctx: DispatchContext) => void;
+export declare const DISPATCH_HOOK_PHASES: readonly ["beforeReduce", "afterReduce", "beforeCommit", "beforeSubscribers", "beforeEffects", "afterEffects"];
+export type DispatchHookPhase = (typeof DISPATCH_HOOK_PHASES)[number];
+export type ScopedInvocationPhase = "effect" | "reaction";
+export type ScopedInvocationSource = {
+    readonly storage: string;
+    readonly template: string;
+};
+export type ScopedInvocationIndices = Readonly<Record<string, unknown>>;
+export type ScopedInvocationContext = {
+    readonly source: ScopedInvocationSource;
+    readonly event: ReadonlyManagerAction<AnyEvent>;
+    readonly indices: ScopedInvocationIndices;
+    readonly phase: ScopedInvocationPhase;
+    readonly transition: (action: ManagerAction<AnyEvent>) => ManagerAction<AnyEvent>;
+};
+export declare const managerExtensionTypeMarker: unique symbol;
+export type ManagerRuntimeContext<Events extends AnyEvent = AnyEvent, S extends MachineStore = MachineStore> = {
+    readonly config: S;
+    readonly options: unknown;
+    readonly schemaVersion: number | undefined;
+    getState(): MachinesState<S>;
+    transition(action: ManagerAction<Events>, options?: unknown): ManagerAction<Events>;
+    onTransition(cb: (prevState: MachinesState<S>, currentState: MachinesState<S>, action: ReadonlyManagerAction<Events> | {
+        readonly type: string;
+        readonly payload?: unknown;
+    }) => void): () => void;
+    getDependencies(): Record<string, unknown>;
+};
+export type ManagerExtensionFactory<Events extends AnyEvent = AnyEvent, Value = unknown, S extends MachineStore = MachineStore> = (ctx: ManagerRuntimeContext<Events, S>) => Value;
+export type ManagerExtensionTypeLambda = {
+    readonly type: unknown;
+};
+export type ManagerExtensionType<Lambda extends ManagerExtensionTypeLambda> = {
+    readonly [managerExtensionTypeMarker]?: Lambda;
+};
+export type NormalizedStorageEntry = {
+    readonly owner: string;
+    readonly kind: string;
+    readonly value: unknown;
+};
+export type NormalizedRouteMetaEntry = {
+    readonly owner: string;
+    readonly key: string;
+    readonly resolver: RouteResolver;
+};
+export type NormalizedScopedFactory = (ctx: ScopedInvocationContext) => unknown;
+export type NormalizedScopedDepsEntry = {
+    readonly owner: string;
+    readonly key: string;
+    readonly factory: NormalizedScopedFactory;
+};
+export type NormalizedScopedTransitionEntry = {
+    readonly owner: string;
+    readonly key: string;
+    readonly factory: NormalizedScopedFactory;
+};
+export type NormalizedManagerEntry = {
+    readonly owner: string;
+    readonly key: string;
+    readonly factory: ManagerExtensionFactory;
+};
+export type NormalizedDispatchHook = {
+    readonly owner: string;
+    readonly phase: DispatchHookPhase;
+    readonly hook: DispatchHook;
+};
+export type NormalizedPlugin = {
+    readonly name: string;
+    readonly storage: readonly NormalizedStorageEntry[];
+    readonly routeMeta: readonly NormalizedRouteMetaEntry[];
+    readonly scopedDeps: readonly NormalizedScopedDepsEntry[];
+    readonly scopedTransition: readonly NormalizedScopedTransitionEntry[];
+    readonly manager: readonly NormalizedManagerEntry[];
+    readonly intercept?: ActionInterceptor;
+    readonly hooks: Partial<Record<DispatchHookPhase, NormalizedDispatchHook>>;
+};

package/dist/pluginTypes.d.ts

@@ -0,0 +1,102 @@
+import type { AnyEvent, MachinesState, MachineStore, ManagerAction, ReadonlyManagerAction } from "./types";
+export type RouteResolverResult = string | readonly string[];
+export type RouteResolverContext<Key extends string = string> = {
+    readonly key: Key;
+    readonly action: ReadonlyManagerAction<AnyEvent>;
+    readonly meta: Readonly<Record<string, unknown>>;
+};
+export type RouteResolver<Key extends string = string> = (value: unknown, ctx: RouteResolverContext<Key>) => RouteResolverResult;
+export type RoutingRegistry = {
+    registerRouteMeta<Key extends string>(key: Key, resolver: RouteResolver<Key>, owner?: string): void;
+};
+export type DispatchContext = {
+    readonly options: unknown;
+    readonly runtime: Map<string, unknown>;
+    readonly originalAction: ReadonlyManagerAction<AnyEvent>;
+    readonly action: ReadonlyManagerAction<AnyEvent>;
+    readonly skipDelivery: boolean;
+    reportError(error: unknown): void;
+};
+export type ActionInterceptorResult = void | {
+    readonly action?: ManagerAction<AnyEvent>;
+    readonly skipDelivery?: boolean;
+    readonly stopInterceptors?: boolean;
+};
+export type ActionInterceptor = (ctx: DispatchContext) => ActionInterceptorResult;
+export type DispatchHook = (ctx: DispatchContext) => void;
+export declare const DISPATCH_HOOK_PHASES: readonly ["beforeReduce", "afterReduce", "beforeCommit", "beforeSubscribers", "beforeEffects", "afterEffects"];
+export type DispatchHookPhase = (typeof DISPATCH_HOOK_PHASES)[number];
+export type ScopedInvocationPhase = "effect" | "reaction";
+export type ScopedInvocationSource = {
+    readonly storage: string;
+    readonly template: string;
+};
+export type ScopedInvocationIndices = Readonly<Record<string, unknown>>;
+export type ScopedInvocationContext = {
+    readonly source: ScopedInvocationSource;
+    readonly event: ReadonlyManagerAction<AnyEvent>;
+    readonly indices: ScopedInvocationIndices;
+    readonly phase: ScopedInvocationPhase;
+    readonly transition: (action: ManagerAction<AnyEvent>) => ManagerAction<AnyEvent>;
+};
+export declare const managerExtensionTypeMarker: unique symbol;
+export type ManagerRuntimeContext<Events extends AnyEvent = AnyEvent, S extends MachineStore = MachineStore> = {
+    readonly config: S;
+    readonly options: unknown;
+    readonly schemaVersion: number | undefined;
+    getState(): MachinesState<S>;
+    transition(action: ManagerAction<Events>, options?: unknown): ManagerAction<Events>;
+    onTransition(cb: (prevState: MachinesState<S>, currentState: MachinesState<S>, action: ReadonlyManagerAction<Events> | {
+        readonly type: string;
+        readonly payload?: unknown;
+    }) => void): () => void;
+    getDependencies(): Record<string, unknown>;
+};
+export type ManagerExtensionFactory<Events extends AnyEvent = AnyEvent, Value = unknown, S extends MachineStore = MachineStore> = (ctx: ManagerRuntimeContext<Events, S>) => Value;
+export type ManagerExtensionTypeLambda = {
+    readonly type: unknown;
+};
+export type ManagerExtensionType<Lambda extends ManagerExtensionTypeLambda> = {
+    readonly [managerExtensionTypeMarker]?: Lambda;
+};
+export type NormalizedStorageEntry = {
+    readonly owner: string;
+    readonly kind: string;
+    readonly value: unknown;
+};
+export type NormalizedRouteMetaEntry = {
+    readonly owner: string;
+    readonly key: string;
+    readonly resolver: RouteResolver;
+};
+export type NormalizedScopedFactory = (ctx: ScopedInvocationContext) => unknown;
+export type NormalizedScopedDepsEntry = {
+    readonly owner: string;
+    readonly key: string;
+    readonly factory: NormalizedScopedFactory;
+};
+export type NormalizedScopedTransitionEntry = {
+    readonly owner: string;
+    readonly key: string;
+    readonly factory: NormalizedScopedFactory;
+};
+export type NormalizedManagerEntry = {
+    readonly owner: string;
+    readonly key: string;
+    readonly factory: ManagerExtensionFactory;
+};
+export type NormalizedDispatchHook = {
+    readonly owner: string;
+    readonly phase: DispatchHookPhase;
+    readonly hook: DispatchHook;
+};
+export type NormalizedPlugin = {
+    readonly name: string;
+    readonly storage: readonly NormalizedStorageEntry[];
+    readonly routeMeta: readonly NormalizedRouteMetaEntry[];
+    readonly scopedDeps: readonly NormalizedScopedDepsEntry[];
+    readonly scopedTransition: readonly NormalizedScopedTransitionEntry[];
+    readonly manager: readonly NormalizedManagerEntry[];
+    readonly intercept?: ActionInterceptor;
+    readonly hooks: Partial<Record<DispatchHookPhase, NormalizedDispatchHook>>;
+};

package/dist/runtime/defaultPreset.d.cts

@@ -0,0 +1,2 @@
+import type { RuntimePreset } from "./kernel/createMachineManagerFactory";
+export declare const defaultRuntimePreset: RuntimePreset;

package/dist/runtime/defaultPreset.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimePreset } from "./kernel/createMachineManagerFactory";
+export declare const defaultRuntimePreset: RuntimePreset;

package/dist/runtime/instance/manager.d.cts

@@ -0,0 +1,37 @@
+import { type ActorIdentity } from "../../actor";
+import { type DispatchContext } from "../../dispatchContext";
+import type { MachineEvents } from "../../interfaces";
+import type { AnyEvent, MachineManagerSnapshot, MachinesState, MachineStore, ManagerAction } from "../../types";
+import { type CompiledStorageTemplate, type CreateRuntimeStateContext, type ResolveEffectInvocationsContext, type ResolveIdentityContext, type StorageActionStageResult, type StorageBeforeReduceContext, type StorageCommitContext, type StorageDehydrateContext, type StorageEffectInvocationContext, type StorageHydrateContext, type StorageHydrateResult, type StoragePrepareActionContext, type StoragePrepareActionResult, type StorageReduceBucketContext, type StorageReduceResult } from "../kernel/storage";
+type RootState<S extends MachineStore> = MachinesState<S>;
+type Action<P extends AnyEvent> = ManagerAction<P>;
+type InstanceEffectInvocation<S extends MachineStore, P extends AnyEvent> = {
+    readonly prevState: RootState<S>;
+    readonly currentState: RootState<S>;
+    readonly action: Action<P>;
+    readonly targets: DispatchContext<S, P>["effectsTargets"];
+};
+type InstanceRuntimeState<S extends MachineStore, P extends AnyEvent> = {
+    readonly initialState: RootState<S>;
+    prepareAction(ctx: StoragePrepareActionContext): StoragePrepareActionResult;
+    beforeReduce(ctx: StorageBeforeReduceContext): StorageActionStageResult;
+    reduceBucket(ctx: StorageReduceBucketContext): StorageReduceResult;
+    commit(ctx: StorageCommitContext): void;
+    condition(predicate: (action: Action<P>) => boolean): Promise<boolean>;
+    resolveEffectInvocations(ctx: ResolveEffectInvocationsContext): InstanceEffectInvocation<S, P>[];
+    invokeEffect(ctx: StorageEffectInvocationContext): void;
+    dehydrate(ctx: StorageDehydrateContext): MachineManagerSnapshot<S>;
+    hydrate(ctx: StorageHydrateContext): StorageHydrateResult;
+    resolveIdentity(ctx: ResolveIdentityContext): ActorIdentity | undefined;
+};
+export declare const validateInstanceTemplate: ({ key, machine }: {
+    key: string;
+    machine: MachineStore[string];
+}) => void;
+export declare const compileInstanceTemplate: ({ key, storageKind, }: {
+    key: string;
+    storageKind: string;
+}) => CompiledStorageTemplate;
+export declare const createInstanceRuntimeState: <S extends MachineStore, P extends AnyEvent = MachineEvents<S>>({ manager, templates }: CreateRuntimeStateContext) => InstanceRuntimeState<S, P>;
+export declare const asInstanceRuntimeState: <S extends MachineStore, P extends AnyEvent>(value: unknown) => InstanceRuntimeState<S, P>;
+export {};

package/dist/runtime/instance/manager.d.ts

@@ -0,0 +1,37 @@
+import { type ActorIdentity } from "../../actor";
+import { type DispatchContext } from "../../dispatchContext";
+import type { MachineEvents } from "../../interfaces";
+import type { AnyEvent, MachineManagerSnapshot, MachinesState, MachineStore, ManagerAction } from "../../types";
+import { type CompiledStorageTemplate, type CreateRuntimeStateContext, type ResolveEffectInvocationsContext, type ResolveIdentityContext, type StorageActionStageResult, type StorageBeforeReduceContext, type StorageCommitContext, type StorageDehydrateContext, type StorageEffectInvocationContext, type StorageHydrateContext, type StorageHydrateResult, type StoragePrepareActionContext, type StoragePrepareActionResult, type StorageReduceBucketContext, type StorageReduceResult } from "../kernel/storage";
+type RootState<S extends MachineStore> = MachinesState<S>;
+type Action<P extends AnyEvent> = ManagerAction<P>;
+type InstanceEffectInvocation<S extends MachineStore, P extends AnyEvent> = {
+    readonly prevState: RootState<S>;
+    readonly currentState: RootState<S>;
+    readonly action: Action<P>;
+    readonly targets: DispatchContext<S, P>["effectsTargets"];
+};
+type InstanceRuntimeState<S extends MachineStore, P extends AnyEvent> = {
+    readonly initialState: RootState<S>;
+    prepareAction(ctx: StoragePrepareActionContext): StoragePrepareActionResult;
+    beforeReduce(ctx: StorageBeforeReduceContext): StorageActionStageResult;
+    reduceBucket(ctx: StorageReduceBucketContext): StorageReduceResult;
+    commit(ctx: StorageCommitContext): void;
+    condition(predicate: (action: Action<P>) => boolean): Promise<boolean>;
+    resolveEffectInvocations(ctx: ResolveEffectInvocationsContext): InstanceEffectInvocation<S, P>[];
+    invokeEffect(ctx: StorageEffectInvocationContext): void;
+    dehydrate(ctx: StorageDehydrateContext): MachineManagerSnapshot<S>;
+    hydrate(ctx: StorageHydrateContext): StorageHydrateResult;
+    resolveIdentity(ctx: ResolveIdentityContext): ActorIdentity | undefined;
+};
+export declare const validateInstanceTemplate: ({ key, machine }: {
+    key: string;
+    machine: MachineStore[string];
+}) => void;
+export declare const compileInstanceTemplate: ({ key, storageKind, }: {
+    key: string;
+    storageKind: string;
+}) => CompiledStorageTemplate;
+export declare const createInstanceRuntimeState: <S extends MachineStore, P extends AnyEvent = MachineEvents<S>>({ manager, templates }: CreateRuntimeStateContext) => InstanceRuntimeState<S, P>;
+export declare const asInstanceRuntimeState: <S extends MachineStore, P extends AnyEvent>(value: unknown) => InstanceRuntimeState<S, P>;
+export {};

package/dist/runtime/instance/plugin.d.cts

@@ -0,0 +1,3 @@
+import type { NormalizedPlugin } from "../../plugin";
+export declare const INSTANCE_RUNTIME_PLUGIN_NAME = "@lite-fsm/core/instance-runtime";
+export declare const instanceRuntimePlugin: NormalizedPlugin;

package/dist/runtime/instance/plugin.d.ts

@@ -0,0 +1,3 @@
+import type { NormalizedPlugin } from "../../plugin";
+export declare const INSTANCE_RUNTIME_PLUGIN_NAME = "@lite-fsm/core/instance-runtime";
+export declare const instanceRuntimePlugin: NormalizedPlugin;

package/dist/runtime/instance/storage.d.cts

@@ -0,0 +1,3 @@
+import type { StorageRuntime } from "../kernel/storage";
+export declare const INSTANCE_STORAGE_KIND = "instance";
+export declare const instanceStorageRuntime: StorageRuntime;

package/dist/runtime/instance/storage.d.ts

@@ -0,0 +1,3 @@
+import type { StorageRuntime } from "../kernel/storage";
+export declare const INSTANCE_STORAGE_KIND = "instance";
+export declare const instanceStorageRuntime: StorageRuntime;

package/dist/runtime/kernel/actionView.d.cts

@@ -0,0 +1,2 @@
+import type { AnyEvent, ManagerAction, ReadonlyManagerAction } from "../../types";
+export declare const createReadonlyActionView: <Events extends AnyEvent>(action: ManagerAction<Events>) => ReadonlyManagerAction<Events>;

package/dist/runtime/kernel/actionView.d.ts

@@ -0,0 +1,2 @@
+import type { AnyEvent, ManagerAction, ReadonlyManagerAction } from "../../types";
+export declare const createReadonlyActionView: <Events extends AnyEvent>(action: ManagerAction<Events>) => ReadonlyManagerAction<Events>;

package/dist/runtime/kernel/bucketRuntime.d.cts

@@ -0,0 +1,34 @@
+import type { AnyEvent, MachinesState, MachineStore, ManagerAction } from "../../types";
+import type { RuntimeBucket } from "./snapshot";
+import { type ManagerRuntimeContext, type StorageDispatchContext, type StorageDispatchLifecycleContext } from "./storage";
+import type { GuardedCallbackRunner } from "./transitionGuard";
+type Action = ManagerAction<AnyEvent>;
+type ActionStageOutcome = {
+    readonly type: "continue";
+    readonly action: Action;
+} | {
+    readonly type: "drop";
+};
+export type BucketRuntime<S extends MachineStore> = {
+    prepareAction(action: Action, options: unknown, dispatch: StorageDispatchLifecycleContext): ActionStageOutcome;
+    beforeReduce(action: Action, dispatch: StorageDispatchLifecycleContext): ActionStageOutcome;
+    reduce(action: Action, dispatch: StorageDispatchLifecycleContext): MachinesState<S>;
+    markExternallyChangedBuckets(prevState: Record<string, unknown>, nextState: Record<string, unknown>, dispatch: StorageDispatchLifecycleContext): void;
+    commit(dispatch: StorageDispatchLifecycleContext): void;
+    runReactions(action: Action, dispatch: StorageDispatchLifecycleContext): void;
+    runEffects(dispatch: StorageDispatchLifecycleContext): void;
+    condition(predicate: (action: Action) => boolean): Promise<boolean>;
+};
+export declare const createBucketRuntime: <S extends MachineStore>(buckets: readonly RuntimeBucket[], managerContext: ManagerRuntimeContext, resolveRoute: (action: Action) => StorageDispatchContext["route"], defaultStorageKind: string, runGuardedCallback: GuardedCallbackRunner) => BucketRuntime<S>;
+export declare const initBucketState: <S extends MachineStore>(buckets: readonly RuntimeBucket[], bucketsByKind: ReadonlyMap<string, RuntimeBucket>, templates: readonly {
+    readonly key: string;
+    readonly kind: string;
+}[], managerContext: ManagerRuntimeContext) => MachinesState<S>;
+export declare const groupTemplatesByRuntime: (templates: readonly {
+    readonly key: string;
+    readonly kind: string;
+}[], registeredRuntimes: readonly {
+    readonly kind: string;
+    readonly runtime: RuntimeBucket["runtime"];
+}[]) => RuntimeBucket[];
+export {};

package/dist/runtime/kernel/bucketRuntime.d.ts

@@ -0,0 +1,34 @@
+import type { AnyEvent, MachinesState, MachineStore, ManagerAction } from "../../types";
+import type { RuntimeBucket } from "./snapshot";
+import { type ManagerRuntimeContext, type StorageDispatchContext, type StorageDispatchLifecycleContext } from "./storage";
+import type { GuardedCallbackRunner } from "./transitionGuard";
+type Action = ManagerAction<AnyEvent>;
+type ActionStageOutcome = {
+    readonly type: "continue";
+    readonly action: Action;
+} | {
+    readonly type: "drop";
+};
+export type BucketRuntime<S extends MachineStore> = {
+    prepareAction(action: Action, options: unknown, dispatch: StorageDispatchLifecycleContext): ActionStageOutcome;
+    beforeReduce(action: Action, dispatch: StorageDispatchLifecycleContext): ActionStageOutcome;
+    reduce(action: Action, dispatch: StorageDispatchLifecycleContext): MachinesState<S>;
+    markExternallyChangedBuckets(prevState: Record<string, unknown>, nextState: Record<string, unknown>, dispatch: StorageDispatchLifecycleContext): void;
+    commit(dispatch: StorageDispatchLifecycleContext): void;
+    runReactions(action: Action, dispatch: StorageDispatchLifecycleContext): void;
+    runEffects(dispatch: StorageDispatchLifecycleContext): void;
+    condition(predicate: (action: Action) => boolean): Promise<boolean>;
+};
+export declare const createBucketRuntime: <S extends MachineStore>(buckets: readonly RuntimeBucket[], managerContext: ManagerRuntimeContext, resolveRoute: (action: Action) => StorageDispatchContext["route"], defaultStorageKind: string, runGuardedCallback: GuardedCallbackRunner) => BucketRuntime<S>;
+export declare const initBucketState: <S extends MachineStore>(buckets: readonly RuntimeBucket[], bucketsByKind: ReadonlyMap<string, RuntimeBucket>, templates: readonly {
+    readonly key: string;
+    readonly kind: string;
+}[], managerContext: ManagerRuntimeContext) => MachinesState<S>;
+export declare const groupTemplatesByRuntime: (templates: readonly {
+    readonly key: string;
+    readonly kind: string;
+}[], registeredRuntimes: readonly {
+    readonly kind: string;
+    readonly runtime: RuntimeBucket["runtime"];
+}[]) => RuntimeBucket[];
+export {};

package/dist/runtime/kernel/callbackValidation.d.cts

@@ -0,0 +1,11 @@
+import type { ActionInterceptorResult } from "../../plugin";
+import type { AnyEvent, ManagerAction } from "../../types";
+import type { StorageActionStageResult, StorageReduceResult } from "./storage";
+export declare const assertReplacementAction: (source: string, action: unknown) => ManagerAction<AnyEvent>;
+export declare const assertStorageActionStageResult: (source: string, result: unknown) => StorageActionStageResult;
+export declare const assertStorageReduceResult: (source: string, result: unknown) => StorageReduceResult;
+export declare const assertStorageAcceptsEventResult: (source: string, result: unknown) => boolean;
+export declare const assertPluginInterceptorResult: (source: string, result: unknown) => ActionInterceptorResult;
+export declare const assertPublicCompileTemplateResult: (source: string, result: unknown) => void | {
+    readonly data?: unknown;
+};

package/dist/runtime/kernel/callbackValidation.d.ts

@@ -0,0 +1,11 @@
+import type { ActionInterceptorResult } from "../../plugin";
+import type { AnyEvent, ManagerAction } from "../../types";
+import type { StorageActionStageResult, StorageReduceResult } from "./storage";
+export declare const assertReplacementAction: (source: string, action: unknown) => ManagerAction<AnyEvent>;
+export declare const assertStorageActionStageResult: (source: string, result: unknown) => StorageActionStageResult;
+export declare const assertStorageReduceResult: (source: string, result: unknown) => StorageReduceResult;
+export declare const assertStorageAcceptsEventResult: (source: string, result: unknown) => boolean;
+export declare const assertPluginInterceptorResult: (source: string, result: unknown) => ActionInterceptorResult;
+export declare const assertPublicCompileTemplateResult: (source: string, result: unknown) => void | {
+    readonly data?: unknown;
+};

package/dist/runtime/kernel/createMachineManagerFactory.d.cts

@@ -0,0 +1,13 @@
+import type { LiteFsmPlugin, NormalizedPlugin } from "../../plugin";
+import type { AnyEvent, MachineStore } from "../../types";
+import type { MachineEvents, MachineManagerOptions, ManagerFromPlugins } from "../../interfaces";
+export type RuntimePreset = {
+    readonly name: string;
+    readonly defaultStorageKind: string;
+    readonly plugins: readonly NormalizedPlugin[];
+};
+export type MachineManagerFactory = {
+    <S extends MachineStore, P extends AnyEvent = MachineEvents<S>>(config: S): ManagerFromPlugins<S, P, readonly []>;
+    <S extends MachineStore, P extends AnyEvent = MachineEvents<S>, const Plugins extends readonly LiteFsmPlugin<any, any, any>[] = readonly []>(config: S, opts: MachineManagerOptions<S, P, Plugins>): ManagerFromPlugins<S, P, Plugins>;
+};
+export declare const createMachineManagerFactory: (preset: RuntimePreset) => MachineManagerFactory;

package/dist/runtime/kernel/createMachineManagerFactory.d.ts

@@ -0,0 +1,13 @@
+import type { LiteFsmPlugin, NormalizedPlugin } from "../../plugin";
+import type { AnyEvent, MachineStore } from "../../types";
+import type { MachineEvents, MachineManagerOptions, ManagerFromPlugins } from "../../interfaces";
+export type RuntimePreset = {
+    readonly name: string;
+    readonly defaultStorageKind: string;
+    readonly plugins: readonly NormalizedPlugin[];
+};
+export type MachineManagerFactory = {
+    <S extends MachineStore, P extends AnyEvent = MachineEvents<S>>(config: S): ManagerFromPlugins<S, P, readonly []>;
+    <S extends MachineStore, P extends AnyEvent = MachineEvents<S>, const Plugins extends readonly LiteFsmPlugin<any, any, any>[] = readonly []>(config: S, opts: MachineManagerOptions<S, P, Plugins>): ManagerFromPlugins<S, P, Plugins>;
+};
+export declare const createMachineManagerFactory: (preset: RuntimePreset) => MachineManagerFactory;

package/dist/runtime/kernel/registry.d.cts

@@ -0,0 +1,23 @@
+import type { ActionInterceptor, DispatchHook, DispatchHookPhase, ManagerRuntimeContext, NormalizedPlugin, ScopedInvocationContext } from "../../plugin";
+import type { RuntimeStorageEntry, StorageRegistry } from "./storage";
+export type { DispatchHookPhase };
+export type ActionInterceptorEntry = {
+    readonly owner: string;
+    readonly intercept: ActionInterceptor;
+};
+type PluginRegistryOptions = {
+    readonly defaultStorageKind: string;
+};
+export declare const createPluginRegistry: ({ defaultStorageKind }: PluginRegistryOptions) => {
+    defaultStorageKind: string;
+    storage: StorageRegistry;
+    routing: import("./routing").RoutingRuntime;
+    listStorageRuntimes: () => RuntimeStorageEntry[];
+    listActionInterceptors: () => readonly ActionInterceptorEntry[];
+    listDispatchHooks: (phase: DispatchHookPhase) => readonly DispatchHook[];
+    createScopedDeps(baseDeps: Record<string, unknown>, ctx: ScopedInvocationContext): Record<string, unknown>;
+    attachManagerExtensions<T extends Record<string, unknown>>(target: T, ctx: ManagerRuntimeContext): T;
+    addPlugin(plugin: NormalizedPlugin): void;
+    assertDefaultStorageRegistered(): void;
+    assertStorageRouteResolversRegistered(): void;
+};

package/dist/runtime/kernel/registry.d.ts

@@ -0,0 +1,23 @@
+import type { ActionInterceptor, DispatchHook, DispatchHookPhase, ManagerRuntimeContext, NormalizedPlugin, ScopedInvocationContext } from "../../plugin";
+import type { RuntimeStorageEntry, StorageRegistry } from "./storage";
+export type { DispatchHookPhase };
+export type ActionInterceptorEntry = {
+    readonly owner: string;
+    readonly intercept: ActionInterceptor;
+};
+type PluginRegistryOptions = {
+    readonly defaultStorageKind: string;
+};
+export declare const createPluginRegistry: ({ defaultStorageKind }: PluginRegistryOptions) => {
+    defaultStorageKind: string;
+    storage: StorageRegistry;
+    routing: import("./routing").RoutingRuntime;
+    listStorageRuntimes: () => RuntimeStorageEntry[];
+    listActionInterceptors: () => readonly ActionInterceptorEntry[];
+    listDispatchHooks: (phase: DispatchHookPhase) => readonly DispatchHook[];
+    createScopedDeps(baseDeps: Record<string, unknown>, ctx: ScopedInvocationContext): Record<string, unknown>;
+    attachManagerExtensions<T extends Record<string, unknown>>(target: T, ctx: ManagerRuntimeContext): T;
+    addPlugin(plugin: NormalizedPlugin): void;
+    assertDefaultStorageRegistered(): void;
+    assertStorageRouteResolversRegistered(): void;
+};

package/dist/runtime/kernel/routing.d.cts

@@ -0,0 +1,33 @@
+import type { RoutingRegistry } from "../../plugin";
+import type { AnyEvent, FSMEventMeta, ManagerAction } from "../../types";
+export type RouteConstraint = {
+    readonly scope: "actor";
+    readonly key: "actorId";
+    readonly targetSet: string[];
+} | {
+    readonly scope: "plugin";
+    readonly key: string;
+    readonly targetSet: string[];
+} | {
+    readonly scope: "group";
+    readonly key: "groupId";
+    readonly targetSet: string[];
+} | {
+    readonly scope: "tag";
+    readonly key: "groupTag";
+    readonly targetSet: string[];
+} | {
+    readonly scope: "unscoped";
+    readonly key: undefined;
+    readonly targetSet: [];
+};
+export type RoutingRuntime = {
+    readonly registry: RoutingRegistry;
+    readonly registeredMetaKeys: readonly string[];
+    hasMetaKey(key: string): boolean;
+    stripSenderFields(meta: FSMEventMeta | undefined): FSMEventMeta;
+    stripRouting(meta: FSMEventMeta | undefined): FSMEventMeta;
+    hasRoute(meta: FSMEventMeta | undefined): boolean;
+    resolveRoute(action: ManagerAction<AnyEvent>): RouteConstraint;
+};
+export declare const createRoutingRuntime: () => RoutingRuntime;

package/dist/runtime/kernel/routing.d.ts

@@ -0,0 +1,33 @@
+import type { RoutingRegistry } from "../../plugin";
+import type { AnyEvent, FSMEventMeta, ManagerAction } from "../../types";
+export type RouteConstraint = {
+    readonly scope: "actor";
+    readonly key: "actorId";
+    readonly targetSet: string[];
+} | {
+    readonly scope: "plugin";
+    readonly key: string;
+    readonly targetSet: string[];
+} | {
+    readonly scope: "group";
+    readonly key: "groupId";
+    readonly targetSet: string[];
+} | {
+    readonly scope: "tag";
+    readonly key: "groupTag";
+    readonly targetSet: string[];
+} | {
+    readonly scope: "unscoped";
+    readonly key: undefined;
+    readonly targetSet: [];
+};
+export type RoutingRuntime = {
+    readonly registry: RoutingRegistry;
+    readonly registeredMetaKeys: readonly string[];
+    hasMetaKey(key: string): boolean;
+    stripSenderFields(meta: FSMEventMeta | undefined): FSMEventMeta;
+    stripRouting(meta: FSMEventMeta | undefined): FSMEventMeta;
+    hasRoute(meta: FSMEventMeta | undefined): boolean;
+    resolveRoute(action: ManagerAction<AnyEvent>): RouteConstraint;
+};
+export declare const createRoutingRuntime: () => RoutingRuntime;

package/dist/runtime/kernel/snapshot.d.cts

@@ -0,0 +1,26 @@
+import type { DehydrateOptions, HydrateStrategy, MachineManagerSnapshot, MachinesState, MachineStore } from "../../types";
+import type { CompiledStorageTemplate, ManagerRuntimeContext, StorageRuntime } from "./storage";
+export type RuntimeBucket = {
+    readonly runtime: StorageRuntime;
+    readonly templates: CompiledStorageTemplate[];
+    state: unknown;
+};
+export type SnapshotRuntimeDeps<S extends MachineStore> = {
+    readonly config: MachineStore;
+    readonly buckets: readonly RuntimeBucket[];
+    readonly bucketsByKind: ReadonlyMap<string, RuntimeBucket>;
+    readonly templateKindByKey: ReadonlyMap<string, string>;
+    readonly defaultStorageKind: string;
+    readonly managerContext: ManagerRuntimeContext;
+    readonly getState: () => MachinesState<S>;
+    readonly getSchemaVersion: () => number | undefined;
+};
+type DehydrateRuntimeOptions = DehydrateOptions<MachineStore> | undefined;
+export declare const createSnapshotRuntime: <S extends MachineStore>(deps: SnapshotRuntimeDeps<S>) => {
+    dehydrate: (options: DehydrateRuntimeOptions) => MachineManagerSnapshot<S>;
+    hydrate: (snapshot: MachineManagerSnapshot<S>, strategy: HydrateStrategy, mode: "preview" | "commit" | "init", baseState: MachinesState<S>, source: "hydrate" | "opts.snapshot") => {
+        nextState: MachinesState<S>;
+        changed: boolean;
+    };
+};
+export {};

package/dist/runtime/kernel/snapshot.d.ts

@@ -0,0 +1,26 @@
+import type { DehydrateOptions, HydrateStrategy, MachineManagerSnapshot, MachinesState, MachineStore } from "../../types";
+import type { CompiledStorageTemplate, ManagerRuntimeContext, StorageRuntime } from "./storage";
+export type RuntimeBucket = {
+    readonly runtime: StorageRuntime;
+    readonly templates: CompiledStorageTemplate[];
+    state: unknown;
+};
+export type SnapshotRuntimeDeps<S extends MachineStore> = {
+    readonly config: MachineStore;
+    readonly buckets: readonly RuntimeBucket[];
+    readonly bucketsByKind: ReadonlyMap<string, RuntimeBucket>;
+    readonly templateKindByKey: ReadonlyMap<string, string>;
+    readonly defaultStorageKind: string;
+    readonly managerContext: ManagerRuntimeContext;
+    readonly getState: () => MachinesState<S>;
+    readonly getSchemaVersion: () => number | undefined;
+};
+type DehydrateRuntimeOptions = DehydrateOptions<MachineStore> | undefined;
+export declare const createSnapshotRuntime: <S extends MachineStore>(deps: SnapshotRuntimeDeps<S>) => {
+    dehydrate: (options: DehydrateRuntimeOptions) => MachineManagerSnapshot<S>;
+    hydrate: (snapshot: MachineManagerSnapshot<S>, strategy: HydrateStrategy, mode: "preview" | "commit" | "init", baseState: MachinesState<S>, source: "hydrate" | "opts.snapshot") => {
+        nextState: MachinesState<S>;
+        changed: boolean;
+    };
+};
+export {};