@lite-fsm/entities 0.1.0-alpha.0

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

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

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

@@ -0,0 +1,34 @@
+import type { AnyEvent, ManagerAction, StorageReduceBucketContext } from "@lite-fsm/core";
+import type { EntityIndex } from "../plugin";
+import type { ColumnarActorStore } from "./state";
+import { type EntityDispatchTransaction, type EntityReactionBatch } from "./transaction";
+import type { EntityTransitionTraceSession } from "./transitionTrace";
+export { runtimeError } from "../internal";
+export { isTerminalStateCode } from "./compile";
+export type ReducerBatch = {
+    readonly store: ColumnarActorStore;
+    readonly indices: readonly EntityIndex[];
+    readonly action: ManagerAction<AnyEvent>;
+    readonly eventCode: number | undefined;
+    readonly accepted?: true;
+    readonly payloadScope?: SpawnPayloadScope;
+};
+export type SpawnPayloadScope = {
+    readonly indices: readonly EntityIndex[];
+    readonly payloads: readonly Record<string, unknown>[];
+    readonly firstEntity: EntityIndex;
+    readonly positionsByEntity?: Readonly<Record<number, number | undefined>>;
+};
+export type ReduceAcceptedBatchOptions = {
+    readonly allowBorrowedReactionBatch?: boolean;
+    readonly scheduleDespawnOn?: boolean;
+    readonly scheduleEffects?: boolean;
+    readonly scheduleReactions?: boolean;
+    readonly scheduleTerminal?: boolean;
+    readonly trace?: EntityTransitionTraceSession;
+    readonly traceBatchPrefix?: string;
+    readonly tracePublicBatch?: boolean;
+    onAccepted?(accepted: readonly EntityIndex[]): void;
+};
+export type LifecycleReactionContext = Pick<StorageReduceBucketContext<any>, "dispatch" | "manager">;
+export declare const appendLifecycleReactionBatch: (transaction: EntityDispatchTransaction | undefined, batches: EntityReactionBatch[], store: ColumnarActorStore, eventCode: number | undefined, indices: readonly EntityIndex[]) => void;

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

@@ -0,0 +1,34 @@
+import type { AnyEvent, ManagerAction, StorageReduceBucketContext } from "@lite-fsm/core";
+import type { EntityIndex } from "../plugin";
+import type { ColumnarActorStore } from "./state";
+import { type EntityDispatchTransaction, type EntityReactionBatch } from "./transaction";
+import type { EntityTransitionTraceSession } from "./transitionTrace";
+export { runtimeError } from "../internal";
+export { isTerminalStateCode } from "./compile";
+export type ReducerBatch = {
+    readonly store: ColumnarActorStore;
+    readonly indices: readonly EntityIndex[];
+    readonly action: ManagerAction<AnyEvent>;
+    readonly eventCode: number | undefined;
+    readonly accepted?: true;
+    readonly payloadScope?: SpawnPayloadScope;
+};
+export type SpawnPayloadScope = {
+    readonly indices: readonly EntityIndex[];
+    readonly payloads: readonly Record<string, unknown>[];
+    readonly firstEntity: EntityIndex;
+    readonly positionsByEntity?: Readonly<Record<number, number | undefined>>;
+};
+export type ReduceAcceptedBatchOptions = {
+    readonly allowBorrowedReactionBatch?: boolean;
+    readonly scheduleDespawnOn?: boolean;
+    readonly scheduleEffects?: boolean;
+    readonly scheduleReactions?: boolean;
+    readonly scheduleTerminal?: boolean;
+    readonly trace?: EntityTransitionTraceSession;
+    readonly traceBatchPrefix?: string;
+    readonly tracePublicBatch?: boolean;
+    onAccepted?(accepted: readonly EntityIndex[]): void;
+};
+export type LifecycleReactionContext = Pick<StorageReduceBucketContext<any>, "dispatch" | "manager">;
+export declare const appendLifecycleReactionBatch: (transaction: EntityDispatchTransaction | undefined, batches: EntityReactionBatch[], store: ColumnarActorStore, eventCode: number | undefined, indices: readonly EntityIndex[]) => void;

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

@@ -0,0 +1,5 @@
+import { type LifecycleReactionContext } from "./reduce-shared";
+import type { EntityRuntimeState } from "./state";
+import { type EntityDispatchTransaction, type StagedEntitySpawn } from "./transaction";
+import { type EntityTransitionTraceSession } from "./transitionTrace";
+export declare const reduceStagedSpawnLifecycle: (runtime: EntityRuntimeState, staged: readonly StagedEntitySpawn[], transaction: EntityDispatchTransaction | undefined, reactionContext: LifecycleReactionContext, trace?: EntityTransitionTraceSession) => boolean;

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

@@ -0,0 +1,5 @@
+import { type LifecycleReactionContext } from "./reduce-shared";
+import type { EntityRuntimeState } from "./state";
+import { type EntityDispatchTransaction, type StagedEntitySpawn } from "./transaction";
+import { type EntityTransitionTraceSession } from "./transitionTrace";
+export declare const reduceStagedSpawnLifecycle: (runtime: EntityRuntimeState, staged: readonly StagedEntitySpawn[], transaction: EntityDispatchTransaction | undefined, reactionContext: LifecycleReactionContext, trace?: EntityTransitionTraceSession) => boolean;

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

@@ -0,0 +1,11 @@
+import type { EntityIndex } from "../plugin";
+import { type ReducerBatch } from "./reduce-shared";
+type DefaultTransitionResult = {
+    readonly firstNextState: string | undefined;
+    readonly previousStateCodeForAccepted: number | undefined;
+    readonly sourceStateCodesByAccepted?: readonly number[];
+    readonly knownValidStateCodeForAccepted?: number;
+};
+export declare const getAcceptedIndices: (batch: ReducerBatch) => readonly EntityIndex[];
+export declare const applyDefaultTransitions: (batch: ReducerBatch, accepted: readonly EntityIndex[]) => DefaultTransitionResult;
+export {};

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

@@ -0,0 +1,11 @@
+import type { EntityIndex } from "../plugin";
+import { type ReducerBatch } from "./reduce-shared";
+type DefaultTransitionResult = {
+    readonly firstNextState: string | undefined;
+    readonly previousStateCodeForAccepted: number | undefined;
+    readonly sourceStateCodesByAccepted?: readonly number[];
+    readonly knownValidStateCodeForAccepted?: number;
+};
+export declare const getAcceptedIndices: (batch: ReducerBatch) => readonly EntityIndex[];
+export declare const applyDefaultTransitions: (batch: ReducerBatch, accepted: readonly EntityIndex[]) => DefaultTransitionResult;
+export {};

package/dist/runtime/reduce.d.cts

@@ -0,0 +1,5 @@
+import type { StorageReduceBucketContext } from "@lite-fsm/core";
+import type { EntityRuntimeState } from "./state";
+export declare const reduceEntityBucket: (runtime: EntityRuntimeState, ctx: StorageReduceBucketContext<any>) => {
+    readonly type: "skip";
+} | void;

package/dist/runtime/reduce.d.ts

@@ -0,0 +1,5 @@
+import type { StorageReduceBucketContext } from "@lite-fsm/core";
+import type { EntityRuntimeState } from "./state";
+export declare const reduceEntityBucket: (runtime: EntityRuntimeState, ctx: StorageReduceBucketContext<any>) => {
+    readonly type: "skip";
+} | void;

package/dist/runtime/routing.d.cts

@@ -0,0 +1,11 @@
+import type { StorageReduceBucketContext } from "@lite-fsm/core";
+import type { EntityIndex } from "../plugin";
+import type { ColumnarActorStore, EntityRuntimeState } from "./state";
+type EntityDispatchRoute = StorageReduceBucketContext<any>["dispatch"]["route"];
+export type EntityPublicReducerBatch = {
+    readonly store: ColumnarActorStore;
+    readonly indices: readonly EntityIndex[];
+    readonly accepted: true;
+};
+export declare const collectEntityPublicReducerBatches: (runtime: EntityRuntimeState, eventCode: number, route: EntityDispatchRoute) => EntityPublicReducerBatch[];
+export {};

package/dist/runtime/routing.d.ts

@@ -0,0 +1,11 @@
+import type { StorageReduceBucketContext } from "@lite-fsm/core";
+import type { EntityIndex } from "../plugin";
+import type { ColumnarActorStore, EntityRuntimeState } from "./state";
+type EntityDispatchRoute = StorageReduceBucketContext<any>["dispatch"]["route"];
+export type EntityPublicReducerBatch = {
+    readonly store: ColumnarActorStore;
+    readonly indices: readonly EntityIndex[];
+    readonly accepted: true;
+};
+export declare const collectEntityPublicReducerBatches: (runtime: EntityRuntimeState, eventCode: number, route: EntityDispatchRoute) => EntityPublicReducerBatch[];
+export {};

package/dist/runtime/runtime-index.d.cts

@@ -0,0 +1,23 @@
+import type { StorageTemplate } from "@lite-fsm/core";
+import type { EntityIndex } from "../plugin";
+import { type EntityTemplateMetadata } from "./compile";
+import type { ColumnarActorStore, EntityActorRowRef, EntityPublicStateSlice, EntityRuntimeState, EntityStore } from "./store-types";
+type ActorRowRemovalMode = "row" | "fullEntity";
+export declare const createScratchByState: (states: readonly string[]) => EntityIndex[][];
+export declare const refreshActorPublicSlice: (store: ColumnarActorStore) => void;
+export declare const clearPendingPrevStateCodeSync: (store: ColumnarActorStore) => void;
+export declare const schedulePrevStateCodeSync: (store: ColumnarActorStore, indices: readonly EntityIndex[]) => void;
+export declare const schedulePrevStateCodeSyncRow: (store: ColumnarActorStore, entity: EntityIndex) => void;
+export declare const schedulePresentPrevStateCodeSync: (store: ColumnarActorStore) => void;
+export declare const syncPendingPrevStateCode: (store: ColumnarActorStore) => void;
+export declare const rebuildActorAcceptStateBuckets: (store: ColumnarActorStore) => void;
+export declare const addEntityToGroupBucket: (store: EntityStore, entity: EntityIndex, groupTag: string) => void;
+export declare const addActorRowOwnership: (runtime: EntityRuntimeState, store: ColumnarActorStore, entity: EntityIndex, groupTag: string) => void;
+export declare const moveActorStateBucket: (store: ColumnarActorStore, entity: EntityIndex, previousCode: number, nextCode: number) => void;
+export declare const moveActorStateBucketBatch: (store: ColumnarActorStore, sourceCode: number, targetCode: number, sourceBucket: readonly EntityIndex[]) => boolean;
+export declare const removeActorRowsForStore: (runtime: EntityRuntimeState, store: ColumnarActorStore, rows: readonly EntityActorRowRef[], bucketStateCodes?: readonly (number | undefined)[], mode?: ActorRowRemovalMode) => number;
+export declare const removeEntityRecords: (runtime: EntityRuntimeState, entities: readonly EntityIndex[]) => number;
+export declare const createPublicInitialState: (runtime: EntityRuntimeState, template: StorageTemplate<EntityTemplateMetadata>) => EntityPublicStateSlice;
+export declare const restorePublicSlices: (runtime: EntityRuntimeState, nextState: Record<string, unknown>) => Record<string, unknown>;
+export declare const rebuildEntityRuntimeIndexes: (runtime: EntityRuntimeState) => void;
+export {};

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

@@ -0,0 +1,23 @@
+import type { StorageTemplate } from "@lite-fsm/core";
+import type { EntityIndex } from "../plugin";
+import { type EntityTemplateMetadata } from "./compile";
+import type { ColumnarActorStore, EntityActorRowRef, EntityPublicStateSlice, EntityRuntimeState, EntityStore } from "./store-types";
+type ActorRowRemovalMode = "row" | "fullEntity";
+export declare const createScratchByState: (states: readonly string[]) => EntityIndex[][];
+export declare const refreshActorPublicSlice: (store: ColumnarActorStore) => void;
+export declare const clearPendingPrevStateCodeSync: (store: ColumnarActorStore) => void;
+export declare const schedulePrevStateCodeSync: (store: ColumnarActorStore, indices: readonly EntityIndex[]) => void;
+export declare const schedulePrevStateCodeSyncRow: (store: ColumnarActorStore, entity: EntityIndex) => void;
+export declare const schedulePresentPrevStateCodeSync: (store: ColumnarActorStore) => void;
+export declare const syncPendingPrevStateCode: (store: ColumnarActorStore) => void;
+export declare const rebuildActorAcceptStateBuckets: (store: ColumnarActorStore) => void;
+export declare const addEntityToGroupBucket: (store: EntityStore, entity: EntityIndex, groupTag: string) => void;
+export declare const addActorRowOwnership: (runtime: EntityRuntimeState, store: ColumnarActorStore, entity: EntityIndex, groupTag: string) => void;
+export declare const moveActorStateBucket: (store: ColumnarActorStore, entity: EntityIndex, previousCode: number, nextCode: number) => void;
+export declare const moveActorStateBucketBatch: (store: ColumnarActorStore, sourceCode: number, targetCode: number, sourceBucket: readonly EntityIndex[]) => boolean;
+export declare const removeActorRowsForStore: (runtime: EntityRuntimeState, store: ColumnarActorStore, rows: readonly EntityActorRowRef[], bucketStateCodes?: readonly (number | undefined)[], mode?: ActorRowRemovalMode) => number;
+export declare const removeEntityRecords: (runtime: EntityRuntimeState, entities: readonly EntityIndex[]) => number;
+export declare const createPublicInitialState: (runtime: EntityRuntimeState, template: StorageTemplate<EntityTemplateMetadata>) => EntityPublicStateSlice;
+export declare const restorePublicSlices: (runtime: EntityRuntimeState, nextState: Record<string, unknown>) => Record<string, unknown>;
+export declare const rebuildEntityRuntimeIndexes: (runtime: EntityRuntimeState) => void;
+export {};

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

@@ -0,0 +1,12 @@
+import { type EntityRuntimeState } from "./state";
+import type { EntitySnapshot } from "./snapshot-types";
+type EntityDehydrateContext = {
+    readonly options?: {
+        readonly machines?: readonly string[];
+    } | undefined;
+};
+export declare const dehydrateEntityRuntime: (runtime: EntityRuntimeState, ctx: EntityDehydrateContext) => {
+    readonly machines: Record<string, unknown>;
+    readonly snapshot: EntitySnapshot;
+};
+export {};

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

@@ -0,0 +1,12 @@
+import { type EntityRuntimeState } from "./state";
+import type { EntitySnapshot } from "./snapshot-types";
+type EntityDehydrateContext = {
+    readonly options?: {
+        readonly machines?: readonly string[];
+    } | undefined;
+};
+export declare const dehydrateEntityRuntime: (runtime: EntityRuntimeState, ctx: EntityDehydrateContext) => {
+    readonly machines: Record<string, unknown>;
+    readonly snapshot: EntitySnapshot;
+};
+export {};

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

@@ -0,0 +1,5 @@
+import type { ColumnarActorStore, EntityRuntimeState } from "./state";
+import type { EntityColumnKind, ImportedRuntime } from "./snapshot-types";
+export declare const columnKindsFor: (store: ColumnarActorStore) => Record<string, EntityColumnKind>;
+export declare const importEntitySnapshot: (runtime: EntityRuntimeState, value: unknown) => ImportedRuntime;
+export declare const importEntitySnapshotPreview: (runtime: EntityRuntimeState, value: unknown) => ImportedRuntime;

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

@@ -0,0 +1,5 @@
+import type { ColumnarActorStore, EntityRuntimeState } from "./state";
+import type { EntityColumnKind, ImportedRuntime } from "./snapshot-types";
+export declare const columnKindsFor: (store: ColumnarActorStore) => Record<string, EntityColumnKind>;
+export declare const importEntitySnapshot: (runtime: EntityRuntimeState, value: unknown) => ImportedRuntime;
+export declare const importEntitySnapshotPreview: (runtime: EntityRuntimeState, value: unknown) => ImportedRuntime;

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

@@ -0,0 +1,56 @@
+import type { EntityIndex } from "../plugin";
+import type { EntityColumn } from "./state";
+export type EntityColumnKind = "f32" | "i16" | "i32" | "u8" | "string";
+export type EntityStoreSnapshot = {
+    readonly count: number;
+    readonly capacity: number;
+    readonly ids: readonly string[];
+    readonly alive: readonly number[];
+    readonly generation?: readonly number[];
+    readonly groupTagByIndex: readonly string[];
+    readonly freeList?: readonly number[];
+    readonly version: number;
+};
+export type EntityActorSnapshot = {
+    readonly schema: {
+        readonly states: readonly string[];
+        readonly columns: Readonly<Record<string, EntityColumnKind>>;
+    };
+    readonly count: number;
+    readonly capacity: number;
+    readonly version: number;
+    readonly presence: readonly number[];
+    readonly stateCode: readonly number[];
+    readonly prevStateCode: readonly number[];
+    readonly rowVersion?: readonly number[];
+    readonly columns: Readonly<Record<string, readonly unknown[]>>;
+};
+export type EntitySnapshot = {
+    readonly formatVersion: 1;
+    readonly entityStore: EntityStoreSnapshot;
+    readonly actors: Readonly<Record<string, EntityActorSnapshot>>;
+};
+export type ImportedEntityStore = {
+    readonly count: number;
+    readonly capacity: number;
+    readonly ids: string[];
+    readonly alive: Uint8Array;
+    readonly generation: Uint32Array;
+    readonly groupTagByIndex: string[];
+    readonly freeList: EntityIndex[];
+    readonly version: number;
+};
+export type ImportedActorStore = {
+    readonly capacity: number;
+    readonly count: number;
+    readonly version: number;
+    readonly presence: Uint8Array;
+    readonly stateCode: Int16Array;
+    readonly prevStateCode: Int16Array;
+    readonly rowVersion: Uint32Array;
+    readonly columns: Record<string, EntityColumn>;
+};
+export type ImportedRuntime = {
+    readonly entityStore: ImportedEntityStore;
+    readonly actorStores: Record<string, ImportedActorStore>;
+};

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

@@ -0,0 +1,56 @@
+import type { EntityIndex } from "../plugin";
+import type { EntityColumn } from "./state";
+export type EntityColumnKind = "f32" | "i16" | "i32" | "u8" | "string";
+export type EntityStoreSnapshot = {
+    readonly count: number;
+    readonly capacity: number;
+    readonly ids: readonly string[];
+    readonly alive: readonly number[];
+    readonly generation?: readonly number[];
+    readonly groupTagByIndex: readonly string[];
+    readonly freeList?: readonly number[];
+    readonly version: number;
+};
+export type EntityActorSnapshot = {
+    readonly schema: {
+        readonly states: readonly string[];
+        readonly columns: Readonly<Record<string, EntityColumnKind>>;
+    };
+    readonly count: number;
+    readonly capacity: number;
+    readonly version: number;
+    readonly presence: readonly number[];
+    readonly stateCode: readonly number[];
+    readonly prevStateCode: readonly number[];
+    readonly rowVersion?: readonly number[];
+    readonly columns: Readonly<Record<string, readonly unknown[]>>;
+};
+export type EntitySnapshot = {
+    readonly formatVersion: 1;
+    readonly entityStore: EntityStoreSnapshot;
+    readonly actors: Readonly<Record<string, EntityActorSnapshot>>;
+};
+export type ImportedEntityStore = {
+    readonly count: number;
+    readonly capacity: number;
+    readonly ids: string[];
+    readonly alive: Uint8Array;
+    readonly generation: Uint32Array;
+    readonly groupTagByIndex: string[];
+    readonly freeList: EntityIndex[];
+    readonly version: number;
+};
+export type ImportedActorStore = {
+    readonly capacity: number;
+    readonly count: number;
+    readonly version: number;
+    readonly presence: Uint8Array;
+    readonly stateCode: Int16Array;
+    readonly prevStateCode: Int16Array;
+    readonly rowVersion: Uint32Array;
+    readonly columns: Record<string, EntityColumn>;
+};
+export type ImportedRuntime = {
+    readonly entityStore: ImportedEntityStore;
+    readonly actorStores: Record<string, ImportedActorStore>;
+};

package/dist/runtime/snapshot.d.cts

@@ -0,0 +1,15 @@
+import { type EntityRuntimeState } from "./state";
+import type { EntitySnapshot } from "./snapshot-types";
+export { dehydrateEntityRuntime } from "./snapshot-export";
+export { importEntitySnapshotPreview } from "./snapshot-import";
+export type { EntityActorSnapshot, EntitySnapshot, EntityStoreSnapshot, ImportedActorStore, ImportedEntityStore, ImportedRuntime, } from "./snapshot-types";
+type EntityHydrateContext = {
+    readonly machines: Readonly<Record<string, unknown>>;
+    readonly snapshot: EntitySnapshot | undefined;
+    readonly baseState: Record<string, unknown>;
+    readonly mode: "preview" | "commit" | "init";
+};
+export declare const hydrateEntityRuntime: (runtime: EntityRuntimeState, ctx: EntityHydrateContext) => {
+    readonly nextState: Record<string, unknown>;
+    readonly changed: boolean;
+};

package/dist/runtime/snapshot.d.ts

@@ -0,0 +1,15 @@
+import { type EntityRuntimeState } from "./state";
+import type { EntitySnapshot } from "./snapshot-types";
+export { dehydrateEntityRuntime } from "./snapshot-export";
+export { importEntitySnapshotPreview } from "./snapshot-import";
+export type { EntityActorSnapshot, EntitySnapshot, EntityStoreSnapshot, ImportedActorStore, ImportedEntityStore, ImportedRuntime, } from "./snapshot-types";
+type EntityHydrateContext = {
+    readonly machines: Readonly<Record<string, unknown>>;
+    readonly snapshot: EntitySnapshot | undefined;
+    readonly baseState: Record<string, unknown>;
+    readonly mode: "preview" | "commit" | "init";
+};
+export declare const hydrateEntityRuntime: (runtime: EntityRuntimeState, ctx: EntityHydrateContext) => {
+    readonly nextState: Record<string, unknown>;
+    readonly changed: boolean;
+};

package/dist/runtime/spawn-commit.d.cts

@@ -0,0 +1,10 @@
+import type { EntityIndex } from "../plugin";
+import type { SpawnPayloadScope } from "./reduce-shared";
+import { type ColumnarActorStore, type EntityRuntimeState } from "./state";
+import type { StagedEntitySpawn } from "./transaction";
+export type SpawnBatch = {
+    readonly store: ColumnarActorStore;
+    readonly indices: EntityIndex[];
+    readonly payloadScope: SpawnPayloadScope;
+};
+export declare const applyStagedSpawnCommit: (runtime: EntityRuntimeState, stagedSpawns: readonly StagedEntitySpawn[]) => readonly SpawnBatch[];

package/dist/runtime/spawn-commit.d.ts

@@ -0,0 +1,10 @@
+import type { EntityIndex } from "../plugin";
+import type { SpawnPayloadScope } from "./reduce-shared";
+import { type ColumnarActorStore, type EntityRuntimeState } from "./state";
+import type { StagedEntitySpawn } from "./transaction";
+export type SpawnBatch = {
+    readonly store: ColumnarActorStore;
+    readonly indices: EntityIndex[];
+    readonly payloadScope: SpawnPayloadScope;
+};
+export declare const applyStagedSpawnCommit: (runtime: EntityRuntimeState, stagedSpawns: readonly StagedEntitySpawn[]) => readonly SpawnBatch[];

package/dist/runtime/state.d.cts

@@ -0,0 +1,15 @@
+import type { StorageManagerContext, StorageTemplate } from "@lite-fsm/core";
+import type { EntityIndex } from "../plugin";
+import { type EntityTemplateMetadata } from "./compile";
+import type { ColumnarActorStore, EntityReducerSelfCache, EntityRuntimeState, EntityStore } from "./store-types";
+export type { ColumnarActorStore, EntityActorRowRef, EntityColumn, EntityReducerSelfCache, EntityRuntimeState, EntityStore, } from "./store-types";
+export { getInitialColumnValue } from "./columns";
+export { addActorRowOwnership, addEntityToGroupBucket, clearPendingPrevStateCodeSync, createPublicInitialState, moveActorStateBucket, moveActorStateBucketBatch, rebuildActorAcceptStateBuckets, rebuildEntityRuntimeIndexes, refreshActorPublicSlice, removeActorRowsForStore, removeEntityRecords, restorePublicSlices, schedulePresentPrevStateCodeSync, schedulePrevStateCodeSync, schedulePrevStateCodeSyncRow, syncPendingPrevStateCode, } from "./runtime-index";
+export { compileEntityTemplate, ENTITY_INIT_STATE, ENTITY_INIT_STATE_CODE, getEntityStateCode, getEntityStateName, } from "./compile";
+export declare const rebindActorReducerSelf: (store: ColumnarActorStore) => void;
+export declare const getActorReducerSelf: (store: ColumnarActorStore, indices: readonly EntityIndex[]) => EntityReducerSelfCache;
+export declare const createEntityRuntimeState: (templates: readonly StorageTemplate<EntityTemplateMetadata>[], manager: StorageManagerContext) => EntityRuntimeState;
+export declare const getEntityRuntimeState: (manager: object) => EntityRuntimeState;
+export declare const asEntityRuntimeState: (state: unknown) => EntityRuntimeState;
+export declare const ensureEntityCapacity: (store: EntityStore, capacity: number) => void;
+export declare const ensureActorCapacity: (store: ColumnarActorStore, capacity: number) => void;

package/dist/runtime/state.d.ts

@@ -0,0 +1,15 @@
+import type { StorageManagerContext, StorageTemplate } from "@lite-fsm/core";
+import type { EntityIndex } from "../plugin";
+import { type EntityTemplateMetadata } from "./compile";
+import type { ColumnarActorStore, EntityReducerSelfCache, EntityRuntimeState, EntityStore } from "./store-types";
+export type { ColumnarActorStore, EntityActorRowRef, EntityColumn, EntityReducerSelfCache, EntityRuntimeState, EntityStore, } from "./store-types";
+export { getInitialColumnValue } from "./columns";
+export { addActorRowOwnership, addEntityToGroupBucket, clearPendingPrevStateCodeSync, createPublicInitialState, moveActorStateBucket, moveActorStateBucketBatch, rebuildActorAcceptStateBuckets, rebuildEntityRuntimeIndexes, refreshActorPublicSlice, removeActorRowsForStore, removeEntityRecords, restorePublicSlices, schedulePresentPrevStateCodeSync, schedulePrevStateCodeSync, schedulePrevStateCodeSyncRow, syncPendingPrevStateCode, } from "./runtime-index";
+export { compileEntityTemplate, ENTITY_INIT_STATE, ENTITY_INIT_STATE_CODE, getEntityStateCode, getEntityStateName, } from "./compile";
+export declare const rebindActorReducerSelf: (store: ColumnarActorStore) => void;
+export declare const getActorReducerSelf: (store: ColumnarActorStore, indices: readonly EntityIndex[]) => EntityReducerSelfCache;
+export declare const createEntityRuntimeState: (templates: readonly StorageTemplate<EntityTemplateMetadata>[], manager: StorageManagerContext) => EntityRuntimeState;
+export declare const getEntityRuntimeState: (manager: object) => EntityRuntimeState;
+export declare const asEntityRuntimeState: (state: unknown) => EntityRuntimeState;
+export declare const ensureEntityCapacity: (store: EntityStore, capacity: number) => void;
+export declare const ensureActorCapacity: (store: ColumnarActorStore, capacity: number) => void;

package/dist/runtime/storage.d.cts

@@ -0,0 +1,19 @@
+import type { LiteFsmStorageRuntimeDefinition } from "@lite-fsm/core";
+import type { EntityMachineExtension } from "../machine-extension";
+import { type EntityContextSchema, type EntitySpawnSchema } from "../schema";
+import { type EntityEffectInvocation } from "./effects";
+import { type EntitySnapshot } from "./snapshot";
+import type { EntityTemplateMetadata } from "./compile";
+import { type EntityRuntimeState } from "./state";
+export type EntityStorageRouteMeta = {
+    readonly entityId: string | readonly string[];
+};
+export type EntityStorageRuntimeExtension = Omit<EntityMachineExtension, "storage"> & {
+    readonly routeMeta: EntityStorageRouteMeta;
+    readonly runtimeState: EntityRuntimeState;
+    readonly templateData: EntityTemplateMetadata;
+    readonly snapshotData: EntitySnapshot;
+    readonly invocation: EntityEffectInvocation;
+};
+export type EntityStorageDefinition<AppDeps = unknown> = LiteFsmStorageRuntimeDefinition<"entity", EntityMachineExtension<EntityContextSchema, EntitySpawnSchema, object, AppDeps>, EntityStorageRouteMeta>;
+export declare const entityStorageRuntime: EntityStorageDefinition<unknown>;

package/dist/runtime/storage.d.ts

@@ -0,0 +1,19 @@
+import type { LiteFsmStorageRuntimeDefinition } from "@lite-fsm/core";
+import type { EntityMachineExtension } from "../machine-extension";
+import { type EntityContextSchema, type EntitySpawnSchema } from "../schema";
+import { type EntityEffectInvocation } from "./effects";
+import { type EntitySnapshot } from "./snapshot";
+import type { EntityTemplateMetadata } from "./compile";
+import { type EntityRuntimeState } from "./state";
+export type EntityStorageRouteMeta = {
+    readonly entityId: string | readonly string[];
+};
+export type EntityStorageRuntimeExtension = Omit<EntityMachineExtension, "storage"> & {
+    readonly routeMeta: EntityStorageRouteMeta;
+    readonly runtimeState: EntityRuntimeState;
+    readonly templateData: EntityTemplateMetadata;
+    readonly snapshotData: EntitySnapshot;
+    readonly invocation: EntityEffectInvocation;
+};
+export type EntityStorageDefinition<AppDeps = unknown> = LiteFsmStorageRuntimeDefinition<"entity", EntityMachineExtension<EntityContextSchema, EntitySpawnSchema, object, AppDeps>, EntityStorageRouteMeta>;
+export declare const entityStorageRuntime: EntityStorageDefinition<unknown>;

package/dist/runtime/store-types.d.cts

@@ -0,0 +1,81 @@
+import type { MachineStore } from "@lite-fsm/core";
+import type { EntityIndex } from "../plugin";
+import type { EntityAccess } from "./access";
+import type { EntityTemplateMetadata } from "./compile";
+import type { EntityReactRuntime } from "./react";
+export type EntityPublicStateSlice = {
+    readonly storage: "entity";
+    readonly version: number;
+    readonly count: number;
+    readonly capacity: number;
+};
+export type EntityColumn = Float32Array | Int16Array | Int32Array | Uint8Array | string[];
+export type EntityStore = {
+    count: number;
+    capacity: number;
+    ids: string[];
+    indexById: Record<string, EntityIndex>;
+    alive: Uint8Array;
+    generation: Uint32Array;
+    groupTagByIndex: string[];
+    entitiesByGroupTag: Record<string, EntityIndex[]>;
+    groupTagPosition: Int32Array;
+    freeList: EntityIndex[];
+    version: number;
+};
+export type EntityActorRowRef = {
+    readonly store: ColumnarActorStore;
+    readonly entity: EntityIndex;
+    readonly groupTag: string;
+    entityRowsPosition: number;
+    groupRowsPosition: number;
+};
+export type ColumnarActorStore = {
+    readonly storeId: number;
+    readonly templateKey: string;
+    readonly metadata: EntityTemplateMetadata;
+    capacity: number;
+    count: number;
+    version: number;
+    presence: Uint8Array;
+    stateCode: Int16Array;
+    prevStateCode: Int16Array;
+    rowVersion: Uint32Array;
+    stateBuckets: EntityIndex[][];
+    statePosition: Int32Array;
+    acceptedScratch: EntityIndex[];
+    defaultTransitionSourceStateScratch: number[];
+    pendingPrevStateCodeSync: EntityIndex[];
+    pendingPrevStateCodeSyncMark: Uint32Array;
+    pendingPrevStateCodeSyncToken: number;
+    routingScratchVersion: number;
+    acceptStateBucketsByEventCode: EntityIndex[][][];
+    columns: Record<string, EntityColumn>;
+    resources: Record<string, unknown>;
+    resourceViews: Record<string, unknown>;
+    reducerSelf: EntityReducerSelfCache;
+    publicSlice: EntityPublicStateSlice;
+};
+export type EntityReducerSelfCache = Record<string, unknown> & {
+    indices: readonly EntityIndex[];
+    readonly states: EntityTemplateMetadata["stateCodeByName"];
+    presence: Uint8Array;
+    stateCode: Int16Array;
+    prevStateCode: Int16Array;
+    rowVersion: Uint32Array;
+    has(entity: EntityIndex): boolean;
+    entityId(entity: EntityIndex): string;
+};
+export type EntityRuntimeState = {
+    readonly entityStore: EntityStore;
+    readonly actorStores: Record<string, ColumnarActorStore>;
+    readonly actorStoresById: ColumnarActorStore[];
+    readonly eventCodeByType: Readonly<Record<string, number>>;
+    readonly eventTypesByCode: readonly string[];
+    readonly templatesByEventCode: readonly (readonly ColumnarActorStore[])[];
+    actorRowsByEntity: EntityActorRowRef[][];
+    actorRowsByGroupTag: Record<string, EntityActorRowRef[]>;
+    routingScratchVersion: number;
+    readonly access: EntityAccess<MachineStore>;
+    react?: EntityReactRuntime;
+};