@twoabove/cue 0.4.2

package/dist/api/supervisor.d.ts

@@ -0,0 +1,22 @@
+import type { Supervisor, SupervisorStrategy } from "../types/public";
+type Guard = (state: unknown, error: Error) => boolean;
+/**
+ * Ergonomic builder for a Supervisor without stringly-typed returns.
+ *
+ * Usage:
+ *   const sup = supervisor({
+ *     // Choose a strategy when the guard returns true.
+ *     resume: (state, err) => err.name === "ValidationError",
+ *     stop:   (state, err) => err.name === "CatastrophicConfigError",
+ *     // Fallback if no guard matches (defaults to "resume")
+ *     default: "reset",
+ *   });
+ */
+export declare function supervisor(spec: {
+    resume?: boolean | Guard;
+    reset?: boolean | Guard;
+    stop?: boolean | Guard;
+    default?: SupervisorStrategy;
+}): Supervisor;
+export {};
+//# sourceMappingURL=supervisor.d.ts.map

package/dist/api/supervisor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"supervisor.d.ts","sourceRoot":"","sources":["../../src/api/supervisor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAEtE,KAAK,KAAK,GAAG,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,KAAK,OAAO,CAAC;AAEvD;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE;IAC/B,MAAM,CAAC,EAAE,OAAO,GAAG,KAAK,CAAC;IACzB,KAAK,CAAC,EAAE,OAAO,GAAG,KAAK,CAAC;IACxB,IAAI,CAAC,EAAE,OAAO,GAAG,KAAK,CAAC;IACvB,OAAO,CAAC,EAAE,kBAAkB,CAAC;CAC9B,GAAG,UAAU,CAuBb"}

package/dist/api/supervisor.js

@@ -0,0 +1,39 @@
+/**
+ * Ergonomic builder for a Supervisor without stringly-typed returns.
+ *
+ * Usage:
+ *   const sup = supervisor({
+ *     // Choose a strategy when the guard returns true.
+ *     resume: (state, err) => err.name === "ValidationError",
+ *     stop:   (state, err) => err.name === "CatastrophicConfigError",
+ *     // Fallback if no guard matches (defaults to "resume")
+ *     default: "reset",
+ *   });
+ */
+export function supervisor(spec) {
+    const toGuard = (g) => {
+        if (g === undefined)
+            return undefined;
+        if (typeof g === "function")
+            return g;
+        return () => g; // boolean -> constant guard
+    };
+    const guards = {
+        // Strategy precedence: stop → reset → resume
+        stop: toGuard(spec.stop),
+        reset: toGuard(spec.reset),
+        resume: toGuard(spec.resume),
+    };
+    const fallback = spec.default ?? "resume";
+    return {
+        strategy(state, error) {
+            if (guards.stop?.(state, error))
+                return "stop";
+            if (guards.reset?.(state, error))
+                return "reset";
+            if (guards.resume?.(state, error))
+                return "resume";
+            return fallback;
+        },
+    };
+}

package/dist/core/Evolution.d.ts

@@ -0,0 +1,11 @@
+import type { AnyEntityDefinition } from "../types/public";
+declare function applyUpcasters<T = any>(state: T, fromSchemaVersion: number, def: AnyEntityDefinition): T;
+declare function applyUpcastersTo<T = any>(state: T, fromSchemaVersion: number, toSchemaVersion: number, def: AnyEntityDefinition): T;
+declare function getLatestInitialState(def: AnyEntityDefinition): any;
+export declare const Evolution: {
+    applyUpcasters: typeof applyUpcasters;
+    applyUpcastersTo: typeof applyUpcastersTo;
+    getLatestInitialState: typeof getLatestInitialState;
+};
+export {};
+//# sourceMappingURL=Evolution.d.ts.map

package/dist/core/Evolution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Evolution.d.ts","sourceRoot":"","sources":["../../src/core/Evolution.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAG3D,iBAAS,cAAc,CAAC,CAAC,GAAG,GAAG,EAC7B,KAAK,EAAE,CAAC,EACR,iBAAiB,EAAE,MAAM,EACzB,GAAG,EAAE,mBAAmB,GACvB,CAAC,CAOH;AAGD,iBAAS,gBAAgB,CAAC,CAAC,GAAG,GAAG,EAC/B,KAAK,EAAE,CAAC,EACR,iBAAiB,EAAE,MAAM,EACzB,eAAe,EAAE,MAAM,EACvB,GAAG,EAAE,mBAAmB,GACvB,CAAC,CAUH;AAGD,iBAAS,qBAAqB,CAAC,GAAG,EAAE,mBAAmB,GAAG,GAAG,CAG5D;AAED,eAAO,MAAM,SAAS;;;;CAIrB,CAAC"}

package/dist/core/Evolution.js

@@ -0,0 +1,29 @@
+import { _initialStateFn, _upcasters } from "../types/internal";
+// biome-ignore lint/suspicious/noExplicitAny: patches can apply to any state shape
+function applyUpcasters(state, fromSchemaVersion, def) {
+    const upcastersToRun = def[_upcasters].slice(fromSchemaVersion - 1);
+    let evolvedState = state;
+    for (const upcaster of upcastersToRun) {
+        evolvedState = upcaster(evolvedState);
+    }
+    return evolvedState;
+}
+// biome-ignore lint/suspicious/noExplicitAny: state shapes vary across versions
+function applyUpcastersTo(state, fromSchemaVersion, toSchemaVersion, def) {
+    const upcastersToRun = def[_upcasters].slice(fromSchemaVersion - 1, toSchemaVersion - 1);
+    let evolvedState = state;
+    for (const upcaster of upcastersToRun) {
+        evolvedState = upcaster(evolvedState);
+    }
+    return evolvedState;
+}
+// biome-ignore lint/suspicious/noExplicitAny: initial state can be any shape
+function getLatestInitialState(def) {
+    const initialState = def[_initialStateFn]();
+    return applyUpcasters(initialState, 1, def);
+}
+export const Evolution = {
+    applyUpcasters,
+    applyUpcastersTo,
+    getLatestInitialState,
+};

package/dist/core/StateKernel.d.ts

@@ -0,0 +1,35 @@
+import type { AnyEntityDefinition, HandlerContext, Patch } from "../types/public";
+export declare class StateKernel<TState extends object> {
+    #private;
+    private readonly def;
+    constructor(def: AnyEntityDefinition);
+    get state(): TState;
+    get version(): bigint;
+    initialiseInMemory(): void;
+    hydrate(params: {
+        baseState: TState;
+        baseVersion: bigint;
+        schemaVersion: number;
+        events: Array<{
+            schemaVersion: number;
+            patches: Patch;
+        }>;
+    }): void;
+    getLatestInitialState(): TState;
+    applyCommittedState(nextState: TState): void;
+    applyCommand(handlerName: string, args: unknown[], ctx: HandlerContext): Promise<{
+        returnValue: unknown;
+        patches: Patch;
+        nextState: TState;
+    }>;
+    runQuery(handlerName: string, args: unknown[], ctx: HandlerContext): unknown;
+    startStream(handlerName: string, args: unknown[], ctx: HandlerContext): {
+        generator: AsyncGenerator;
+        finalize: () => {
+            patches: Patch;
+            nextState: TState;
+        };
+        discard: () => void;
+    };
+}
+//# sourceMappingURL=StateKernel.d.ts.map

package/dist/core/StateKernel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StateKernel.d.ts","sourceRoot":"","sources":["../../src/core/StateKernel.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EACV,mBAAmB,EACnB,cAAc,EACd,KAAK,EACN,MAAM,iBAAiB,CAAC;AAIzB,qBAAa,WAAW,CAAC,MAAM,SAAS,MAAM;;IAIhC,OAAO,CAAC,QAAQ,CAAC,GAAG;gBAAH,GAAG,EAAE,mBAAmB;IAErD,IAAI,KAAK,IAAI,MAAM,CAMlB;IAED,IAAI,OAAO,IAAI,MAAM,CAMpB;IAED,kBAAkB;IAKlB,OAAO,CAAC,MAAM,EAAE;QACd,SAAS,EAAE,MAAM,CAAC;QAClB,WAAW,EAAE,MAAM,CAAC;QACpB,aAAa,EAAE,MAAM,CAAC;QACtB,MAAM,EAAE,KAAK,CAAC;YAAE,aAAa,EAAE,MAAM,CAAC;YAAC,OAAO,EAAE,KAAK,CAAA;SAAE,CAAC,CAAC;KAC1D;IAsBD,qBAAqB,IAAI,MAAM;IAI/B,mBAAmB,CAAC,SAAS,EAAE,MAAM;IAK/B,YAAY,CAChB,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,OAAO,EAAE,EACf,GAAG,EAAE,cAAc,GAClB,OAAO,CAAC;QAAE,WAAW,EAAE,OAAO,CAAC;QAAC,OAAO,EAAE,KAAK,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;IAsBvE,QAAQ,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,GAAG,EAAE,cAAc,GAAG,OAAO;IAe5E,WAAW,CACT,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,OAAO,EAAE,EACf,GAAG,EAAE,cAAc,GAClB;QACD,SAAS,EAAE,cAAc,CAAC;QAC1B,QAAQ,EAAE,MAAM;YAAE,OAAO,EAAE,KAAK,CAAC;YAAC,SAAS,EAAE,MAAM,CAAA;SAAE,CAAC;QACtD,OAAO,EAAE,MAAM,IAAI,CAAC;KACrB;CAiDF"}

package/dist/core/StateKernel.js

@@ -0,0 +1,113 @@
+import { applyPatches, createDraft, finishDraft, isDraft, } from "immer";
+import { _handlers } from "../types/internal";
+import { invariant } from "../utils/invariants";
+import { Evolution } from "./Evolution";
+export class StateKernel {
+    def;
+    #state = null;
+    #version = -1n;
+    constructor(def) {
+        this.def = def;
+    }
+    get state() {
+        invariant(this.#state, "State not available. Ensure the entity is hydrated.");
+        return this.#state;
+    }
+    get version() {
+        invariant(this.#version >= 0n, "Version not available. Ensure the entity is hydrated.");
+        return this.#version;
+    }
+    initialiseInMemory() {
+        this.#state = Evolution.getLatestInitialState(this.def);
+        this.#version = 0n;
+    }
+    hydrate(params) {
+        let state = params.baseState;
+        let currentSchema = params.schemaVersion;
+        for (const event of params.events) {
+            if (event.schemaVersion > currentSchema) {
+                state = Evolution.applyUpcastersTo(state, currentSchema, event.schemaVersion, this.def);
+                currentSchema = event.schemaVersion;
+            }
+            state = applyPatches(state, event.patches);
+        }
+        // Upcast to latest schema version
+        this.#state = Evolution.applyUpcasters(state, currentSchema, this.def);
+        this.#version = params.baseVersion + BigInt(params.events.length);
+    }
+    getLatestInitialState() {
+        return Evolution.getLatestInitialState(this.def);
+    }
+    applyCommittedState(nextState) {
+        this.#state = nextState;
+        this.#version += 1n;
+    }
+    async applyCommand(handlerName, args, ctx) {
+        const entry = this.def[_handlers][handlerName];
+        invariant(entry && entry.type === "command", `Handler "${handlerName}" not found or not a command.`);
+        let patches = [];
+        const draft = createDraft(this.state);
+        try {
+            const returnValue = await Promise.resolve(entry.fn(draft, ...args, ctx));
+            const nextState = finishDraft(draft, (p) => {
+                patches = p;
+            });
+            return { returnValue, patches, nextState };
+        }
+        catch (e) {
+            finishDraft(draft);
+            throw e;
+        }
+    }
+    runQuery(handlerName, args, ctx) {
+        const entry = this.def[_handlers][handlerName];
+        invariant(entry && entry.type === "query", `Handler "${handlerName}" not found or not a query.`);
+        const draft = createDraft(this.state);
+        try {
+            return entry.fn(draft, ...args, ctx);
+        }
+        finally {
+            finishDraft(draft); // discards changes
+        }
+    }
+    startStream(handlerName, args, ctx) {
+        const entry = this.def[_handlers][handlerName];
+        invariant(entry && entry.type === "stream", `Handler "${handlerName}" not found or not a stream.`);
+        const draft = createDraft(this.state);
+        const generatorImpl = entry.fn(draft, ...args, ctx);
+        invariant(generatorImpl && typeof generatorImpl.next === "function", `Stream handler "${handlerName}" did not return an AsyncGenerator.`);
+        const generator = {
+            async next(...a) {
+                return await generatorImpl.next(...a);
+            },
+            async return(...a) {
+                return generatorImpl.return(...a);
+            },
+            async throw(...a) {
+                return generatorImpl.throw(...a);
+            },
+            [Symbol.asyncIterator]() {
+                return this;
+            },
+            // TS 5.9 AsyncDisposable – no-op to satisfy the interface
+            async [Symbol.asyncDispose]() {
+                /* noop */
+            },
+        };
+        return {
+            generator,
+            finalize: () => {
+                let patches = [];
+                const nextState = finishDraft(draft, (p) => {
+                    patches = p;
+                });
+                return { patches, nextState };
+            },
+            discard: () => {
+                if (isDraft(draft)) {
+                    finishDraft(draft);
+                }
+            },
+        };
+    }
+}

package/dist/errors/index.d.ts

@@ -0,0 +1,22 @@
+export declare class ResetError extends Error {
+    constructor(original: Error);
+}
+export declare class DefinitionMismatchError extends Error {
+    constructor(message: string);
+}
+export declare class OutOfOrderEventsError extends Error {
+    constructor(message: string);
+}
+export declare class CommitError extends Error {
+    constructor(message: string, cause?: unknown);
+}
+export declare class HydrationError extends Error {
+    constructor(message: string, cause?: unknown);
+}
+export declare class StoppedEntityError extends Error {
+    constructor(entityId: string);
+}
+export declare class ManagerShutdownError extends Error {
+    constructor(message: string);
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/errors/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/errors/index.ts"],"names":[],"mappings":"AAAA,qBAAa,UAAW,SAAQ,KAAK;gBACvB,QAAQ,EAAE,KAAK;CAK5B;AAED,qBAAa,uBAAwB,SAAQ,KAAK;gBACpC,OAAO,EAAE,MAAM;CAI5B;AAED,qBAAa,qBAAsB,SAAQ,KAAK;gBAClC,OAAO,EAAE,MAAM;CAI5B;AAED,qBAAa,WAAY,SAAQ,KAAK;gBACxB,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO;CAI7C;AAED,qBAAa,cAAe,SAAQ,KAAK;gBAC3B,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO;CAI7C;AAED,qBAAa,kBAAmB,SAAQ,KAAK;gBAC/B,QAAQ,EAAE,MAAM;CAM7B;AAED,qBAAa,oBAAqB,SAAQ,KAAK;gBACjC,OAAO,EAAE,MAAM;CAI5B"}

package/dist/errors/index.js

@@ -0,0 +1,43 @@
+export class ResetError extends Error {
+    constructor(original) {
+        super(`Entity reset after error: ${original.message}`);
+        this.cause = original;
+        this.name = "ResetError";
+    }
+}
+export class DefinitionMismatchError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "DefinitionMismatchError";
+    }
+}
+export class OutOfOrderEventsError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "OutOfOrderEventsError";
+    }
+}
+export class CommitError extends Error {
+    constructor(message, cause) {
+        super(message, { cause });
+        this.name = "CommitError";
+    }
+}
+export class HydrationError extends Error {
+    constructor(message, cause) {
+        super(message, { cause });
+        this.name = "HydrationError";
+    }
+}
+export class StoppedEntityError extends Error {
+    constructor(entityId) {
+        super(`Entity ${entityId} is stopped/failed. Further messages are rejected.`);
+        this.name = "StoppedEntityError";
+    }
+}
+export class ManagerShutdownError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ManagerShutdownError";
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./api/index";
+export * from "./errors/index";
+export type * from "./persistence/types";
+export type * from "./types/public";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,mBAAmB,qBAAqB,CAAC;AACzC,mBAAmB,gBAAgB,CAAC"}

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from "./api/index";
+export * from "./errors/index";

package/dist/persistence/adapters/inMemory.d.ts

@@ -0,0 +1,21 @@
+import type { PersistenceAdapter } from "../types";
+interface EventRecord {
+    version: bigint;
+    data: string;
+}
+interface SnapshotRecord {
+    version: bigint;
+    data: string;
+}
+export declare class InMemoryPersistenceAdapter implements PersistenceAdapter {
+    private events;
+    private snapshots;
+    getEvents(entityId: string, fromVersion: bigint): Promise<EventRecord[]>;
+    commitEvent(entityId: string, version: bigint, data: string): Promise<void>;
+    getLatestSnapshot(entityId: string): Promise<SnapshotRecord | null>;
+    commitSnapshot(entityId: string, version: bigint, data: string): Promise<void>;
+    clearEntity(entityId: string): Promise<void>;
+    clear(): void;
+}
+export {};
+//# sourceMappingURL=inMemory.d.ts.map

package/dist/persistence/adapters/inMemory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inMemory.d.ts","sourceRoot":"","sources":["../../../src/persistence/adapters/inMemory.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAEnD,UAAU,WAAW;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,UAAU,cAAc;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;CACd;AAWD,qBAAa,0BAA2B,YAAW,kBAAkB;IACnE,OAAO,CAAC,MAAM,CAAoC;IAClD,OAAO,CAAC,SAAS,CAAqC;IAEhD,SAAS,CACb,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,WAAW,EAAE,CAAC;IAKnB,WAAW,CACf,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,IAAI,CAAC;IAcV,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC;IAKnE,cAAc,CAClB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,IAAI,CAAC;IAIV,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAMlD,KAAK,IAAI,IAAI;CAId"}

package/dist/persistence/adapters/inMemory.js

@@ -0,0 +1,41 @@
+import { CommitError } from "../../errors/index";
+import { clone } from "../../serde/index";
+function auditVersion(currentVersion, newVersion) {
+    const expectedVersion = currentVersion + 1n;
+    if (newVersion !== expectedVersion) {
+        throw new CommitError(`Optimistic lock failure: expected version ${expectedVersion}, got ${newVersion}.`);
+    }
+}
+export class InMemoryPersistenceAdapter {
+    events = new Map();
+    snapshots = new Map();
+    async getEvents(entityId, fromVersion) {
+        const entityEvents = this.events.get(entityId) ?? [];
+        return clone(entityEvents.filter((event) => event.version > fromVersion));
+    }
+    async commitEvent(entityId, version, data) {
+        const entityEvents = this.events.get(entityId) ?? [];
+        const lastEventVersion = entityEvents.at(-1)?.version ?? 0n;
+        const snapshotVersion = this.snapshots.get(entityId)?.version ?? 0n;
+        const currentVersion = lastEventVersion > snapshotVersion ? lastEventVersion : snapshotVersion;
+        auditVersion(currentVersion, version);
+        entityEvents.push({ version, data });
+        this.events.set(entityId, entityEvents);
+    }
+    async getLatestSnapshot(entityId) {
+        const snapshot = this.snapshots.get(entityId);
+        return snapshot ? clone(snapshot) : null;
+    }
+    async commitSnapshot(entityId, version, data) {
+        this.snapshots.set(entityId, { version, data });
+    }
+    async clearEntity(entityId) {
+        this.events.delete(entityId);
+        this.snapshots.delete(entityId);
+    }
+    // test helper
+    clear() {
+        this.events.clear();
+        this.snapshots.clear();
+    }
+}

package/dist/persistence/types.d.ts

@@ -0,0 +1,28 @@
+import type { Patch } from "../types/public";
+export type EventEnvelope = {
+    entityDefName: string;
+    schemaVersion: number;
+    handler: string;
+    payload: unknown[];
+    returnVal?: unknown;
+    patches: Patch;
+};
+export type SnapshotEnvelope = {
+    entityDefName: string;
+    schemaVersion: number;
+    state: unknown;
+};
+export interface PersistenceAdapter {
+    getEvents(entityId: string, fromVersion: bigint): Promise<{
+        version: bigint;
+        data: string;
+    }[]>;
+    commitEvent(entityId: string, version: bigint, data: string): Promise<void>;
+    getLatestSnapshot(entityId: string): Promise<{
+        version: bigint;
+        data: string;
+    } | null>;
+    commitSnapshot(entityId: string, version: bigint, data: string): Promise<void>;
+    clearEntity?(entityId: string): Promise<void>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/persistence/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/persistence/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAE7C,MAAM,MAAM,aAAa,GAAG;IAC1B,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,OAAO,EAAE,CAAC;IACnB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,OAAO,EAAE,KAAK,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AAEF,MAAM,WAAW,kBAAkB;IACjC,SAAS,CACP,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC,CAAC;IAEhD,WAAW,CACT,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,IAAI,CAAC,CAAC;IAEjB,iBAAiB,CACf,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC,CAAC;IAErD,cAAc,CACZ,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,IAAI,CAAC,CAAC;IAEjB,WAAW,CAAC,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/C"}

package/dist/persistence/types.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/Entity.d.ts

@@ -0,0 +1,42 @@
+import type { PersistenceAdapter } from "../persistence/types";
+import type { AnyEntityDefinition, EntityMetrics, Supervisor } from "../types/public";
+import type { Clock } from "../utils/clock";
+export declare class Entity<TState extends object> {
+    readonly id: string;
+    private readonly def;
+    private readonly managerId;
+    private readonly store?;
+    private readonly supervisor?;
+    private readonly metrics?;
+    private readonly clock;
+    private kernel;
+    private status;
+    private mailbox;
+    private lastTouch;
+    private error?;
+    private hydrationPromise?;
+    constructor(id: string, def: AnyEntityDefinition, managerId: string, store?: PersistenceAdapter | undefined, supervisor?: Supervisor | undefined, metrics?: EntityMetrics | undefined, clock?: Clock);
+    get isFailed(): boolean;
+    get isShutdown(): boolean;
+    get lastActivity(): number;
+    tell: (handlerName: string, args: unknown[]) => Promise<unknown>;
+    ask: (handlerName: string, args: unknown[]) => Promise<unknown>;
+    stream: (handlerName: string, args: unknown[]) => AsyncGenerator<unknown, unknown, unknown>;
+    inspect: () => Promise<{
+        state: TState;
+        version: bigint;
+    }>;
+    terminate: () => Promise<void>;
+    stateAt: (targetVersion: bigint) => Promise<{
+        schemaVersion: number;
+        state: unknown;
+    }>;
+    private commit;
+    private ensureActive;
+    private hydrate;
+    maybeSnapshot(force?: boolean): Promise<void>;
+    private onReset;
+    private onStop;
+    private buildContext;
+}
+//# sourceMappingURL=Entity.d.ts.map

package/dist/runtime/Entity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Entity.d.ts","sourceRoot":"","sources":["../../src/runtime/Entity.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAEV,kBAAkB,EAEnB,MAAM,sBAAsB,CAAC;AAS9B,OAAO,KAAK,EACV,mBAAmB,EACnB,aAAa,EAEb,UAAU,EACX,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAO5C,qBAAa,MAAM,CAAC,MAAM,SAAS,MAAM;aASrB,EAAE,EAAE,MAAM;IAC1B,OAAO,CAAC,QAAQ,CAAC,GAAG;IACpB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC;IACvB,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAC;IAC5B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC;IACzB,OAAO,CAAC,QAAQ,CAAC,KAAK;IAdxB,OAAO,CAAC,MAAM,CAAsB;IACpC,OAAO,CAAC,MAAM,CAA2B;IACzC,OAAO,CAAC,OAAO,CAAiB;IAChC,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,KAAK,CAAC,CAAQ;IACtB,OAAO,CAAC,gBAAgB,CAAC,CAAgB;gBAGvB,EAAE,EAAE,MAAM,EACT,GAAG,EAAE,mBAAmB,EACxB,SAAS,EAAE,MAAM,EACjB,KAAK,CAAC,EAAE,kBAAkB,YAAA,EAC1B,UAAU,CAAC,EAAE,UAAU,YAAA,EACvB,OAAO,CAAC,EAAE,aAAa,YAAA,EACvB,KAAK,GAAE,KAAiB;IAM3C,IAAI,QAAQ,IAAI,OAAO,CAEtB;IAED,IAAI,UAAU,IAAI,OAAO,CAExB;IAED,IAAI,YAAY,IAAI,MAAM,CAEzB;IAEM,IAAI,GAAI,aAAa,MAAM,EAAE,MAAM,OAAO,EAAE,KAAG,OAAO,CAAC,OAAO,CAAC,CA6DpE;IAEK,GAAG,GAAI,aAAa,MAAM,EAAE,MAAM,OAAO,EAAE,KAAG,OAAO,CAAC,OAAO,CAAC,CAKnE;IAEK,MAAM,GACX,aAAa,MAAM,EACnB,MAAM,OAAO,EAAE,KACd,cAAc,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,CAuG1C;IAEK,OAAO,QAAa,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAMpE;IAEK,SAAS,QAAa,OAAO,CAAC,IAAI,CAAC,CAKxC;IAEK,OAAO,GACZ,eAAe,MAAM,KACpB,OAAO,CAAC;QAAE,aAAa,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,OAAO,CAAA;KAAE,CAAC,CA8CnD;YAEY,MAAM;YAkCN,YAAY;YASZ,OAAO;IAgER,aAAa,CAAC,KAAK,UAAQ;IA0BxC,OAAO,CAAC,OAAO,CAOb;IAEF,OAAO,CAAC,MAAM,CAIZ;IAEF,OAAO,CAAC,YAAY;CAOrB"}