@twoabove/cue 0.4.2

package/dist/runtime/Entity.js

@@ -0,0 +1,357 @@
+import { applyPatches } from "immer";
+import { Evolution } from "../core/Evolution";
+import { StateKernel } from "../core/StateKernel";
+import { CommitError, DefinitionMismatchError, HydrationError, OutOfOrderEventsError, StoppedEntityError, } from "../errors";
+import { clone, deserialize, serialize } from "../serde";
+import { _handlers, _initialStateFn, _name, _persistence, _upcasters, } from "../types/internal";
+import { WallClock } from "../utils/clock";
+import { Mailbox } from "./Mailbox";
+import { Supervise } from "./Supervision";
+export class Entity {
+    id;
+    def;
+    managerId;
+    store;
+    supervisor;
+    metrics;
+    clock;
+    kernel;
+    status = "pending";
+    mailbox = new Mailbox();
+    lastTouch;
+    error;
+    hydrationPromise;
+    constructor(id, def, managerId, store, supervisor, metrics, clock = WallClock) {
+        this.id = id;
+        this.def = def;
+        this.managerId = managerId;
+        this.store = store;
+        this.supervisor = supervisor;
+        this.metrics = metrics;
+        this.clock = clock;
+        this.kernel = new StateKernel(this.def);
+        this.lastTouch = this.clock.now();
+    }
+    get isFailed() {
+        return this.status === "failed";
+    }
+    get isShutdown() {
+        return this.status === "stopped";
+    }
+    get lastActivity() {
+        return this.lastTouch;
+    }
+    tell = (handlerName, args) => {
+        return this.mailbox.enqueue(async () => {
+            await this.ensureActive();
+            const task = async () => {
+                const entry = this.def[_handlers][handlerName];
+                if (entry?.type === "stream") {
+                    const stream = this.kernel.startStream(handlerName, args, this.buildContext());
+                    let finalReturn;
+                    try {
+                        while (true) {
+                            const r = await stream.generator.next();
+                            if (r.done) {
+                                finalReturn = r.value;
+                                break;
+                            }
+                        }
+                        const { patches, nextState } = stream.finalize();
+                        if (patches.length > 0) {
+                            await this.commit(handlerName, args, finalReturn, patches, nextState);
+                        }
+                    }
+                    catch (e) {
+                        stream.discard();
+                        throw e;
+                    }
+                    return finalReturn;
+                }
+                const { returnValue, patches, nextState } = await this.kernel.applyCommand(handlerName, args, this.buildContext());
+                if (patches.length > 0) {
+                    await this.commit(handlerName, args, returnValue, patches, nextState);
+                }
+                return returnValue;
+            };
+            if (this.supervisor) {
+                return Supervise(task, this.kernel.state, this.supervisor, this.onReset, this.onStop);
+            }
+            return task();
+        });
+    };
+    ask = (handlerName, args) => {
+        return this.mailbox.enqueue(async () => {
+            await this.ensureActive();
+            return this.kernel.runQuery(handlerName, args, this.buildContext());
+        });
+    };
+    stream = (handlerName, args) => {
+        // Stream holds the mailbox for its entire duration to prevent interleaved
+        // commands from causing state overwrites when the stream commits.
+        const self = this;
+        const channel = [];
+        let consumerWaiting = null;
+        let producerWaiting = null;
+        let aborted = false;
+        function push(item) {
+            if (consumerWaiting) {
+                const resolve = consumerWaiting;
+                consumerWaiting = null;
+                resolve(item);
+            }
+            else {
+                channel.push(item);
+            }
+        }
+        function pull() {
+            const queued = channel.shift();
+            if (queued)
+                return Promise.resolve(queued);
+            return new Promise((resolve) => {
+                consumerWaiting = resolve;
+            });
+        }
+        function signalProducerContinue() {
+            if (producerWaiting) {
+                const { resolve } = producerWaiting;
+                producerWaiting = null;
+                resolve();
+            }
+        }
+        function signalProducerAbort() {
+            aborted = true;
+            if (producerWaiting) {
+                const { reject } = producerWaiting;
+                producerWaiting = null;
+                reject(new Error("stream aborted"));
+            }
+        }
+        const mailboxTask = self.mailbox.enqueue(async () => {
+            await self.ensureActive();
+            const stream = self.kernel.startStream(handlerName, args, self.buildContext());
+            try {
+                for await (const value of stream.generator) {
+                    push({ type: "value", value });
+                    await new Promise((resolve, reject) => {
+                        producerWaiting = { resolve, reject };
+                    });
+                }
+                push({ type: "done" });
+            }
+            catch (e) {
+                if (!aborted) {
+                    stream.discard();
+                    push({ type: "error", error: e });
+                    return;
+                }
+            }
+            const { patches, nextState } = stream.finalize();
+            if (patches.length > 0) {
+                await self.commit(handlerName, args, undefined, patches, nextState);
+            }
+        });
+        async function* outerGenerator() {
+            try {
+                while (true) {
+                    const item = await pull();
+                    if (item.type === "done")
+                        return;
+                    if (item.type === "error")
+                        throw item.error;
+                    yield item.value;
+                    signalProducerContinue();
+                }
+            }
+            finally {
+                signalProducerAbort();
+                await mailboxTask;
+            }
+        }
+        return outerGenerator();
+    };
+    inspect = async () => {
+        await this.ensureActive();
+        return {
+            state: clone(this.kernel.state),
+            version: this.kernel.version,
+        };
+    };
+    terminate = async () => {
+        if (this.isShutdown)
+            return;
+        await this.mailbox.enqueue(async () => {
+            this.status = "stopped";
+        });
+    };
+    stateAt = async (targetVersion) => {
+        if (!this.store) {
+            throw new Error("stateAt requires a persistence store");
+        }
+        const snapshotRec = await this.store.getLatestSnapshot(this.id);
+        let state;
+        let schemaVersion;
+        let currentVersion;
+        if (snapshotRec && snapshotRec.version <= targetVersion) {
+            const envelope = deserialize(snapshotRec.data);
+            state = envelope.state;
+            schemaVersion = envelope.schemaVersion;
+            currentVersion = snapshotRec.version;
+        }
+        else {
+            state = this.def[_initialStateFn]();
+            schemaVersion = 1;
+            currentVersion = 0n;
+        }
+        const events = await this.store.getEvents(this.id, currentVersion);
+        for (const eventRec of events) {
+            if (eventRec.version > targetVersion)
+                break;
+            const envelope = deserialize(eventRec.data);
+            if (envelope.schemaVersion > schemaVersion) {
+                state = Evolution.applyUpcastersTo(state, schemaVersion, envelope.schemaVersion, this.def);
+                schemaVersion = envelope.schemaVersion;
+            }
+            state = applyPatches(state, envelope.patches);
+        }
+        return {
+            schemaVersion,
+            state: clone(state),
+        };
+    };
+    async commit(handlerName, payload, returnVal, patches, nextState) {
+        if (!this.store) {
+            this.kernel.applyCommittedState(nextState);
+            return;
+        }
+        const newVersion = this.kernel.version + 1n;
+        const envelope = {
+            entityDefName: this.def[_name],
+            schemaVersion: this.def[_upcasters].length + 1,
+            handler: handlerName,
+            payload,
+            returnVal,
+            patches,
+        };
+        try {
+            await this.store.commitEvent(this.id, newVersion, serialize(envelope));
+            this.kernel.applyCommittedState(nextState);
+            this.metrics?.onAfterCommit?.(this.id, newVersion, patches);
+            await this.maybeSnapshot();
+        }
+        catch (err) {
+            this.status = "failed";
+            this.error = new CommitError("Failed to commit event", { cause: err });
+            throw this.error;
+        }
+    }
+    async ensureActive() {
+        this.lastTouch = this.clock.now();
+        if (this.status === "active")
+            return;
+        if (this.status === "hydrating")
+            return this.hydrationPromise;
+        if (this.status === "failed" || this.status === "stopped")
+            throw new StoppedEntityError(this.id);
+        if (this.status === "pending")
+            await this.hydrate();
+    }
+    async hydrate() {
+        this.status = "hydrating";
+        this.hydrationPromise = (async () => {
+            try {
+                if (!this.store) {
+                    this.kernel.initialiseInMemory();
+                }
+                else {
+                    const snapshotRec = await this.store.getLatestSnapshot(this.id);
+                    let baseState;
+                    let baseVersion;
+                    let schemaVersion;
+                    if (snapshotRec) {
+                        const snapshot = deserialize(snapshotRec.data);
+                        if (snapshot.entityDefName !== this.def[_name])
+                            throw new DefinitionMismatchError(`Hydrating entity '${this.id}' with definition '${this.def[_name]}', but snapshot is from '${snapshot.entityDefName}'.`);
+                        baseState = snapshot.state;
+                        baseVersion = snapshotRec.version;
+                        schemaVersion = snapshot.schemaVersion;
+                    }
+                    else {
+                        baseState = this.def[_initialStateFn]();
+                        baseVersion = 0n;
+                        schemaVersion = 1;
+                    }
+                    const eventRecs = await this.store.getEvents(this.id, baseVersion);
+                    const events = [];
+                    let expectedVersion = baseVersion + 1n;
+                    for (const rec of eventRecs) {
+                        if (rec.version !== expectedVersion)
+                            throw new OutOfOrderEventsError(`Hydrating entity '${this.id}': expected event version ${expectedVersion}, but got ${rec.version}.`);
+                        const envelope = deserialize(rec.data);
+                        events.push({
+                            schemaVersion: envelope.schemaVersion,
+                            patches: envelope.patches,
+                        });
+                        expectedVersion++;
+                    }
+                    this.kernel.hydrate({
+                        baseState,
+                        baseVersion,
+                        schemaVersion,
+                        events,
+                    });
+                }
+                this.status = "active";
+                this.metrics?.onHydrate?.(this.id);
+            }
+            catch (err) {
+                this.status = "failed";
+                this.error = new HydrationError(`Failed to hydrate entity '${this.id}'`, { cause: err });
+                this.metrics?.onError?.(this.id, this.error);
+                throw this.error;
+            }
+        })();
+        await this.hydrationPromise;
+    }
+    async maybeSnapshot(force = false) {
+        const config = this.def[_persistence];
+        if (!this.store || !config?.snapshotEvery)
+            return;
+        if (force || this.kernel.version % BigInt(config.snapshotEvery) === 0n) {
+            try {
+                this.metrics?.onBeforeSnapshot?.(this.id, this.kernel.version);
+                const envelope = {
+                    entityDefName: this.def[_name],
+                    schemaVersion: this.def[_upcasters].length + 1,
+                    state: this.kernel.state,
+                };
+                await this.store.commitSnapshot(this.id, this.kernel.version, serialize(envelope));
+                this.metrics?.onSnapshot?.(this.id, this.kernel.version);
+            }
+            catch (err) {
+                this.metrics?.onError?.(this.id, err instanceof Error ? err : new Error(String(err)));
+            }
+        }
+    }
+    onReset = async () => {
+        try {
+            await this.store?.clearEntity?.(this.id);
+        }
+        finally {
+            this.kernel.initialiseInMemory();
+            this.status = "active";
+        }
+    };
+    onStop = () => {
+        this.status = "failed";
+        this.error = new Error("Entity stopped by supervisor");
+        throw new StoppedEntityError(this.id);
+    };
+    buildContext() {
+        return {
+            self: { id: this.id, isFailed: this.isFailed },
+            clock: this.clock,
+            meta: { managerId: this.managerId, defName: this.def[_name] },
+        };
+    }
+}

package/dist/runtime/EntityManager.d.ts

@@ -0,0 +1,15 @@
+import type { AnyEntityDefinition, EntityManagerConfig, StateOf } from "../types/public";
+import { Entity } from "./Entity";
+export declare class RuntimeEntityManager<TDef extends AnyEntityDefinition> {
+    private config;
+    private entities;
+    private managerId;
+    private passivation?;
+    isShutdown: boolean;
+    constructor(config: EntityManagerConfig<TDef>);
+    getEntity(id: string): Entity<StateOf<TDef>>;
+    removeEntity(id: string): void;
+    private evictEntity;
+    terminate(): Promise<void>;
+}
+//# sourceMappingURL=EntityManager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"EntityManager.d.ts","sourceRoot":"","sources":["../../src/runtime/EntityManager.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,mBAAmB,EACnB,mBAAmB,EACnB,OAAO,EACR,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAGlC,qBAAa,oBAAoB,CAAC,IAAI,SAAS,mBAAmB;IAMpD,OAAO,CAAC,MAAM;IAL1B,OAAO,CAAC,QAAQ,CAA4C;IAC5D,OAAO,CAAC,SAAS,CAAW;IAC5B,OAAO,CAAC,WAAW,CAAC,CAAqB;IAClC,UAAU,UAAS;gBAEN,MAAM,EAAE,mBAAmB,CAAC,IAAI,CAAC;IAYrD,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IAqB5C,YAAY,CAAC,EAAE,EAAE,MAAM;IAIvB,OAAO,CAAC,WAAW,CAQjB;IAEI,SAAS;CAQhB"}

package/dist/runtime/EntityManager.js

@@ -0,0 +1,46 @@
+import { ManagerShutdownError } from "../errors";
+import { newId } from "../utils/id";
+import { Entity } from "./Entity";
+import { PassivationManager } from "./Passivation";
+export class RuntimeEntityManager {
+    config;
+    entities = new Map();
+    managerId = newId();
+    passivation;
+    isShutdown = false;
+    constructor(config) {
+        this.config = config;
+        if (config.passivation) {
+            this.passivation = new PassivationManager(this.entities, this.evictEntity, config.passivation.idleAfter, config.passivation.sweepInterval ?? 60_000, () => Date.now());
+        }
+    }
+    getEntity(id) {
+        if (this.isShutdown) {
+            throw new ManagerShutdownError("EntityManager is shut down. Cannot create new entities.");
+        }
+        let entity = this.entities.get(id);
+        if (!entity || entity.isFailed) {
+            entity = new Entity(id, this.config.definition, this.managerId, this.config.store, this.config.supervisor, this.config.metrics);
+            this.entities.set(id, entity);
+        }
+        return entity;
+    }
+    removeEntity(id) {
+        this.entities.delete(id);
+    }
+    evictEntity = async (id) => {
+        const entity = this.entities.get(id);
+        if (entity) {
+            await entity.maybeSnapshot(true);
+            await entity.terminate();
+            this.entities.delete(id);
+            this.config.metrics?.onEvict?.(id);
+        }
+    };
+    async terminate() {
+        this.isShutdown = true;
+        this.passivation?.stop();
+        await Promise.allSettled([...this.entities.values()].map((e) => e.terminate()));
+        this.entities.clear();
+    }
+}

package/dist/runtime/Mailbox.d.ts

@@ -0,0 +1,5 @@
+export declare class Mailbox {
+    private queue;
+    enqueue<T>(task: () => Promise<T>): Promise<T>;
+}
+//# sourceMappingURL=Mailbox.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Mailbox.d.ts","sourceRoot":"","sources":["../../src/runtime/Mailbox.ts"],"names":[],"mappings":"AAAA,qBAAa,OAAO;IAClB,OAAO,CAAC,KAAK,CAAuC;IAEpD,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;CAK/C"}

package/dist/runtime/Mailbox.js

@@ -0,0 +1,8 @@
+export class Mailbox {
+    queue = Promise.resolve();
+    enqueue(task) {
+        const taskPromise = this.queue.then(task);
+        this.queue = taskPromise.catch(() => { }); // prevent unhandled promise rejection
+        return taskPromise;
+    }
+}

package/dist/runtime/Passivation.d.ts

@@ -0,0 +1,12 @@
+import type { Entity } from "./Entity";
+export declare class PassivationManager {
+    private entities;
+    private onEvict;
+    private idleAfterMs;
+    private now;
+    private sweeper?;
+    constructor(entities: Map<string, Entity<any>>, onEvict: (id: string) => Promise<void> | void, idleAfterMs: number, sweepIntervalMs: number, now?: () => number);
+    private sweep;
+    stop(): void;
+}
+//# sourceMappingURL=Passivation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Passivation.d.ts","sourceRoot":"","sources":["../../src/runtime/Passivation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAEvC,qBAAa,kBAAkB;IAK3B,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,WAAW;IAEnB,OAAO,CAAC,GAAG;IARb,OAAO,CAAC,OAAO,CAAC,CAA6C;gBAInD,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,EAClC,OAAO,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,EAC7C,WAAW,EAAE,MAAM,EAC3B,eAAe,EAAE,MAAM,EACf,GAAG,GAAE,MAAM,MAAyB;YAYhC,KAAK;IAanB,IAAI;CAML"}

package/dist/runtime/Passivation.js

@@ -0,0 +1,42 @@
+export class PassivationManager {
+    entities;
+    onEvict;
+    idleAfterMs;
+    now;
+    sweeper;
+    constructor(
+    // biome-ignore lint/suspicious/noExplicitAny: Entity can have any state
+    entities, onEvict, idleAfterMs, sweepIntervalMs, now = () => Date.now()) {
+        this.entities = entities;
+        this.onEvict = onEvict;
+        this.idleAfterMs = idleAfterMs;
+        this.now = now;
+        this.sweeper = setInterval(() => {
+            // Run the sweep as an async task; swallow errors but complete its awaits.
+            (async () => {
+                await this.sweep();
+            })().catch(() => { });
+        }, sweepIntervalMs);
+        // `unref` doesn't exist in some environments (e.g., browsers)
+        this.sweeper.unref?.();
+    }
+    async sweep() {
+        const now = this.now();
+        const pending = [];
+        for (const [id, entity] of this.entities.entries()) {
+            if (entity.isFailed)
+                continue;
+            if (now - entity.lastActivity > this.idleAfterMs) {
+                pending.push(this.onEvict(id));
+            }
+        }
+        // Ensure evictions complete (important for fake-timer tests)
+        await Promise.allSettled(pending);
+    }
+    stop() {
+        if (this.sweeper) {
+            clearInterval(this.sweeper);
+            this.sweeper = undefined;
+        }
+    }
+}

package/dist/runtime/Supervision.d.ts

@@ -0,0 +1,4 @@
+import type { Supervisor } from "../types/public";
+export declare function Supervise<T>(task: () => Promise<T>, state: unknown, supervisor: Supervisor, onReset: () => Promise<void>, // side-effect; we will throw here
+onStop: () => never): Promise<T>;
+//# sourceMappingURL=Supervision.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Supervision.d.ts","sourceRoot":"","sources":["../../src/runtime/Supervision.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAElD,wBAAsB,SAAS,CAAC,CAAC,EAC/B,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACtB,KAAK,EAAE,OAAO,EACd,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,EAAE,kCAAkC;AAChE,MAAM,EAAE,MAAM,KAAK,GAClB,OAAO,CAAC,CAAC,CAAC,CAiBZ"}

package/dist/runtime/Supervision.js

@@ -0,0 +1,20 @@
+import { ResetError } from "../errors";
+export async function Supervise(task, state, supervisor, onReset, // side-effect; we will throw here
+onStop) {
+    try {
+        return await task();
+    }
+    catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        const strategy = supervisor.strategy(state, error);
+        switch (strategy) {
+            case "resume":
+                throw error;
+            case "reset":
+                await onReset();
+                throw new ResetError(error);
+            case "stop":
+                onStop(); // this should throw
+        }
+    }
+}

package/dist/serde/index.d.ts

@@ -0,0 +1,7 @@
+export declare const clone: <T>(value: T) => T;
+export declare const serialize: (value: unknown) => string;
+export declare const deserialize: <T = unknown>(value: string) => T;
+export declare const serializeComparable: (value: unknown) => unknown;
+export declare const deepEqual: (a: unknown, b: unknown) => boolean;
+export declare const escapeJsonPointerToken: (token: string | number) => string;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/serde/index.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,KAAK,GAAI,CAAC,EAAE,OAAO,CAAC,KAAG,CACc,CAAC;AAEnD,eAAO,MAAM,SAAS,GAAI,OAAO,OAAO,KAAG,MAAoC,CAAC;AAEhF,eAAO,MAAM,WAAW,GAAI,CAAC,GAAG,OAAO,EAAE,OAAO,MAAM,KAAG,CACjC,CAAC;AAEzB,eAAO,MAAM,mBAAmB,GAAI,OAAO,OAAO,KAAG,OACpB,CAAC;AAElC,eAAO,MAAM,SAAS,GAAI,GAAG,OAAO,EAAE,GAAG,OAAO,KAAG,OAQlD,CAAC;AAEF,eAAO,MAAM,sBAAsB,GAAI,OAAO,MAAM,GAAG,MAAM,KAAG,MAG/D,CAAC"}

package/dist/serde/index.js

@@ -0,0 +1,19 @@
+import superjson from "superjson";
+export const clone = (value) => superjson.parse(superjson.stringify(value));
+export const serialize = (value) => superjson.stringify(value);
+export const deserialize = (value) => superjson.parse(value);
+export const serializeComparable = (value) => superjson.serialize(value).json;
+export const deepEqual = (a, b) => {
+    try {
+        const serializedA = superjson.stringify(a);
+        const serializedB = superjson.stringify(b);
+        return serializedA === serializedB;
+    }
+    catch {
+        return a === b;
+    }
+};
+export const escapeJsonPointerToken = (token) => {
+    const str = String(token);
+    return str.replace(/~/g, "~0").replace(/\//g, "~1");
+};

package/dist/types/internal.d.ts

@@ -0,0 +1,10 @@
+export declare const _name: unique symbol;
+export declare const _state: unique symbol;
+export declare const _messages: unique symbol;
+export declare const _tag: unique symbol;
+export declare const _initialStateFn: unique symbol;
+export declare const _upcasters: unique symbol;
+export declare const _handlers: unique symbol;
+export declare const _persistence: unique symbol;
+export declare const _versions: unique symbol;
+//# sourceMappingURL=internal.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../../src/types/internal.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,KAAK,eAAyB,CAAC;AAC5C,eAAO,MAAM,MAAM,eAA0B,CAAC;AAC9C,eAAO,MAAM,SAAS,eAA6B,CAAC;AACpD,eAAO,MAAM,IAAI,eAAwB,CAAC;AAC1C,eAAO,MAAM,eAAe,eAAmC,CAAC;AAChE,eAAO,MAAM,UAAU,eAA8B,CAAC;AACtD,eAAO,MAAM,SAAS,eAA6B,CAAC;AACpD,eAAO,MAAM,YAAY,eAAgC,CAAC;AAC1D,eAAO,MAAM,SAAS,eAA6B,CAAC"}

package/dist/types/internal.js

@@ -0,0 +1,10 @@
+// Branded symbols to hide internal properties from the public API and prevent accidental access.
+export const _name = Symbol.for("cue_name");
+export const _state = Symbol.for("cue_state");
+export const _messages = Symbol.for("cue_messages");
+export const _tag = Symbol.for("cue_tag");
+export const _initialStateFn = Symbol.for("cue_initialStateFn");
+export const _upcasters = Symbol.for("cue_upcasters");
+export const _handlers = Symbol.for("cue_handlers");
+export const _persistence = Symbol.for("cue_persistence");
+export const _versions = Symbol.for("cue_versions");