@lite-fsm/entities 0.1.0-alpha.0

package/dist/runtime/access.d.cts

@@ -0,0 +1,72 @@
+import type { ActorPublicState, MachineStore } from "@lite-fsm/core";
+import type { EntityIndex } from "../plugin";
+import type { EntitySchemaResourceViews, EntitySchemaValue, EntityContextSchema } from "../schema";
+import type { ColumnarActorStore, EntityRuntimeState } from "./state";
+import type { CapturedEntityScopeEntry } from "./transaction";
+export type ReadonlyEntityColumn<T> = {
+    readonly [entity: EntityIndex]: T;
+};
+type Prettify<Value> = {
+    [Key in keyof Value]: Value[Key];
+} & {};
+type EntityActorMachine = {
+    readonly storage: "entity";
+    readonly config: object;
+    readonly initialContext: EntityContextSchema;
+};
+export type EntityActorKey<AppMachines extends MachineStore> = {
+    readonly [Key in keyof AppMachines]: AppMachines[Key] extends EntityActorMachine ? Key : never;
+}[keyof AppMachines] & string;
+export type EntityContextFor<AppMachines extends MachineStore, Key extends EntityActorKey<AppMachines>> = EntityContextSchemaFor<AppMachines, Key> extends infer Context extends EntityContextSchema ? EntitySchemaValue<Context> : never;
+type EntityContextSchemaFor<AppMachines extends MachineStore, Key extends EntityActorKey<AppMachines>> = AppMachines[Key] extends {
+    readonly initialContext: infer Context extends EntityContextSchema;
+} ? Context : never;
+export type EntityStateFor<AppMachines extends MachineStore, Key extends EntityActorKey<AppMachines>> = AppMachines[Key] extends {
+    readonly config: infer Config extends object;
+} ? ActorPublicState<Config> : never;
+type EntityActorStoreViewFor<AppMachines extends MachineStore, Key extends EntityActorKey<AppMachines>> = Prettify<{
+    readonly count: number;
+    readonly version: number;
+    has(entity: EntityIndex): boolean;
+    state(entity: EntityIndex): EntityStateFor<AppMachines, Key> | undefined;
+} & {
+    readonly [Field in keyof EntityContextFor<AppMachines, Key>]: ReadonlyEntityColumn<EntityContextFor<AppMachines, Key>[Field]>;
+} & EntitySchemaResourceViews<EntityContextSchemaFor<AppMachines, Key>>>;
+export type EntityAccess<AppMachines extends MachineStore> = {
+    get<Key extends EntityActorKey<AppMachines>>(key: Key): EntityActorStoreViewFor<AppMachines, Key>;
+    maybe<Key extends EntityActorKey<AppMachines>>(key: Key): EntityActorStoreViewFor<AppMachines, Key>;
+};
+export type EntityAccessScope = {
+    readonly sourceActor: string;
+    readonly eventType: string;
+    readonly entries: readonly CapturedEntityScopeEntry[];
+};
+type ScopedEntitySelfOptions = {
+    readonly scopeName: "effect";
+    readonly indices: readonly EntityIndex[];
+    readonly entries: readonly CapturedEntityScopeEntry[];
+};
+export type EntityReactionScope = {
+    readonly indices: readonly EntityIndex[];
+    readonly markers: Uint32Array;
+    readonly generation: Uint32Array;
+    readonly lifetime: {
+        readonly token: number;
+    };
+    readonly token: number;
+};
+export declare const capturedEntityScopeEntryIsLive: (runtime: EntityRuntimeState, entry: CapturedEntityScopeEntry) => boolean;
+export declare const rebindEntityStoreView: (store: ColumnarActorStore) => void;
+export declare const createEntityAccess: (runtime: EntityRuntimeState) => EntityAccess<MachineStore>;
+type ActorSelfCore = {
+    readonly indices: readonly EntityIndex[];
+    has(entity: EntityIndex): boolean;
+    entityId(entity: EntityIndex): string;
+};
+export declare const assignActorSelfFields: (self: Record<string, unknown>, store: ColumnarActorStore) => void;
+export declare const createActorSelf: (store: ColumnarActorStore, core: ActorSelfCore) => Record<string, unknown>;
+export declare const createScopedEntitySelf: (runtime: EntityRuntimeState, store: ColumnarActorStore, options: ScopedEntitySelfOptions) => Record<string, unknown>;
+export declare const createReactionEntitySelf: (runtime: EntityRuntimeState, store: ColumnarActorStore, scope: EntityReactionScope) => Record<string, unknown>;
+export declare const createReactionEntityAccess: (runtime: EntityRuntimeState) => EntityAccess<MachineStore>;
+export declare const createScopedEntityAccess: (runtime: EntityRuntimeState, scope: EntityAccessScope) => EntityAccess<MachineStore>;
+export {};

package/dist/runtime/access.d.ts

@@ -0,0 +1,72 @@
+import type { ActorPublicState, MachineStore } from "@lite-fsm/core";
+import type { EntityIndex } from "../plugin";
+import type { EntitySchemaResourceViews, EntitySchemaValue, EntityContextSchema } from "../schema";
+import type { ColumnarActorStore, EntityRuntimeState } from "./state";
+import type { CapturedEntityScopeEntry } from "./transaction";
+export type ReadonlyEntityColumn<T> = {
+    readonly [entity: EntityIndex]: T;
+};
+type Prettify<Value> = {
+    [Key in keyof Value]: Value[Key];
+} & {};
+type EntityActorMachine = {
+    readonly storage: "entity";
+    readonly config: object;
+    readonly initialContext: EntityContextSchema;
+};
+export type EntityActorKey<AppMachines extends MachineStore> = {
+    readonly [Key in keyof AppMachines]: AppMachines[Key] extends EntityActorMachine ? Key : never;
+}[keyof AppMachines] & string;
+export type EntityContextFor<AppMachines extends MachineStore, Key extends EntityActorKey<AppMachines>> = EntityContextSchemaFor<AppMachines, Key> extends infer Context extends EntityContextSchema ? EntitySchemaValue<Context> : never;
+type EntityContextSchemaFor<AppMachines extends MachineStore, Key extends EntityActorKey<AppMachines>> = AppMachines[Key] extends {
+    readonly initialContext: infer Context extends EntityContextSchema;
+} ? Context : never;
+export type EntityStateFor<AppMachines extends MachineStore, Key extends EntityActorKey<AppMachines>> = AppMachines[Key] extends {
+    readonly config: infer Config extends object;
+} ? ActorPublicState<Config> : never;
+type EntityActorStoreViewFor<AppMachines extends MachineStore, Key extends EntityActorKey<AppMachines>> = Prettify<{
+    readonly count: number;
+    readonly version: number;
+    has(entity: EntityIndex): boolean;
+    state(entity: EntityIndex): EntityStateFor<AppMachines, Key> | undefined;
+} & {
+    readonly [Field in keyof EntityContextFor<AppMachines, Key>]: ReadonlyEntityColumn<EntityContextFor<AppMachines, Key>[Field]>;
+} & EntitySchemaResourceViews<EntityContextSchemaFor<AppMachines, Key>>>;
+export type EntityAccess<AppMachines extends MachineStore> = {
+    get<Key extends EntityActorKey<AppMachines>>(key: Key): EntityActorStoreViewFor<AppMachines, Key>;
+    maybe<Key extends EntityActorKey<AppMachines>>(key: Key): EntityActorStoreViewFor<AppMachines, Key>;
+};
+export type EntityAccessScope = {
+    readonly sourceActor: string;
+    readonly eventType: string;
+    readonly entries: readonly CapturedEntityScopeEntry[];
+};
+type ScopedEntitySelfOptions = {
+    readonly scopeName: "effect";
+    readonly indices: readonly EntityIndex[];
+    readonly entries: readonly CapturedEntityScopeEntry[];
+};
+export type EntityReactionScope = {
+    readonly indices: readonly EntityIndex[];
+    readonly markers: Uint32Array;
+    readonly generation: Uint32Array;
+    readonly lifetime: {
+        readonly token: number;
+    };
+    readonly token: number;
+};
+export declare const capturedEntityScopeEntryIsLive: (runtime: EntityRuntimeState, entry: CapturedEntityScopeEntry) => boolean;
+export declare const rebindEntityStoreView: (store: ColumnarActorStore) => void;
+export declare const createEntityAccess: (runtime: EntityRuntimeState) => EntityAccess<MachineStore>;
+type ActorSelfCore = {
+    readonly indices: readonly EntityIndex[];
+    has(entity: EntityIndex): boolean;
+    entityId(entity: EntityIndex): string;
+};
+export declare const assignActorSelfFields: (self: Record<string, unknown>, store: ColumnarActorStore) => void;
+export declare const createActorSelf: (store: ColumnarActorStore, core: ActorSelfCore) => Record<string, unknown>;
+export declare const createScopedEntitySelf: (runtime: EntityRuntimeState, store: ColumnarActorStore, options: ScopedEntitySelfOptions) => Record<string, unknown>;
+export declare const createReactionEntitySelf: (runtime: EntityRuntimeState, store: ColumnarActorStore, scope: EntityReactionScope) => Record<string, unknown>;
+export declare const createReactionEntityAccess: (runtime: EntityRuntimeState) => EntityAccess<MachineStore>;
+export declare const createScopedEntityAccess: (runtime: EntityRuntimeState, scope: EntityAccessScope) => EntityAccess<MachineStore>;
+export {};

package/dist/runtime/columns.d.cts

@@ -0,0 +1,11 @@
+import type { EntityDescriptor } from "../schema";
+import type { EntityColumn } from "./store-types";
+type EntityColumnDescriptor = EntityDescriptor;
+export declare const createEmptyColumn: (descriptor: EntityColumnDescriptor) => EntityColumn;
+export declare const growColumn: (column: EntityColumn, descriptor: EntityColumnDescriptor, capacity: number) => EntityColumn;
+export declare const growInt16: (value: Int16Array, capacity: number, fillValue?: number) => Int16Array;
+export declare const growInt32: (value: Int32Array, capacity: number, fillValue?: number) => Int32Array;
+export declare const growUint8: (value: Uint8Array, capacity: number) => Uint8Array;
+export declare const growUint32: (value: Uint32Array, capacity: number) => Uint32Array;
+export declare const getInitialColumnValue: (descriptor: EntityColumnDescriptor) => number | string;
+export {};

package/dist/runtime/columns.d.ts

@@ -0,0 +1,11 @@
+import type { EntityDescriptor } from "../schema";
+import type { EntityColumn } from "./store-types";
+type EntityColumnDescriptor = EntityDescriptor;
+export declare const createEmptyColumn: (descriptor: EntityColumnDescriptor) => EntityColumn;
+export declare const growColumn: (column: EntityColumn, descriptor: EntityColumnDescriptor, capacity: number) => EntityColumn;
+export declare const growInt16: (value: Int16Array, capacity: number, fillValue?: number) => Int16Array;
+export declare const growInt32: (value: Int32Array, capacity: number, fillValue?: number) => Int32Array;
+export declare const growUint8: (value: Uint8Array, capacity: number) => Uint8Array;
+export declare const growUint32: (value: Uint32Array, capacity: number) => Uint32Array;
+export declare const getInitialColumnValue: (descriptor: EntityColumnDescriptor) => number | string;
+export {};

package/dist/runtime/compile.d.cts

@@ -0,0 +1,68 @@
+import type { AnyEvent, ManagerAction } from "@lite-fsm/core";
+import { type EntityColumnSchema, type EntityContextSchema, type EntityResourceSchema, type EntitySpawnSchema } from "../schema";
+export declare const ENTITY_INIT_STATE = "__INIT";
+export declare const ENTITY_INIT_STATE_CODE = -1;
+export declare const ENTITY_RESOLVED_STATE_CODE = -2;
+export declare const ENTITY_REJECTED_STATE_CODE = -3;
+export declare const ENTITY_CANCELLED_STATE_CODE = -4;
+export declare const ENTITY_NO_TRANSITION = -32768;
+export declare const ENTITY_INVALID_TRANSITION_TARGET = -32767;
+type EntityActorReducer = (state: {
+    readonly state: string;
+    readonly context: Record<string, unknown>;
+}, action: ManagerAction<AnyEvent>, meta: Record<string, unknown>) => unknown;
+export type EntityActorEffect = (deps: Record<string, unknown>) => unknown;
+export type EntityActorReaction = (deps: Record<string, unknown>) => unknown;
+export type EntityReducePlan = {
+    readonly eventCode: number;
+    readonly acceptStateCodes: readonly number[];
+    readonly allDefaultTransitionsIdentity: boolean;
+    readonly hasNonIdentityDefaultTransition: boolean;
+    readonly mayEnterEffectState: boolean;
+    readonly hasDespawnOnStates: boolean;
+    readonly hasReaction: boolean;
+    readonly mayEnterTerminalState: boolean;
+    readonly requiresReducerCall: boolean;
+};
+export type EntityTemplateMetadata = {
+    readonly templateKey: string;
+    readonly config: Record<string, Record<string, string | null | undefined> | undefined>;
+    readonly initialContext: EntityColumnSchema;
+    readonly resourceSchema: EntityResourceSchema;
+    readonly spawnSchema: EntitySpawnSchema;
+    readonly publicStates: readonly string[];
+    readonly stateCodeByName: Readonly<Record<string, number>>;
+    readonly eventTypes: readonly string[];
+    readonly eventAcceptMask: Uint8Array;
+    readonly transitionTable: Int16Array;
+    readonly transitionTargetByCell: Readonly<Record<number, string>>;
+    readonly acceptStateCodesByEventCode: readonly (readonly number[])[];
+    readonly stateSlotCount: number;
+    readonly despawnStateMask: Uint8Array;
+    readonly despawnLifecycleStateMask: Uint8Array;
+    readonly effectsByStateCode: readonly (EntityActorEffect | undefined)[];
+    readonly reactionsByEventType: Readonly<Record<string, EntityActorReaction>>;
+    readonly reactionsByEventCode: readonly (EntityActorReaction | undefined)[];
+    readonly reducePlansByEventCode: readonly EntityReducePlan[];
+    readonly reducer?: EntityActorReducer;
+};
+export type EntityCompiledRuntimeMetadata = {
+    readonly eventCodeByType: Readonly<Record<string, number>>;
+    readonly eventTypesByCode: readonly string[];
+    readonly metadataByKey: Readonly<Record<string, EntityTemplateMetadata>>;
+};
+export declare const isTerminalStateCode: (code: number) => boolean;
+export declare const hasDespawnOnStates: (despawnStateMask: Uint8Array) => boolean;
+export declare const compileEntityTemplate: (templateKey: string, machine: {
+    readonly config: object;
+    readonly initialContext: EntityContextSchema;
+    readonly spawnSchema: EntitySpawnSchema;
+    readonly despawnOn?: unknown;
+    readonly effects?: unknown;
+    readonly reactions?: unknown;
+    readonly reducer?: unknown;
+}) => EntityTemplateMetadata;
+export declare const compileEntityRuntimeMetadata: (templates: readonly EntityTemplateMetadata[]) => EntityCompiledRuntimeMetadata;
+export declare const getEntityStateName: (metadata: EntityTemplateMetadata, code: number) => string | undefined;
+export declare const getEntityStateCode: (metadata: EntityTemplateMetadata, state: string) => number | undefined;
+export {};

package/dist/runtime/compile.d.ts

@@ -0,0 +1,68 @@
+import type { AnyEvent, ManagerAction } from "@lite-fsm/core";
+import { type EntityColumnSchema, type EntityContextSchema, type EntityResourceSchema, type EntitySpawnSchema } from "../schema";
+export declare const ENTITY_INIT_STATE = "__INIT";
+export declare const ENTITY_INIT_STATE_CODE = -1;
+export declare const ENTITY_RESOLVED_STATE_CODE = -2;
+export declare const ENTITY_REJECTED_STATE_CODE = -3;
+export declare const ENTITY_CANCELLED_STATE_CODE = -4;
+export declare const ENTITY_NO_TRANSITION = -32768;
+export declare const ENTITY_INVALID_TRANSITION_TARGET = -32767;
+type EntityActorReducer = (state: {
+    readonly state: string;
+    readonly context: Record<string, unknown>;
+}, action: ManagerAction<AnyEvent>, meta: Record<string, unknown>) => unknown;
+export type EntityActorEffect = (deps: Record<string, unknown>) => unknown;
+export type EntityActorReaction = (deps: Record<string, unknown>) => unknown;
+export type EntityReducePlan = {
+    readonly eventCode: number;
+    readonly acceptStateCodes: readonly number[];
+    readonly allDefaultTransitionsIdentity: boolean;
+    readonly hasNonIdentityDefaultTransition: boolean;
+    readonly mayEnterEffectState: boolean;
+    readonly hasDespawnOnStates: boolean;
+    readonly hasReaction: boolean;
+    readonly mayEnterTerminalState: boolean;
+    readonly requiresReducerCall: boolean;
+};
+export type EntityTemplateMetadata = {
+    readonly templateKey: string;
+    readonly config: Record<string, Record<string, string | null | undefined> | undefined>;
+    readonly initialContext: EntityColumnSchema;
+    readonly resourceSchema: EntityResourceSchema;
+    readonly spawnSchema: EntitySpawnSchema;
+    readonly publicStates: readonly string[];
+    readonly stateCodeByName: Readonly<Record<string, number>>;
+    readonly eventTypes: readonly string[];
+    readonly eventAcceptMask: Uint8Array;
+    readonly transitionTable: Int16Array;
+    readonly transitionTargetByCell: Readonly<Record<number, string>>;
+    readonly acceptStateCodesByEventCode: readonly (readonly number[])[];
+    readonly stateSlotCount: number;
+    readonly despawnStateMask: Uint8Array;
+    readonly despawnLifecycleStateMask: Uint8Array;
+    readonly effectsByStateCode: readonly (EntityActorEffect | undefined)[];
+    readonly reactionsByEventType: Readonly<Record<string, EntityActorReaction>>;
+    readonly reactionsByEventCode: readonly (EntityActorReaction | undefined)[];
+    readonly reducePlansByEventCode: readonly EntityReducePlan[];
+    readonly reducer?: EntityActorReducer;
+};
+export type EntityCompiledRuntimeMetadata = {
+    readonly eventCodeByType: Readonly<Record<string, number>>;
+    readonly eventTypesByCode: readonly string[];
+    readonly metadataByKey: Readonly<Record<string, EntityTemplateMetadata>>;
+};
+export declare const isTerminalStateCode: (code: number) => boolean;
+export declare const hasDespawnOnStates: (despawnStateMask: Uint8Array) => boolean;
+export declare const compileEntityTemplate: (templateKey: string, machine: {
+    readonly config: object;
+    readonly initialContext: EntityContextSchema;
+    readonly spawnSchema: EntitySpawnSchema;
+    readonly despawnOn?: unknown;
+    readonly effects?: unknown;
+    readonly reactions?: unknown;
+    readonly reducer?: unknown;
+}) => EntityTemplateMetadata;
+export declare const compileEntityRuntimeMetadata: (templates: readonly EntityTemplateMetadata[]) => EntityCompiledRuntimeMetadata;
+export declare const getEntityStateName: (metadata: EntityTemplateMetadata, code: number) => string | undefined;
+export declare const getEntityStateCode: (metadata: EntityTemplateMetadata, state: string) => number | undefined;
+export {};

package/dist/runtime/effects.d.cts

@@ -0,0 +1,26 @@
+import type { AnyEvent, ReadonlyManagerAction, StorageManagerContext } from "@lite-fsm/core";
+import type { EntityIndex } from "../plugin";
+import { type EntityAccessScope } from "./access";
+import type { EntityRuntimeState } from "./state";
+export type EntityEffectInvocation = {
+    readonly storeKey: string;
+    readonly stateCode: number;
+    readonly indices: readonly EntityIndex[];
+    readonly scope: EntityAccessScope;
+};
+type EffectResolveContext = {
+    readonly action: ReadonlyManagerAction<AnyEvent>;
+    readonly dispatch: {
+        readonly runtime: Map<string, unknown>;
+    };
+};
+type EffectInvokeContext = {
+    readonly action: ReadonlyManagerAction<AnyEvent>;
+    readonly manager: StorageManagerContext<AnyEvent>;
+    readonly dispatch: {
+        reportError(error: unknown): void;
+    };
+};
+export declare const resolveEntityEffectInvocations: (runtime: EntityRuntimeState, ctx: EffectResolveContext) => readonly EntityEffectInvocation[];
+export declare const invokeEntityEffect: (runtime: EntityRuntimeState, invocation: EntityEffectInvocation, ctx: EffectInvokeContext) => void;
+export {};

package/dist/runtime/effects.d.ts

@@ -0,0 +1,26 @@
+import type { AnyEvent, ReadonlyManagerAction, StorageManagerContext } from "@lite-fsm/core";
+import type { EntityIndex } from "../plugin";
+import { type EntityAccessScope } from "./access";
+import type { EntityRuntimeState } from "./state";
+export type EntityEffectInvocation = {
+    readonly storeKey: string;
+    readonly stateCode: number;
+    readonly indices: readonly EntityIndex[];
+    readonly scope: EntityAccessScope;
+};
+type EffectResolveContext = {
+    readonly action: ReadonlyManagerAction<AnyEvent>;
+    readonly dispatch: {
+        readonly runtime: Map<string, unknown>;
+    };
+};
+type EffectInvokeContext = {
+    readonly action: ReadonlyManagerAction<AnyEvent>;
+    readonly manager: StorageManagerContext<AnyEvent>;
+    readonly dispatch: {
+        reportError(error: unknown): void;
+    };
+};
+export declare const resolveEntityEffectInvocations: (runtime: EntityRuntimeState, ctx: EffectResolveContext) => readonly EntityEffectInvocation[];
+export declare const invokeEntityEffect: (runtime: EntityRuntimeState, invocation: EntityEffectInvocation, ctx: EffectInvokeContext) => void;
+export {};

package/dist/runtime/lifecycle.d.cts

@@ -0,0 +1,10 @@
+export type LiteFsmEntityLifecycleEvents = {
+    readonly type: "ENTITY_SPAWNED";
+} | {
+    readonly type: "ENTITY_DESPAWNED";
+};
+export declare const ENTITY_SPAWNED: LiteFsmEntityLifecycleEvents["type"];
+export declare const ENTITY_DESPAWNED: LiteFsmEntityLifecycleEvents["type"];
+export declare const isEntityLifecycleEventType: (eventType: string) => eventType is LiteFsmEntityLifecycleEvents["type"];
+export declare const assertPublicEntityLifecycleDispatch: (eventType: string) => void;
+export declare const assertEntityInitLifecycleConfig: (machineKey: string, config: unknown) => void;

package/dist/runtime/lifecycle.d.ts

@@ -0,0 +1,10 @@
+export type LiteFsmEntityLifecycleEvents = {
+    readonly type: "ENTITY_SPAWNED";
+} | {
+    readonly type: "ENTITY_DESPAWNED";
+};
+export declare const ENTITY_SPAWNED: LiteFsmEntityLifecycleEvents["type"];
+export declare const ENTITY_DESPAWNED: LiteFsmEntityLifecycleEvents["type"];
+export declare const isEntityLifecycleEventType: (eventType: string) => eventType is LiteFsmEntityLifecycleEvents["type"];
+export declare const assertPublicEntityLifecycleDispatch: (eventType: string) => void;
+export declare const assertEntityInitLifecycleConfig: (machineKey: string, config: unknown) => void;

package/dist/runtime/mutation-snapshot.d.cts

@@ -0,0 +1,41 @@
+import type { EntityIndex } from "../plugin";
+import { type ColumnarActorStore, type EntityActorRowRef, type EntityColumn, type EntityRuntimeState } from "./state";
+type EntityStoreMutationSnapshot = {
+    readonly count: number;
+    readonly capacity: number;
+    readonly ids: string[];
+    readonly indexById: Record<string, EntityIndex>;
+    readonly alive: Uint8Array;
+    readonly generation: Uint32Array;
+    readonly groupTagByIndex: string[];
+    readonly entitiesByGroupTag: Record<string, EntityIndex[]>;
+    readonly groupTagPosition: Int32Array;
+    readonly freeList: EntityIndex[];
+    readonly version: number;
+};
+type ActorStoreMutationSnapshot = {
+    readonly capacity: number;
+    readonly count: number;
+    readonly version: number;
+    readonly presence: Uint8Array;
+    readonly stateCode: Int16Array;
+    readonly prevStateCode: Int16Array;
+    readonly rowVersion: Uint32Array;
+    readonly stateBuckets: EntityIndex[][];
+    readonly statePosition: Int32Array;
+    readonly acceptedScratch: EntityIndex[];
+    readonly pendingPrevStateCodeSync: EntityIndex[];
+    readonly pendingPrevStateCodeSyncMark: Uint32Array;
+    readonly pendingPrevStateCodeSyncToken: number;
+    readonly columns: Record<string, EntityColumn>;
+    readonly publicSlice: ColumnarActorStore["publicSlice"];
+};
+type RuntimeMutationSnapshot = {
+    readonly entityStore: EntityStoreMutationSnapshot;
+    readonly actorStores: Record<string, ActorStoreMutationSnapshot>;
+    readonly actorRowsByEntity: EntityActorRowRef[][];
+    readonly actorRowsByGroupTag: Record<string, EntityActorRowRef[]>;
+};
+export declare const snapshotRuntimeMutation: (runtime: EntityRuntimeState) => RuntimeMutationSnapshot;
+export declare const restoreRuntimeMutation: (runtime: EntityRuntimeState, snapshot: RuntimeMutationSnapshot) => void;
+export {};

package/dist/runtime/mutation-snapshot.d.ts

@@ -0,0 +1,41 @@
+import type { EntityIndex } from "../plugin";
+import { type ColumnarActorStore, type EntityActorRowRef, type EntityColumn, type EntityRuntimeState } from "./state";
+type EntityStoreMutationSnapshot = {
+    readonly count: number;
+    readonly capacity: number;
+    readonly ids: string[];
+    readonly indexById: Record<string, EntityIndex>;
+    readonly alive: Uint8Array;
+    readonly generation: Uint32Array;
+    readonly groupTagByIndex: string[];
+    readonly entitiesByGroupTag: Record<string, EntityIndex[]>;
+    readonly groupTagPosition: Int32Array;
+    readonly freeList: EntityIndex[];
+    readonly version: number;
+};
+type ActorStoreMutationSnapshot = {
+    readonly capacity: number;
+    readonly count: number;
+    readonly version: number;
+    readonly presence: Uint8Array;
+    readonly stateCode: Int16Array;
+    readonly prevStateCode: Int16Array;
+    readonly rowVersion: Uint32Array;
+    readonly stateBuckets: EntityIndex[][];
+    readonly statePosition: Int32Array;
+    readonly acceptedScratch: EntityIndex[];
+    readonly pendingPrevStateCodeSync: EntityIndex[];
+    readonly pendingPrevStateCodeSyncMark: Uint32Array;
+    readonly pendingPrevStateCodeSyncToken: number;
+    readonly columns: Record<string, EntityColumn>;
+    readonly publicSlice: ColumnarActorStore["publicSlice"];
+};
+type RuntimeMutationSnapshot = {
+    readonly entityStore: EntityStoreMutationSnapshot;
+    readonly actorStores: Record<string, ActorStoreMutationSnapshot>;
+    readonly actorRowsByEntity: EntityActorRowRef[][];
+    readonly actorRowsByGroupTag: Record<string, EntityActorRowRef[]>;
+};
+export declare const snapshotRuntimeMutation: (runtime: EntityRuntimeState) => RuntimeMutationSnapshot;
+export declare const restoreRuntimeMutation: (runtime: EntityRuntimeState, snapshot: RuntimeMutationSnapshot) => void;
+export {};

package/dist/runtime/react.d.cts

@@ -0,0 +1,29 @@
+import type { MachineStore } from "@lite-fsm/core";
+import type { EntityId } from "../plugin";
+import type { EntityActorKey, EntityContextFor, EntityStateFor } from "./access";
+import type { EntityRuntimeState } from "./state";
+export type EntityRowSnapshot<Context, State extends string = string> = {
+    readonly entityId: EntityId;
+    readonly groupTag: string;
+    readonly state: State;
+    readonly context: Context;
+};
+export type EntityListOptions = {
+    readonly groupTag?: string;
+};
+export type TypedUseEntitySnapshotHook<AppMachines extends MachineStore> = <Key extends EntityActorKey<AppMachines>>(templateKey: Key, entityId: EntityId | null | undefined) => EntityRowSnapshot<EntityContextFor<AppMachines, Key>, EntityStateFor<AppMachines, Key>> | undefined;
+export type TypedUseEntityCountHook<AppMachines extends MachineStore> = <Key extends EntityActorKey<AppMachines>>(templateKey: Key, options?: EntityListOptions) => number;
+export type TypedUseEntityListHook<AppMachines extends MachineStore> = <Key extends EntityActorKey<AppMachines>>(templateKey: Key, options?: EntityListOptions) => readonly EntityId[];
+export type EntityReadMode = {
+    readonly mode: "commit";
+} | {
+    readonly mode: "preview";
+    readonly snapshot: unknown;
+};
+export type EntityReactRuntime = {
+    readRow(templateKey: string, entityId: EntityId | null | undefined, mode: EntityReadMode): EntityRowSnapshot<Record<string, unknown>, string> | undefined;
+    readCount(templateKey: string, options: EntityListOptions | undefined, mode: EntityReadMode): number;
+    readList(templateKey: string, options: EntityListOptions | undefined, mode: EntityReadMode): readonly EntityId[];
+};
+export declare const createEntityReactRuntime: (runtime: EntityRuntimeState) => EntityReactRuntime;
+export type EntityHookRowSnapshot<AppMachines extends MachineStore, Key extends EntityActorKey<AppMachines>> = EntityRowSnapshot<EntityContextFor<AppMachines, Key>, EntityStateFor<AppMachines, Key>>;

package/dist/runtime/react.d.ts

@@ -0,0 +1,29 @@
+import type { MachineStore } from "@lite-fsm/core";
+import type { EntityId } from "../plugin";
+import type { EntityActorKey, EntityContextFor, EntityStateFor } from "./access";
+import type { EntityRuntimeState } from "./state";
+export type EntityRowSnapshot<Context, State extends string = string> = {
+    readonly entityId: EntityId;
+    readonly groupTag: string;
+    readonly state: State;
+    readonly context: Context;
+};
+export type EntityListOptions = {
+    readonly groupTag?: string;
+};
+export type TypedUseEntitySnapshotHook<AppMachines extends MachineStore> = <Key extends EntityActorKey<AppMachines>>(templateKey: Key, entityId: EntityId | null | undefined) => EntityRowSnapshot<EntityContextFor<AppMachines, Key>, EntityStateFor<AppMachines, Key>> | undefined;
+export type TypedUseEntityCountHook<AppMachines extends MachineStore> = <Key extends EntityActorKey<AppMachines>>(templateKey: Key, options?: EntityListOptions) => number;
+export type TypedUseEntityListHook<AppMachines extends MachineStore> = <Key extends EntityActorKey<AppMachines>>(templateKey: Key, options?: EntityListOptions) => readonly EntityId[];
+export type EntityReadMode = {
+    readonly mode: "commit";
+} | {
+    readonly mode: "preview";
+    readonly snapshot: unknown;
+};
+export type EntityReactRuntime = {
+    readRow(templateKey: string, entityId: EntityId | null | undefined, mode: EntityReadMode): EntityRowSnapshot<Record<string, unknown>, string> | undefined;
+    readCount(templateKey: string, options: EntityListOptions | undefined, mode: EntityReadMode): number;
+    readList(templateKey: string, options: EntityListOptions | undefined, mode: EntityReadMode): readonly EntityId[];
+};
+export declare const createEntityReactRuntime: (runtime: EntityRuntimeState) => EntityReactRuntime;
+export type EntityHookRowSnapshot<AppMachines extends MachineStore, Key extends EntityActorKey<AppMachines>> = EntityRowSnapshot<EntityContextFor<AppMachines, Key>, EntityStateFor<AppMachines, Key>>;

package/dist/runtime/reactions.d.cts

@@ -0,0 +1,15 @@
+import type { AnyEvent, ReadonlyManagerAction, StorageManagerContext } from "@lite-fsm/core";
+import type { EntityRuntimeState } from "./state";
+import { type EntityTransitionTraceSession } from "./transitionTrace";
+import { type EntityReactionBatch } from "./transaction";
+type ReactionRunContext = {
+    readonly action: ReadonlyManagerAction<AnyEvent>;
+    readonly manager: Pick<StorageManagerContext<AnyEvent>, "getDependencies">;
+    readonly dispatch: {
+        readonly runtime: Map<string, unknown>;
+        reportError(error: unknown): void;
+    };
+};
+export declare const runEntityReactionBatches: (runtime: EntityRuntimeState, batches: readonly EntityReactionBatch[], ctx: ReactionRunContext, trace?: EntityTransitionTraceSession, phasePrefix?: string) => void;
+export declare const runEntityReactions: (runtime: EntityRuntimeState, ctx: ReactionRunContext) => void;
+export {};

package/dist/runtime/reactions.d.ts

@@ -0,0 +1,15 @@
+import type { AnyEvent, ReadonlyManagerAction, StorageManagerContext } from "@lite-fsm/core";
+import type { EntityRuntimeState } from "./state";
+import { type EntityTransitionTraceSession } from "./transitionTrace";
+import { type EntityReactionBatch } from "./transaction";
+type ReactionRunContext = {
+    readonly action: ReadonlyManagerAction<AnyEvent>;
+    readonly manager: Pick<StorageManagerContext<AnyEvent>, "getDependencies">;
+    readonly dispatch: {
+        readonly runtime: Map<string, unknown>;
+        reportError(error: unknown): void;
+    };
+};
+export declare const runEntityReactionBatches: (runtime: EntityRuntimeState, batches: readonly EntityReactionBatch[], ctx: ReactionRunContext, trace?: EntityTransitionTraceSession, phasePrefix?: string) => void;
+export declare const runEntityReactions: (runtime: EntityRuntimeState, ctx: ReactionRunContext) => void;
+export {};

package/dist/runtime/reduce-batch.d.cts

@@ -0,0 +1,6 @@
+import type { EntityIndex } from "../plugin";
+import { type ReduceAcceptedBatchOptions, type ReducerBatch } from "./reduce-shared";
+import { type ColumnarActorStore, type EntityRuntimeState } from "./state";
+import { type EntityDispatchTransaction } from "./transaction";
+export declare const isSingleStateBucketReactionSource: (store: ColumnarActorStore, eventCode: number, indices: readonly EntityIndex[]) => boolean;
+export declare const reduceAcceptedBatch: (runtime: EntityRuntimeState, batch: ReducerBatch, transaction: EntityDispatchTransaction | undefined, options?: ReduceAcceptedBatchOptions) => boolean;

package/dist/runtime/reduce-batch.d.ts

@@ -0,0 +1,6 @@
+import type { EntityIndex } from "../plugin";
+import { type ReduceAcceptedBatchOptions, type ReducerBatch } from "./reduce-shared";
+import { type ColumnarActorStore, type EntityRuntimeState } from "./state";
+import { type EntityDispatchTransaction } from "./transaction";
+export declare const isSingleStateBucketReactionSource: (store: ColumnarActorStore, eventCode: number, indices: readonly EntityIndex[]) => boolean;
+export declare const reduceAcceptedBatch: (runtime: EntityRuntimeState, batch: ReducerBatch, transaction: EntityDispatchTransaction | undefined, options?: ReduceAcceptedBatchOptions) => boolean;

package/dist/runtime/reduce-despawn.d.cts

@@ -0,0 +1,7 @@
+import { type LifecycleReactionContext } from "./reduce-shared";
+import { type EntityRuntimeState } from "./state";
+import { type EntityDispatchTransaction } from "./transaction";
+import { type EntityTransitionTraceSession } from "./transitionTrace";
+type CleanupPhaseKind = "spawn" | "public";
+export declare const flushEntityLifecycleCleanup: (runtime: EntityRuntimeState, transaction: EntityDispatchTransaction | undefined, reactionContext: LifecycleReactionContext, phaseKind: CleanupPhaseKind, trace: EntityTransitionTraceSession | undefined) => boolean;
+export {};

package/dist/runtime/reduce-despawn.d.ts

@@ -0,0 +1,7 @@
+import { type LifecycleReactionContext } from "./reduce-shared";
+import { type EntityRuntimeState } from "./state";
+import { type EntityDispatchTransaction } from "./transaction";
+import { type EntityTransitionTraceSession } from "./transitionTrace";
+type CleanupPhaseKind = "spawn" | "public";
+export declare const flushEntityLifecycleCleanup: (runtime: EntityRuntimeState, transaction: EntityDispatchTransaction | undefined, reactionContext: LifecycleReactionContext, phaseKind: CleanupPhaseKind, trace: EntityTransitionTraceSession | undefined) => boolean;
+export {};

package/dist/runtime/reduce-post-process.d.cts

@@ -0,0 +1,35 @@
+import type { EntityIndex } from "../plugin";
+import { type EntityReducePlan } from "./compile";
+import { type ReduceAcceptedBatchOptions } from "./reduce-shared";
+import { type ColumnarActorStore } from "./state";
+import { type CapturedEntityScopeEntry, type EntityDispatchTransaction } from "./transaction";
+type PostProcessingFlags = {
+    readonly scheduleDespawnOn: boolean;
+    readonly scheduleEffects: boolean;
+    readonly collectReactionSurvivors: boolean;
+    readonly scheduleTerminal: boolean;
+};
+export type EnteredEffectRows = {
+    readonly indices: EntityIndex[];
+    readonly entries: CapturedEntityScopeEntry[];
+};
+export type AcceptedRowsPostProcessing = {
+    readonly dirtyRows: readonly EntityIndex[] | undefined;
+    readonly dirtyRowsPreviousStateCode: number | undefined;
+    readonly dirtyRowsPreviousStateCodes: readonly number[] | undefined;
+    readonly bulkStateTransition: BulkStateTransition | undefined;
+    readonly enteredByState: ReadonlyMap<number, EnteredEffectRows> | undefined;
+    readonly cleanupRemovesAcceptedRows: boolean;
+    readonly despawnOnRemovesAcceptedRows: boolean;
+    readonly acceptedRowsHaveFinalRemoval: boolean;
+    readonly reactionSurvivorRows: readonly EntityIndex[] | undefined;
+};
+export type BulkStateTransition = {
+    readonly indices: readonly EntityIndex[];
+    readonly previousStateCode: number;
+    readonly stateCode: number;
+};
+export declare const getPostProcessingFlags: (store: ColumnarActorStore, plan: EntityReducePlan | undefined, options: ReduceAcceptedBatchOptions) => PostProcessingFlags;
+export declare const getEnteredEffectIndices: (entered: EnteredEffectRows) => readonly EntityIndex[];
+export declare const postProcessAcceptedRows: (transaction: EntityDispatchTransaction | undefined, store: ColumnarActorStore, accepted: readonly EntityIndex[], flags: PostProcessingFlags, plan: EntityReducePlan | undefined, previousStateCodeForAccepted: number | undefined, knownValidStateCodeForAccepted: number | undefined, sourceStateCodesByAccepted?: readonly number[]) => AcceptedRowsPostProcessing;
+export {};