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

package/dist/interfaces.d.ts

@@ -1,45 +1,66 @@
-import { AnyEvent, AnyRecord, DefaultDeps, GenerateSpawnIdFn, MachineConfig, MachineManagerDehydrateFn, MachineManagerRuntimeSnapshot, MachineManagerSnapshot, MachineStore, MachinesState, Reducer, StateName, StateType, TransitionSubscriber, HydrateOptions, HydratePreviewOptions, UnknownMachineKeyContext, Middleware, WILDCARD, ManagerAction } from "./types";
+import { AnyEvent, AnyRecord, CoreActionMeta, DefaultDeps, GenerateSpawnIdFn, MachineConfig, MachineManagerDehydrateFn, MachineManagerRuntimeSnapshot, MachineManagerSnapshot, MachineRuntimeMetadata, MachineStore, MachinesState, Reducer, StateName, StateType, TransitionSubscriber, HydrateOptions, HydratePreviewOptions, UnknownMachineKeyContext, Middleware, WILDCARD, ManagerAction } from "./types";
+import type { LiteFsmPlugin, ManagerActionMeta, ManagerTransitionEvents, PluginManagerExtensions, PluginScopedDeps, ScopedPluginDepsOf } from "./plugin";
 type UnionToIntersection<U> = (U extends unknown ? (value: U) => void : never) extends (value: infer I) => void ? I : never;
-type ConfigDependencies<E> = E extends MachineConfig<infer C, infer T, infer P, infer D, infer Snapshot> ? [C, T, P, D, Snapshot] extends [object, AnyRecord, AnyEvent, AnyRecord, unknown] ? D : never : never;
-type EffectFunctionDependencies<F> = NonNullable<F> extends (deps: infer D) => unknown ? Omit<D, keyof DefaultDeps | "self"> : {};
-type EffectDependencies<E> = "effects" extends keyof E ? keyof NonNullable<E["effects"]> extends never ? {} : [ConfigDependencies<E>] extends [never] ? UnionToIntersection<{
-    [key in keyof NonNullable<E["effects"]>]: EffectFunctionDependencies<NonNullable<E["effects"]>[key]>;
-}[keyof NonNullable<E["effects"]>]> : ConfigDependencies<E> : {};
-export type MachineDependencies<S extends MachineStore> = keyof S extends never ? {} : UnionToIntersection<{
-    [key in keyof S]: EffectDependencies<S[key]>;
-}[keyof S]>;
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+};
+type MachineRuntimeOwnedDependencyKeys<E> = (MachineRuntimeMetadata<E> extends {
+    readonly effectDeps: infer Deps extends object;
+} ? keyof Deps : never) | (MachineRuntimeMetadata<E> extends {
+    readonly reactionDeps: infer Deps extends object;
+} ? keyof Deps : never);
+type MachineDeclaredDependencies<E> = E extends {
+    readonly __liteFsmDependencies?: infer D extends AnyRecord;
+} ? D : never;
+type ConfigDependencies<E> = MachineDeclaredDependencies<E> extends never ? E extends MachineConfig<infer C, infer T, infer P, infer D, infer Snapshot> ? [C, T, P, D, Snapshot] extends [object, AnyRecord, AnyEvent, AnyRecord, unknown] ? D : never : Omit<E, "storage"> extends MachineConfig<infer C, infer T, infer P, infer D, infer Snapshot> ? [C, T, P, D, Snapshot] extends [object, AnyRecord, AnyEvent, AnyRecord, unknown] ? D : never : never : MachineDeclaredDependencies<E>;
+type StripScopedDependencies<D, Plugins extends readonly LiteFsmPlugin<any, any, any>[], E> = Prettify<Omit<D, keyof DefaultDeps | "self" | keyof ScopedPluginDepsOf<D> | keyof PluginScopedDeps<Plugins> | MachineRuntimeOwnedDependencyKeys<E>>>;
+type EffectFunctionDependencies<F, Plugins extends readonly LiteFsmPlugin<any, any, any>[], E> = NonNullable<F> extends (deps: infer D) => unknown ? StripScopedDependencies<D, Plugins, E> : {};
+type EffectDependencies<E, Plugins extends readonly LiteFsmPlugin<any, any, any>[]> = "effects" extends keyof E ? keyof NonNullable<E["effects"]> extends never ? {} : [ConfigDependencies<E>] extends [never] ? UnionToIntersection<{
+    [key in keyof NonNullable<E["effects"]>]: EffectFunctionDependencies<NonNullable<E["effects"]>[key], Plugins, E>;
+}[keyof NonNullable<E["effects"]>]> : StripScopedDependencies<ConfigDependencies<E>, Plugins, E> : {};
+export type MachineDependencies<S extends MachineStore, Plugins extends readonly LiteFsmPlugin<any, any, any>[] = readonly []> = keyof S extends never ? {} : Prettify<Omit<UnionToIntersection<{
+    [key in keyof S]: EffectDependencies<S[key], Plugins>;
+}[keyof S]>, keyof PluginScopedDeps<Plugins>>>;
 type EventFromReducer<M> = M extends {
     reducer: MachineConfig<infer C, infer T, infer P, infer D>["reducer"];
 } ? [C, T, D] extends [object, AnyRecord, AnyRecord] ? P : never : never;
 type EventFromMachineConfig<M> = M extends MachineConfig<infer C, infer T, infer P, infer D> ? [C, T, D] extends [object, AnyRecord, AnyRecord] ? P : never : never;
+type EventFromRuntimeMetadata<M> = MachineRuntimeMetadata<M> extends {
+    readonly publicEvents: infer P extends AnyEvent;
+} ? P : never;
 export type MachineEvents<S extends MachineStore> = {
-    [key in keyof S]: EventFromReducer<S[key]> extends never ? EventFromMachineConfig<S[key]> extends never ? AnyEvent : EventFromMachineConfig<S[key]> : EventFromReducer<S[key]>;
+    [key in keyof S]: EventFromRuntimeMetadata<S[key]> extends never ? EventFromReducer<S[key]> extends never ? EventFromMachineConfig<S[key]> extends never ? AnyEvent : EventFromMachineConfig<S[key]> : EventFromReducer<S[key]> : EventFromRuntimeMetadata<S[key]>;
 }[keyof S];
-export type MachineManagerOptions<S extends MachineStore, P extends AnyEvent = MachineEvents<S>> = {
+export type MachineManagerOptions<S extends MachineStore, P extends AnyEvent = MachineEvents<S>, Plugins extends readonly LiteFsmPlugin<any, any, any>[] = readonly []> = {
     onError?: (err: unknown) => void;
-    middleware?: Middleware<MachinesState<S>, P>[];
+    middleware?: Middleware<MachinesState<S>, ManagerTransitionEvents<P, Plugins>, ManagerActionMeta<Plugins>>[];
     snapshot?: MachineManagerSnapshot<S>;
     schemaVersion?: number;
     onUnknownMachineKey?: (key: string, context: UnknownMachineKeyContext) => void;
     onSchemaVersionMismatch?: (incoming: number | undefined, current: number | undefined) => void;
     originId?: string;
-    generateActorId?: GenerateSpawnIdFn<P>;
-    generateGroupId?: GenerateSpawnIdFn<P>;
+    generateActorId?: GenerateSpawnIdFn<ManagerTransitionEvents<P, Plugins>>;
+    generateGroupId?: GenerateSpawnIdFn<ManagerTransitionEvents<P, Plugins>>;
+    plugins?: Plugins;
 };
 export type IMachine<C extends object, T extends AnyRecord = {}, P extends AnyEvent = AnyEvent, D extends AnyRecord = {}> = {
     transition: (state: StateType<C, T>, action: P) => StateType<C, T>;
     invokeEffect: (prevState: StateName<C>, currentState: StateName<C>, deps: D & DefaultDeps<StateName<C> | WILDCARD, C, P>) => Promise<void>;
     config: C;
 };
-export type IMachineManager<S extends MachineStore, P extends AnyEvent = MachineEvents<S>> = {
-    transition: (payload: ManagerAction<P>) => ManagerAction<P>;
+export type IMachineManager<S extends MachineStore, P extends AnyEvent = MachineEvents<S>, Meta extends object = CoreActionMeta, Plugins extends readonly LiteFsmPlugin<any, any, any>[] = readonly []> = {
+    transition: (payload: ManagerAction<P, Meta>) => ManagerAction<P, Meta>;
     getState: () => MachinesState<S>;
     getSnapshot: () => MachineManagerRuntimeSnapshot<S>;
     getHydratedState: (snapshot: MachineManagerSnapshot<S>, opts?: HydratePreviewOptions<S>) => MachinesState<S>;
     hydrate: (snapshot: MachineManagerSnapshot<S>, opts?: HydrateOptions) => void;
     dehydrate: MachineManagerDehydrateFn<S>;
-    onTransition: (cb: TransitionSubscriber<S, P>) => () => void;
-    replaceReducer: (cb: (reducer: Reducer<MachinesState<S>, ManagerAction<P>>) => Reducer<MachinesState<S>, ManagerAction<P>>) => void;
-    setDependencies: (d: MachineDependencies<S> | ((deps: MachineDependencies<S>) => MachineDependencies<S>)) => void;
+    onTransition: (cb: TransitionSubscriber<S, P, Meta>) => () => void;
+    replaceReducer: (cb: (reducer: Reducer<MachinesState<S>, ManagerAction<P, Meta>>) => Reducer<MachinesState<S>, ManagerAction<P, Meta>>) => void;
+    setDependencies: {
+        (deps: MachineDependencies<S, Plugins>): void;
+        (updater: (deps: MachineDependencies<S, Plugins>) => MachineDependencies<S, Plugins>): void;
+    };
 };
+export type ManagerFromPlugins<S extends MachineStore, AppEvents extends AnyEvent, Plugins extends readonly LiteFsmPlugin<any, any, any>[]> = IMachineManager<S, ManagerTransitionEvents<AppEvents, Plugins>, ManagerActionMeta<Plugins>, Plugins> & PluginManagerExtensions<Plugins, S, ManagerTransitionEvents<AppEvents, Plugins>>;
 export {};

package/dist/managerNormalize.d.cts

@@ -1,10 +1,16 @@
 import { type NormalizeOptions } from "./actor";
 import type { DispatchContext } from "./dispatchContext";
+import type { RoutingRuntime } from "./runtime/kernel/routing";
 import type { SidecarState } from "./sidecar";
 import type { AnyEvent, ManagerAction, MachineStore } from "./types";
-export declare const NORMALIZE_DROP: unique symbol;
+export type NormalizeActionResult<P extends AnyEvent> = {
+    readonly type: "continue";
+    readonly action: ManagerAction<P>;
+} | {
+    readonly type: "drop";
+};
 export type Normalizer<S extends MachineStore, P extends AnyEvent> = {
-    normalizeAction: (raw: ManagerAction<P>, opts?: NormalizeOptions) => ManagerAction<P> | typeof NORMALIZE_DROP;
+    normalizeAction: (raw: ManagerAction<P>, opts?: NormalizeOptions) => NormalizeActionResult<P>;
     applyPostNormalize: (ctx: DispatchContext<S, P>, action: ManagerAction<P>) => void;
 };
 export declare const assertUserAction: (action: {
@@ -12,4 +18,5 @@ export declare const assertUserAction: (action: {
 }) => void;
 export declare const createNormalizer: <S extends MachineStore, P extends AnyEvent>(deps: {
     sidecar: SidecarState;
+    routing: RoutingRuntime;
 }) => Normalizer<S, P>;

package/dist/managerNormalize.d.ts

@@ -1,10 +1,16 @@
 import { type NormalizeOptions } from "./actor";
 import type { DispatchContext } from "./dispatchContext";
+import type { RoutingRuntime } from "./runtime/kernel/routing";
 import type { SidecarState } from "./sidecar";
 import type { AnyEvent, ManagerAction, MachineStore } from "./types";
-export declare const NORMALIZE_DROP: unique symbol;
+export type NormalizeActionResult<P extends AnyEvent> = {
+    readonly type: "continue";
+    readonly action: ManagerAction<P>;
+} | {
+    readonly type: "drop";
+};
 export type Normalizer<S extends MachineStore, P extends AnyEvent> = {
-    normalizeAction: (raw: ManagerAction<P>, opts?: NormalizeOptions) => ManagerAction<P> | typeof NORMALIZE_DROP;
+    normalizeAction: (raw: ManagerAction<P>, opts?: NormalizeOptions) => NormalizeActionResult<P>;
     applyPostNormalize: (ctx: DispatchContext<S, P>, action: ManagerAction<P>) => void;
 };
 export declare const assertUserAction: (action: {
@@ -12,4 +18,5 @@ export declare const assertUserAction: (action: {
 }) => void;
 export declare const createNormalizer: <S extends MachineStore, P extends AnyEvent>(deps: {
     sidecar: SidecarState;
+    routing: RoutingRuntime;
 }) => Normalizer<S, P>;

package/dist/plugin.d.cts

@@ -0,0 +1,81 @@
+import type { DispatchContext, DispatchHookPhase, ManagerExtensionFactory, NormalizedPlugin, RouteResolverContext, RouteResolverResult, ScopedInvocationContext } from "./pluginTypes";
+import type { LiteFsmStorageRuntimeDefinition } from "./pluginStorage";
+import type { AnyEvent, ManagerAction, ReadonlyManagerAction } from "./types";
+export type { ActionInterceptor, ActionInterceptorResult, DispatchContext, DispatchHook, DispatchHookPhase, ManagerExtensionFactory, ManagerExtensionType, ManagerExtensionTypeLambda, ManagerRuntimeContext, NormalizedDispatchHook, NormalizedManagerEntry, NormalizedPlugin, NormalizedRouteMetaEntry, NormalizedScopedDepsEntry, NormalizedScopedTransitionEntry, NormalizedStorageEntry, RouteResolver, RouteResolverContext, RouteResolverResult, RoutingRegistry, ScopedInvocationContext, ScopedInvocationIndices, ScopedInvocationPhase, ScopedInvocationSource, } from "./pluginTypes";
+export type { EffectDeps, ManagerActionMeta, ManagerTransitionEvents, PluginManagerEvents, PluginManagerExtensions, PluginRouteMeta, PluginScopedDeps, PluginScopedTransition, ScopedPluginDepsOf, } from "./pluginHelpers";
+declare const liteFsmPluginMarker: unique symbol;
+declare const liteFsmPluginPayload: unique symbol;
+declare const liteFsmPluginEvents: unique symbol;
+declare const liteFsmPluginDefinition: unique symbol;
+export type LiteFsmPlugin<Name extends string = string, PluginEvents extends AnyEvent = never, Definition extends object = object> = {
+    readonly name: Name;
+    readonly [liteFsmPluginMarker]: true;
+    readonly [liteFsmPluginPayload]: NormalizedPlugin;
+    readonly [liteFsmPluginEvents]: PluginEvents;
+    readonly [liteFsmPluginDefinition]: Definition;
+};
+type PluginObservedEvents<PluginEvents extends AnyEvent, HostEvents extends AnyEvent> = [AnyEvent] extends [HostEvents] ? AnyEvent : HostEvents | PluginEvents;
+type PluginDispatchContext<Events extends AnyEvent> = Omit<DispatchContext, "action" | "originalAction"> & {
+    readonly originalAction: ReadonlyManagerAction<Events>;
+    readonly action: ReadonlyManagerAction<Events>;
+};
+type PluginActionInterceptorResult<Events extends AnyEvent> = void | {
+    readonly action?: ManagerAction<Events>;
+    readonly skipDelivery?: boolean;
+    readonly stopInterceptors?: boolean;
+};
+type PluginActionInterceptor<Events extends AnyEvent> = (ctx: PluginDispatchContext<Events>) => PluginActionInterceptorResult<Events>;
+type PluginDispatchHook<Events extends AnyEvent> = (ctx: PluginDispatchContext<Events>) => void;
+type PluginRouteResolverContext<Key extends string, Events extends AnyEvent> = Omit<RouteResolverContext<Key>, "action"> & {
+    readonly action: ReadonlyManagerAction<Events>;
+};
+type PluginRouteResolver<Key extends string, Events extends AnyEvent, Value = unknown> = {
+    bivarianceHack(value: Value, ctx: PluginRouteResolverContext<Key, Events>): RouteResolverResult;
+}["bivarianceHack"];
+export type PluginScopedInvocationContext<Events extends AnyEvent, TransitionEvents extends AnyEvent> = Omit<ScopedInvocationContext, "event" | "transition"> & {
+    readonly event: ReadonlyManagerAction<Events>;
+    readonly transition: (action: ManagerAction<TransitionEvents>) => ManagerAction<TransitionEvents>;
+};
+type PluginScopedFactory<Events extends AnyEvent, TransitionEvents extends AnyEvent> = (ctx: PluginScopedInvocationContext<Events, TransitionEvents>) => unknown;
+type PluginRouteMetaContext<RouteMetaValues extends object, Events extends AnyEvent> = {
+    readonly [Key in keyof RouteMetaValues]: Key extends string ? PluginRouteResolver<Key, Events, RouteMetaValues[Key]> : never;
+};
+type IsAny<Value> = 0 extends 1 & Value ? true : false;
+type UnknownIfUnannotated<Value> = IsAny<Value> extends true ? unknown : [Value] extends [never] ? unknown : Value;
+type RouteMetaValue<Resolver> = Resolver extends (value: infer Value, ...args: any[]) => unknown ? UnknownIfUnannotated<Value> : unknown;
+type UnionToIntersection<Union> = (Union extends unknown ? (value: Union) => void : never) extends (value: infer Intersection) => void ? Intersection : never;
+type StorageRouteMetaRequirements<Definition> = Definition extends {
+    readonly storage?: infer Storage extends readonly unknown[];
+} ? UnionToIntersection<Storage[number] extends LiteFsmStorageRuntimeDefinition<any, any, infer RouteMetaRequirements> ? RouteMetaRequirements : never> : {};
+type RequiredRouteMetaSection<RouteMetaResolvers extends object, RouteMetaRequirements extends object> = keyof RouteMetaRequirements extends never ? {} : {
+    readonly routeMeta: {
+        readonly [Key in keyof RouteMetaRequirements & string]: Key extends keyof RouteMetaResolvers ? RouteMetaValue<RouteMetaResolvers[Key]> extends RouteMetaRequirements[Key] ? unknown : never : never;
+    };
+};
+type PluginRouteMetaSection<RouteMetaValues extends object, RouteMetaResolvers extends object, Events extends AnyEvent> = {
+    readonly routeMeta?: RouteMetaResolvers & PluginRouteMetaContext<RouteMetaValues, Events>;
+};
+type PluginDefinitionBase<PluginEvents extends AnyEvent, HostEvents extends AnyEvent, Name extends string = string, Events extends AnyEvent = PluginObservedEvents<PluginEvents, HostEvents>> = {
+    readonly name: Name;
+    readonly manager?: Record<string, ManagerExtensionFactory<PluginEvents>>;
+    readonly storage?: readonly [LiteFsmStorageRuntimeDefinition, ...LiteFsmStorageRuntimeDefinition[]];
+    readonly scopedDeps?: Record<string, PluginScopedFactory<Events, PluginEvents>>;
+    readonly scopedTransition?: Record<string, PluginScopedFactory<Events, PluginEvents>>;
+    readonly intercept?: PluginActionInterceptor<Events>;
+    readonly hooks?: Partial<Record<DispatchHookPhase, PluginDispatchHook<Events>>>;
+};
+type PluginDefinitionKey = "name" | "routeMeta" | "manager" | "storage" | "scopedDeps" | "scopedTransition" | "intercept" | "hooks";
+type RejectUnknownKeys<Definition extends object> = {
+    readonly [Key in Exclude<keyof Definition, PluginDefinitionKey>]: never;
+};
+type PluginDefinitionOutput<Definition extends object, RouteMetaResolvers extends object> = Omit<Definition, "routeMeta"> & {
+    readonly routeMeta?: RouteMetaResolvers;
+};
+type PluginDefinitionInput<PluginEvents extends AnyEvent, HostEvents extends AnyEvent, RouteMetaValues extends object, RouteMetaResolvers extends object, Definition extends PluginDefinitionBase<PluginEvents, HostEvents>> = Definition & PluginRouteMetaSection<RouteMetaValues, RouteMetaResolvers, PluginObservedEvents<PluginEvents, HostEvents>> & RequiredRouteMetaSection<RouteMetaResolvers, StorageRouteMetaRequirements<Definition>> & RejectUnknownKeys<Definition & PluginRouteMetaSection<RouteMetaValues, RouteMetaResolvers, PluginObservedEvents<PluginEvents, HostEvents>>>;
+type PluginCreate<PluginEvents extends AnyEvent, HostEvents extends AnyEvent> = <const RouteMetaValues extends object = {}, const RouteMetaResolvers extends object = {}, const Definition extends PluginDefinitionBase<PluginEvents, HostEvents> = PluginDefinitionBase<PluginEvents, HostEvents>>(definition: PluginDefinitionInput<PluginEvents, HostEvents, RouteMetaValues, RouteMetaResolvers, Definition>) => LiteFsmPlugin<Definition["name"], PluginEvents, PluginDefinitionOutput<Definition, RouteMetaResolvers>>;
+export type PluginBuilder<PluginEvents extends AnyEvent, HostEvents extends AnyEvent> = {
+    create: PluginCreate<PluginEvents, HostEvents>;
+};
+export declare function definePlugin<PluginEvents extends AnyEvent = never, HostEvents extends AnyEvent = AnyEvent>(): PluginBuilder<PluginEvents, HostEvents>;
+export declare const isLiteFsmPluginValue: (value: unknown) => value is LiteFsmPlugin;
+export declare const getNormalizedPlugin: (plugin: LiteFsmPlugin) => NormalizedPlugin;

package/dist/plugin.d.ts

@@ -0,0 +1,81 @@
+import type { DispatchContext, DispatchHookPhase, ManagerExtensionFactory, NormalizedPlugin, RouteResolverContext, RouteResolverResult, ScopedInvocationContext } from "./pluginTypes";
+import type { LiteFsmStorageRuntimeDefinition } from "./pluginStorage";
+import type { AnyEvent, ManagerAction, ReadonlyManagerAction } from "./types";
+export type { ActionInterceptor, ActionInterceptorResult, DispatchContext, DispatchHook, DispatchHookPhase, ManagerExtensionFactory, ManagerExtensionType, ManagerExtensionTypeLambda, ManagerRuntimeContext, NormalizedDispatchHook, NormalizedManagerEntry, NormalizedPlugin, NormalizedRouteMetaEntry, NormalizedScopedDepsEntry, NormalizedScopedTransitionEntry, NormalizedStorageEntry, RouteResolver, RouteResolverContext, RouteResolverResult, RoutingRegistry, ScopedInvocationContext, ScopedInvocationIndices, ScopedInvocationPhase, ScopedInvocationSource, } from "./pluginTypes";
+export type { EffectDeps, ManagerActionMeta, ManagerTransitionEvents, PluginManagerEvents, PluginManagerExtensions, PluginRouteMeta, PluginScopedDeps, PluginScopedTransition, ScopedPluginDepsOf, } from "./pluginHelpers";
+declare const liteFsmPluginMarker: unique symbol;
+declare const liteFsmPluginPayload: unique symbol;
+declare const liteFsmPluginEvents: unique symbol;
+declare const liteFsmPluginDefinition: unique symbol;
+export type LiteFsmPlugin<Name extends string = string, PluginEvents extends AnyEvent = never, Definition extends object = object> = {
+    readonly name: Name;
+    readonly [liteFsmPluginMarker]: true;
+    readonly [liteFsmPluginPayload]: NormalizedPlugin;
+    readonly [liteFsmPluginEvents]: PluginEvents;
+    readonly [liteFsmPluginDefinition]: Definition;
+};
+type PluginObservedEvents<PluginEvents extends AnyEvent, HostEvents extends AnyEvent> = [AnyEvent] extends [HostEvents] ? AnyEvent : HostEvents | PluginEvents;
+type PluginDispatchContext<Events extends AnyEvent> = Omit<DispatchContext, "action" | "originalAction"> & {
+    readonly originalAction: ReadonlyManagerAction<Events>;
+    readonly action: ReadonlyManagerAction<Events>;
+};
+type PluginActionInterceptorResult<Events extends AnyEvent> = void | {
+    readonly action?: ManagerAction<Events>;
+    readonly skipDelivery?: boolean;
+    readonly stopInterceptors?: boolean;
+};
+type PluginActionInterceptor<Events extends AnyEvent> = (ctx: PluginDispatchContext<Events>) => PluginActionInterceptorResult<Events>;
+type PluginDispatchHook<Events extends AnyEvent> = (ctx: PluginDispatchContext<Events>) => void;
+type PluginRouteResolverContext<Key extends string, Events extends AnyEvent> = Omit<RouteResolverContext<Key>, "action"> & {
+    readonly action: ReadonlyManagerAction<Events>;
+};
+type PluginRouteResolver<Key extends string, Events extends AnyEvent, Value = unknown> = {
+    bivarianceHack(value: Value, ctx: PluginRouteResolverContext<Key, Events>): RouteResolverResult;
+}["bivarianceHack"];
+export type PluginScopedInvocationContext<Events extends AnyEvent, TransitionEvents extends AnyEvent> = Omit<ScopedInvocationContext, "event" | "transition"> & {
+    readonly event: ReadonlyManagerAction<Events>;
+    readonly transition: (action: ManagerAction<TransitionEvents>) => ManagerAction<TransitionEvents>;
+};
+type PluginScopedFactory<Events extends AnyEvent, TransitionEvents extends AnyEvent> = (ctx: PluginScopedInvocationContext<Events, TransitionEvents>) => unknown;
+type PluginRouteMetaContext<RouteMetaValues extends object, Events extends AnyEvent> = {
+    readonly [Key in keyof RouteMetaValues]: Key extends string ? PluginRouteResolver<Key, Events, RouteMetaValues[Key]> : never;
+};
+type IsAny<Value> = 0 extends 1 & Value ? true : false;
+type UnknownIfUnannotated<Value> = IsAny<Value> extends true ? unknown : [Value] extends [never] ? unknown : Value;
+type RouteMetaValue<Resolver> = Resolver extends (value: infer Value, ...args: any[]) => unknown ? UnknownIfUnannotated<Value> : unknown;
+type UnionToIntersection<Union> = (Union extends unknown ? (value: Union) => void : never) extends (value: infer Intersection) => void ? Intersection : never;
+type StorageRouteMetaRequirements<Definition> = Definition extends {
+    readonly storage?: infer Storage extends readonly unknown[];
+} ? UnionToIntersection<Storage[number] extends LiteFsmStorageRuntimeDefinition<any, any, infer RouteMetaRequirements> ? RouteMetaRequirements : never> : {};
+type RequiredRouteMetaSection<RouteMetaResolvers extends object, RouteMetaRequirements extends object> = keyof RouteMetaRequirements extends never ? {} : {
+    readonly routeMeta: {
+        readonly [Key in keyof RouteMetaRequirements & string]: Key extends keyof RouteMetaResolvers ? RouteMetaValue<RouteMetaResolvers[Key]> extends RouteMetaRequirements[Key] ? unknown : never : never;
+    };
+};
+type PluginRouteMetaSection<RouteMetaValues extends object, RouteMetaResolvers extends object, Events extends AnyEvent> = {
+    readonly routeMeta?: RouteMetaResolvers & PluginRouteMetaContext<RouteMetaValues, Events>;
+};
+type PluginDefinitionBase<PluginEvents extends AnyEvent, HostEvents extends AnyEvent, Name extends string = string, Events extends AnyEvent = PluginObservedEvents<PluginEvents, HostEvents>> = {
+    readonly name: Name;
+    readonly manager?: Record<string, ManagerExtensionFactory<PluginEvents>>;
+    readonly storage?: readonly [LiteFsmStorageRuntimeDefinition, ...LiteFsmStorageRuntimeDefinition[]];
+    readonly scopedDeps?: Record<string, PluginScopedFactory<Events, PluginEvents>>;
+    readonly scopedTransition?: Record<string, PluginScopedFactory<Events, PluginEvents>>;
+    readonly intercept?: PluginActionInterceptor<Events>;
+    readonly hooks?: Partial<Record<DispatchHookPhase, PluginDispatchHook<Events>>>;
+};
+type PluginDefinitionKey = "name" | "routeMeta" | "manager" | "storage" | "scopedDeps" | "scopedTransition" | "intercept" | "hooks";
+type RejectUnknownKeys<Definition extends object> = {
+    readonly [Key in Exclude<keyof Definition, PluginDefinitionKey>]: never;
+};
+type PluginDefinitionOutput<Definition extends object, RouteMetaResolvers extends object> = Omit<Definition, "routeMeta"> & {
+    readonly routeMeta?: RouteMetaResolvers;
+};
+type PluginDefinitionInput<PluginEvents extends AnyEvent, HostEvents extends AnyEvent, RouteMetaValues extends object, RouteMetaResolvers extends object, Definition extends PluginDefinitionBase<PluginEvents, HostEvents>> = Definition & PluginRouteMetaSection<RouteMetaValues, RouteMetaResolvers, PluginObservedEvents<PluginEvents, HostEvents>> & RequiredRouteMetaSection<RouteMetaResolvers, StorageRouteMetaRequirements<Definition>> & RejectUnknownKeys<Definition & PluginRouteMetaSection<RouteMetaValues, RouteMetaResolvers, PluginObservedEvents<PluginEvents, HostEvents>>>;
+type PluginCreate<PluginEvents extends AnyEvent, HostEvents extends AnyEvent> = <const RouteMetaValues extends object = {}, const RouteMetaResolvers extends object = {}, const Definition extends PluginDefinitionBase<PluginEvents, HostEvents> = PluginDefinitionBase<PluginEvents, HostEvents>>(definition: PluginDefinitionInput<PluginEvents, HostEvents, RouteMetaValues, RouteMetaResolvers, Definition>) => LiteFsmPlugin<Definition["name"], PluginEvents, PluginDefinitionOutput<Definition, RouteMetaResolvers>>;
+export type PluginBuilder<PluginEvents extends AnyEvent, HostEvents extends AnyEvent> = {
+    create: PluginCreate<PluginEvents, HostEvents>;
+};
+export declare function definePlugin<PluginEvents extends AnyEvent = never, HostEvents extends AnyEvent = AnyEvent>(): PluginBuilder<PluginEvents, HostEvents>;
+export declare const isLiteFsmPluginValue: (value: unknown) => value is LiteFsmPlugin;
+export declare const getNormalizedPlugin: (plugin: LiteFsmPlugin) => NormalizedPlugin;

package/dist/pluginHelpers.d.cts

@@ -0,0 +1,68 @@
+import type { LiteFsmStorageRuntimeDefinition } from "./pluginStorage";
+import type { LiteFsmPlugin } from "./plugin";
+import type { AnyEvent, CoreActionMeta, MachinesState, MachineStore } from "./types";
+import type { ManagerExtensionType, ManagerExtensionTypeLambda, managerExtensionTypeMarker, ManagerRuntimeContext } from "./pluginTypes";
+import type { StorageMachineTypingExtension } from "./pluginStorageTypes";
+type UnionToIntersection<Union> = (Union extends unknown ? (value: Union) => void : never) extends (value: infer Intersection) => void ? Intersection : never;
+type Prettify<Value> = {
+    [Key in keyof Value]: Value[Key];
+};
+type IsAny<Value> = 0 extends 1 & Value ? true : false;
+type UnknownIfUnannotated<Value> = IsAny<Value> extends true ? unknown : [Value] extends [never] ? unknown : Value;
+type FactoryReturn<Factory> = Factory extends (...args: any[]) => infer Result ? Result : never;
+type RouteMetaValue<Resolver> = Resolver extends (value: infer Value, ...args: any[]) => unknown ? UnknownIfUnannotated<Value> : unknown;
+type IsExactly<Value, Expected> = [Value] extends [Expected] ? [Expected] extends [Value] ? true : false : false;
+type IsStoreReference<Value> = IsExactly<Value, MachineStore> extends true ? true : IsExactly<Value, MachinesState<MachineStore>> extends true ? true : false;
+type HasStoreReferences<Value> = IsAny<Value> extends true ? false : [Value] extends [never] ? false : IsStoreReference<Value> extends true ? true : Value extends (...args: any[]) => infer Result ? HasStoreReferences<Result> : Value extends object ? keyof Value extends never ? false : true extends {
+    [Key in keyof Value]: HasStoreReferences<Value[Key]>;
+}[keyof Value] ? true : false : false;
+type SpecializeStoreReferences<Value, S extends MachineStore> = IsExactly<Value, MachineStore> extends true ? S : IsExactly<Value, MachinesState<MachineStore>> extends true ? MachinesState<S> : Value extends (...args: infer Args) => infer Result ? HasStoreReferences<Result> extends true ? (...args: Args) => SpecializeStoreReferences<Result, S> : Value : Value extends object ? HasStoreReferences<Value> extends true ? {
+    [Key in keyof Value]: SpecializeStoreReferences<Value[Key], S>;
+} : Value : Value;
+type PluginMember<Plugin> = Plugin extends readonly unknown[] ? Plugin[number] : Plugin;
+type PluginDefinitionOf<Plugin> = Plugin extends LiteFsmPlugin<any, any, infer Definition> ? Definition : never;
+type IntersectCapabilities<Capability> = [Capability] extends [never] ? {} : Prettify<UnionToIntersection<Capability>>;
+type RouteMetaForPlugin<Plugin> = PluginDefinitionOf<Plugin> extends {
+    readonly routeMeta?: infer RouteMeta extends object;
+} ? {
+    [Key in keyof RouteMeta]: RouteMetaValue<RouteMeta[Key]>;
+} : {};
+type ScopedDepsForPlugin<Plugin> = PluginDefinitionOf<Plugin> extends {
+    readonly scopedDeps?: infer ScopedDeps extends object;
+} ? {
+    [Key in keyof ScopedDeps]: FactoryReturn<ScopedDeps[Key]>;
+} : {};
+type ScopedTransitionForPlugin<Plugin> = PluginDefinitionOf<Plugin> extends {
+    readonly scopedTransition?: infer ScopedTransition extends object;
+} ? {
+    [Key in keyof ScopedTransition]: FactoryReturn<ScopedTransition[Key]>;
+} : {};
+type ApplyManagerExtensionType<Lambda extends ManagerExtensionTypeLambda, S extends MachineStore, Events extends AnyEvent> = (Lambda & {
+    readonly context: ManagerRuntimeContext<Events, S>;
+})["type"];
+type ManagerFactoryReturn<Factory, S extends MachineStore, Events extends AnyEvent> = typeof managerExtensionTypeMarker extends keyof Factory ? Factory extends ManagerExtensionType<infer Lambda> ? ApplyManagerExtensionType<Lambda, S, Events> : never : SpecializeStoreReferences<Factory extends (ctx: ManagerRuntimeContext<infer FactoryEvents, any>) => unknown ? Factory extends (ctx: ManagerRuntimeContext<FactoryEvents, S>) => infer Result ? Result : FactoryReturn<Factory> : FactoryReturn<Factory>, S>;
+type ManagerExtensionsForPlugin<Plugin, S extends MachineStore, Events extends AnyEvent> = PluginDefinitionOf<Plugin> extends {
+    readonly manager?: infer Manager extends object;
+} ? {
+    [Key in keyof Manager]: ManagerFactoryReturn<Manager[Key], S, Events>;
+} : {};
+type StorageTypingExtensionsForPlugin<Plugin> = PluginDefinitionOf<Plugin> extends {
+    readonly storage?: infer Storage extends readonly unknown[];
+} ? Storage[number] extends LiteFsmStorageRuntimeDefinition<any, infer MachineExtension> ? MachineExtension : never : never;
+declare const scopedEffectDeps: unique symbol;
+export type ManagerActionMeta<Plugins extends readonly LiteFsmPlugin<any, any, any>[]> = Prettify<CoreActionMeta & Partial<PluginRouteMeta<Plugins>>>;
+export type ScopedPluginDepsOf<Deps> = Deps extends {
+    readonly [scopedEffectDeps]?: infer PluginScopedDeps;
+} ? PluginScopedDeps : {};
+export type EffectDeps<AppDeps extends object, Plugin> = Prettify<AppDeps & PluginScopedDeps<Plugin> & {
+    readonly transition: PluginScopedTransition<Plugin>;
+    readonly [scopedEffectDeps]?: PluginScopedDeps<Plugin>;
+}>;
+export type ManagerTransitionEvents<AppEvents extends AnyEvent, Plugins extends readonly LiteFsmPlugin<any, any, any>[]> = AppEvents | PluginManagerEvents<Plugins>;
+export type PluginRouteMeta<Plugin> = IntersectCapabilities<PluginMember<Plugin> extends infer Member ? Member extends LiteFsmPlugin<any, any, any> ? RouteMetaForPlugin<Member> : never : never>;
+export type PluginScopedDeps<Plugin> = IntersectCapabilities<PluginMember<Plugin> extends infer Member ? Member extends LiteFsmPlugin<any, any, any> ? ScopedDepsForPlugin<Member> : never : never>;
+export type PluginScopedTransition<Plugin> = IntersectCapabilities<PluginMember<Plugin> extends infer Member ? Member extends LiteFsmPlugin<any, any, any> ? ScopedTransitionForPlugin<Member> : never : never>;
+export type PluginManagerExtensions<Plugin, S extends MachineStore = MachineStore, Events extends AnyEvent = AnyEvent> = IntersectCapabilities<PluginMember<Plugin> extends infer Member ? Member extends LiteFsmPlugin<any, any, any> ? ManagerExtensionsForPlugin<Member, S, Events> : never : never>;
+export type PluginManagerEvents<Plugin> = PluginMember<Plugin> extends infer Member ? Member extends LiteFsmPlugin<any, infer PluginEvents, any> ? PluginEvents : never : never;
+export type StorageTypingExtensionsForPluginSource<Plugin> = PluginMember<Plugin> extends infer Member ? Member extends LiteFsmPlugin<any, any, any> ? StorageTypingExtensionsForPlugin<Member> extends StorageMachineTypingExtension ? StorageTypingExtensionsForPlugin<Member> : never : never : never;
+export {};

package/dist/pluginHelpers.d.ts

@@ -0,0 +1,68 @@
+import type { LiteFsmStorageRuntimeDefinition } from "./pluginStorage";
+import type { LiteFsmPlugin } from "./plugin";
+import type { AnyEvent, CoreActionMeta, MachinesState, MachineStore } from "./types";
+import type { ManagerExtensionType, ManagerExtensionTypeLambda, managerExtensionTypeMarker, ManagerRuntimeContext } from "./pluginTypes";
+import type { StorageMachineTypingExtension } from "./pluginStorageTypes";
+type UnionToIntersection<Union> = (Union extends unknown ? (value: Union) => void : never) extends (value: infer Intersection) => void ? Intersection : never;
+type Prettify<Value> = {
+    [Key in keyof Value]: Value[Key];
+};
+type IsAny<Value> = 0 extends 1 & Value ? true : false;
+type UnknownIfUnannotated<Value> = IsAny<Value> extends true ? unknown : [Value] extends [never] ? unknown : Value;
+type FactoryReturn<Factory> = Factory extends (...args: any[]) => infer Result ? Result : never;
+type RouteMetaValue<Resolver> = Resolver extends (value: infer Value, ...args: any[]) => unknown ? UnknownIfUnannotated<Value> : unknown;
+type IsExactly<Value, Expected> = [Value] extends [Expected] ? [Expected] extends [Value] ? true : false : false;
+type IsStoreReference<Value> = IsExactly<Value, MachineStore> extends true ? true : IsExactly<Value, MachinesState<MachineStore>> extends true ? true : false;
+type HasStoreReferences<Value> = IsAny<Value> extends true ? false : [Value] extends [never] ? false : IsStoreReference<Value> extends true ? true : Value extends (...args: any[]) => infer Result ? HasStoreReferences<Result> : Value extends object ? keyof Value extends never ? false : true extends {
+    [Key in keyof Value]: HasStoreReferences<Value[Key]>;
+}[keyof Value] ? true : false : false;
+type SpecializeStoreReferences<Value, S extends MachineStore> = IsExactly<Value, MachineStore> extends true ? S : IsExactly<Value, MachinesState<MachineStore>> extends true ? MachinesState<S> : Value extends (...args: infer Args) => infer Result ? HasStoreReferences<Result> extends true ? (...args: Args) => SpecializeStoreReferences<Result, S> : Value : Value extends object ? HasStoreReferences<Value> extends true ? {
+    [Key in keyof Value]: SpecializeStoreReferences<Value[Key], S>;
+} : Value : Value;
+type PluginMember<Plugin> = Plugin extends readonly unknown[] ? Plugin[number] : Plugin;
+type PluginDefinitionOf<Plugin> = Plugin extends LiteFsmPlugin<any, any, infer Definition> ? Definition : never;
+type IntersectCapabilities<Capability> = [Capability] extends [never] ? {} : Prettify<UnionToIntersection<Capability>>;
+type RouteMetaForPlugin<Plugin> = PluginDefinitionOf<Plugin> extends {
+    readonly routeMeta?: infer RouteMeta extends object;
+} ? {
+    [Key in keyof RouteMeta]: RouteMetaValue<RouteMeta[Key]>;
+} : {};
+type ScopedDepsForPlugin<Plugin> = PluginDefinitionOf<Plugin> extends {
+    readonly scopedDeps?: infer ScopedDeps extends object;
+} ? {
+    [Key in keyof ScopedDeps]: FactoryReturn<ScopedDeps[Key]>;
+} : {};
+type ScopedTransitionForPlugin<Plugin> = PluginDefinitionOf<Plugin> extends {
+    readonly scopedTransition?: infer ScopedTransition extends object;
+} ? {
+    [Key in keyof ScopedTransition]: FactoryReturn<ScopedTransition[Key]>;
+} : {};
+type ApplyManagerExtensionType<Lambda extends ManagerExtensionTypeLambda, S extends MachineStore, Events extends AnyEvent> = (Lambda & {
+    readonly context: ManagerRuntimeContext<Events, S>;
+})["type"];
+type ManagerFactoryReturn<Factory, S extends MachineStore, Events extends AnyEvent> = typeof managerExtensionTypeMarker extends keyof Factory ? Factory extends ManagerExtensionType<infer Lambda> ? ApplyManagerExtensionType<Lambda, S, Events> : never : SpecializeStoreReferences<Factory extends (ctx: ManagerRuntimeContext<infer FactoryEvents, any>) => unknown ? Factory extends (ctx: ManagerRuntimeContext<FactoryEvents, S>) => infer Result ? Result : FactoryReturn<Factory> : FactoryReturn<Factory>, S>;
+type ManagerExtensionsForPlugin<Plugin, S extends MachineStore, Events extends AnyEvent> = PluginDefinitionOf<Plugin> extends {
+    readonly manager?: infer Manager extends object;
+} ? {
+    [Key in keyof Manager]: ManagerFactoryReturn<Manager[Key], S, Events>;
+} : {};
+type StorageTypingExtensionsForPlugin<Plugin> = PluginDefinitionOf<Plugin> extends {
+    readonly storage?: infer Storage extends readonly unknown[];
+} ? Storage[number] extends LiteFsmStorageRuntimeDefinition<any, infer MachineExtension> ? MachineExtension : never : never;
+declare const scopedEffectDeps: unique symbol;
+export type ManagerActionMeta<Plugins extends readonly LiteFsmPlugin<any, any, any>[]> = Prettify<CoreActionMeta & Partial<PluginRouteMeta<Plugins>>>;
+export type ScopedPluginDepsOf<Deps> = Deps extends {
+    readonly [scopedEffectDeps]?: infer PluginScopedDeps;
+} ? PluginScopedDeps : {};
+export type EffectDeps<AppDeps extends object, Plugin> = Prettify<AppDeps & PluginScopedDeps<Plugin> & {
+    readonly transition: PluginScopedTransition<Plugin>;
+    readonly [scopedEffectDeps]?: PluginScopedDeps<Plugin>;
+}>;
+export type ManagerTransitionEvents<AppEvents extends AnyEvent, Plugins extends readonly LiteFsmPlugin<any, any, any>[]> = AppEvents | PluginManagerEvents<Plugins>;
+export type PluginRouteMeta<Plugin> = IntersectCapabilities<PluginMember<Plugin> extends infer Member ? Member extends LiteFsmPlugin<any, any, any> ? RouteMetaForPlugin<Member> : never : never>;
+export type PluginScopedDeps<Plugin> = IntersectCapabilities<PluginMember<Plugin> extends infer Member ? Member extends LiteFsmPlugin<any, any, any> ? ScopedDepsForPlugin<Member> : never : never>;
+export type PluginScopedTransition<Plugin> = IntersectCapabilities<PluginMember<Plugin> extends infer Member ? Member extends LiteFsmPlugin<any, any, any> ? ScopedTransitionForPlugin<Member> : never : never>;
+export type PluginManagerExtensions<Plugin, S extends MachineStore = MachineStore, Events extends AnyEvent = AnyEvent> = IntersectCapabilities<PluginMember<Plugin> extends infer Member ? Member extends LiteFsmPlugin<any, any, any> ? ManagerExtensionsForPlugin<Member, S, Events> : never : never>;
+export type PluginManagerEvents<Plugin> = PluginMember<Plugin> extends infer Member ? Member extends LiteFsmPlugin<any, infer PluginEvents, any> ? PluginEvents : never : never;
+export type StorageTypingExtensionsForPluginSource<Plugin> = PluginMember<Plugin> extends infer Member ? Member extends LiteFsmPlugin<any, any, any> ? StorageTypingExtensionsForPlugin<Member> extends StorageMachineTypingExtension ? StorageTypingExtensionsForPlugin<Member> : never : never : never;
+export {};

package/dist/pluginNormalize.d.cts

@@ -0,0 +1,16 @@
+import type { NormalizedPlugin, NormalizedStorageEntry } from "./pluginTypes";
+import type { StorageRuntime } from "./runtime/kernel/storage";
+export type PlainRecord = Record<string, unknown>;
+export type UnknownFunction = (...args: never[]) => unknown;
+export declare const hasOwn: (value: object, key: string) => boolean;
+export declare const isPlainObject: (value: unknown) => value is PlainRecord;
+export declare const extractUserPlugins: (opts: unknown) => readonly unknown[];
+export declare const invalidPluginDefinition: (message: string) => never;
+export declare const assertNonEmptyString: (value: unknown, message: string) => string;
+export declare const assertFunction: (value: unknown, message: string) => UnknownFunction;
+type NormalizedStorageRuntimeEntry = NormalizedStorageEntry & {
+    readonly value: StorageRuntime;
+};
+export declare const getNormalizedStorageRuntimeEntries: (plugin: NormalizedPlugin) => readonly NormalizedStorageRuntimeEntry[];
+export declare const normalizePluginDefinition: (value: unknown) => NormalizedPlugin;
+export {};

package/dist/pluginNormalize.d.ts

@@ -0,0 +1,16 @@
+import type { NormalizedPlugin, NormalizedStorageEntry } from "./pluginTypes";
+import type { StorageRuntime } from "./runtime/kernel/storage";
+export type PlainRecord = Record<string, unknown>;
+export type UnknownFunction = (...args: never[]) => unknown;
+export declare const hasOwn: (value: object, key: string) => boolean;
+export declare const isPlainObject: (value: unknown) => value is PlainRecord;
+export declare const extractUserPlugins: (opts: unknown) => readonly unknown[];
+export declare const invalidPluginDefinition: (message: string) => never;
+export declare const assertNonEmptyString: (value: unknown, message: string) => string;
+export declare const assertFunction: (value: unknown, message: string) => UnknownFunction;
+type NormalizedStorageRuntimeEntry = NormalizedStorageEntry & {
+    readonly value: StorageRuntime;
+};
+export declare const getNormalizedStorageRuntimeEntries: (plugin: NormalizedPlugin) => readonly NormalizedStorageRuntimeEntry[];
+export declare const normalizePluginDefinition: (value: unknown) => NormalizedPlugin;
+export {};

package/dist/pluginStorage.d.cts

@@ -0,0 +1,20 @@
+import type { StorageRuntimeExtension, StorageRuntimeBuilder, StorageMachineTypingExtension } from "./pluginStorageTypes";
+declare const liteFsmStorageRuntimeMarker: unique symbol;
+declare const liteFsmStorageRuntimePayload: unique symbol;
+declare const liteFsmStorageRuntimeOpaquePayload: unique symbol;
+declare const liteFsmStorageRuntimeExtension: unique symbol;
+declare const liteFsmStorageRouteMetaRequirements: unique symbol;
+type LiteFsmStorageRuntimePayload = {
+    readonly [liteFsmStorageRuntimeOpaquePayload]: never;
+};
+export type LiteFsmStorageRuntimeDefinition<Kind extends string = string, MachineExtension extends StorageMachineTypingExtension = StorageMachineTypingExtension, RouteMetaRequirements extends object = object> = {
+    readonly kind: Kind;
+    readonly [liteFsmStorageRuntimeMarker]: true;
+    readonly [liteFsmStorageRuntimePayload]: LiteFsmStorageRuntimePayload;
+    readonly [liteFsmStorageRuntimeExtension]: MachineExtension;
+    readonly [liteFsmStorageRouteMetaRequirements]: RouteMetaRequirements;
+};
+export declare const isLiteFsmStorageRuntimeDefinition: (value: unknown) => value is LiteFsmStorageRuntimeDefinition;
+export declare const getStorageRuntimePayload: (definition: LiteFsmStorageRuntimeDefinition) => unknown;
+export declare function defineStorageRuntime<Extension extends StorageRuntimeExtension = {}>(): StorageRuntimeBuilder<Extension>;
+export {};

package/dist/pluginStorage.d.ts

@@ -0,0 +1,20 @@
+import type { StorageRuntimeExtension, StorageRuntimeBuilder, StorageMachineTypingExtension } from "./pluginStorageTypes";
+declare const liteFsmStorageRuntimeMarker: unique symbol;
+declare const liteFsmStorageRuntimePayload: unique symbol;
+declare const liteFsmStorageRuntimeOpaquePayload: unique symbol;
+declare const liteFsmStorageRuntimeExtension: unique symbol;
+declare const liteFsmStorageRouteMetaRequirements: unique symbol;
+type LiteFsmStorageRuntimePayload = {
+    readonly [liteFsmStorageRuntimeOpaquePayload]: never;
+};
+export type LiteFsmStorageRuntimeDefinition<Kind extends string = string, MachineExtension extends StorageMachineTypingExtension = StorageMachineTypingExtension, RouteMetaRequirements extends object = object> = {
+    readonly kind: Kind;
+    readonly [liteFsmStorageRuntimeMarker]: true;
+    readonly [liteFsmStorageRuntimePayload]: LiteFsmStorageRuntimePayload;
+    readonly [liteFsmStorageRuntimeExtension]: MachineExtension;
+    readonly [liteFsmStorageRouteMetaRequirements]: RouteMetaRequirements;
+};
+export declare const isLiteFsmStorageRuntimeDefinition: (value: unknown) => value is LiteFsmStorageRuntimeDefinition;
+export declare const getStorageRuntimePayload: (definition: LiteFsmStorageRuntimeDefinition) => unknown;
+export declare function defineStorageRuntime<Extension extends StorageRuntimeExtension = {}>(): StorageRuntimeBuilder<Extension>;
+export {};

package/dist/pluginStorageNormalize.d.cts

@@ -0,0 +1,3 @@
+import type { StorageRuntime } from "./runtime/kernel/storage";
+export declare const assertStorageRuntimeDefinition: (value: unknown) => StorageRuntime;
+export declare const normalizePublicStorageRuntime: <Kind extends string>(kind: Kind, runtime: StorageRuntime) => StorageRuntime;

package/dist/pluginStorageNormalize.d.ts

@@ -0,0 +1,3 @@
+import type { StorageRuntime } from "./runtime/kernel/storage";
+export declare const assertStorageRuntimeDefinition: (value: unknown) => StorageRuntime;
+export declare const normalizePublicStorageRuntime: <Kind extends string>(kind: Kind, runtime: StorageRuntime) => StorageRuntime;