@spine-event-engine/storage 2.0.0-snapshot.10

package/dist/memory/in-memory-entity-history.js

@@ -0,0 +1,756 @@
+/*
+ * Copyright 2026, CodeMatters. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License. You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the License for the specific language governing permissions and limitations under
+ * the License.
+ */
+import { clone, create, fromBinary, toBinary } from "@bufbuild/protobuf";
+import { TimestampSchema } from "@bufbuild/protobuf/wkt";
+import { EventSchema } from "@spine-event-engine/proto";
+import { EntityRecordSchema, } from "@spine-event-engine/proto/generated/spine/server/entity/entity_pb.js";
+import { EntityStateKeySchema, } from "@spine-event-engine/proto/generated/spine/server/entity/state_key_pb.js";
+import { disabledEventHistoryPort, disabledStateHistoryPort, } from "../entity/entity-history-storage.js";
+import { TenantBoundary } from "../internal/tenancy.js";
+import { CanonicalUtf8 } from "./canonical-utf8.js";
+import { InMemoryStorageBackend } from "./in-memory-storage-backend.js";
+import { RecordColumn } from "../record/record-column.js";
+import { StorageQueryEvaluator } from "../query/query-execution.js";
+import { StorageQueryPolicy } from "../query/query-policy.js";
+const storageHost = globalThis;
+/**
+ * Shared in-memory entity-storage factory for adapter conformance.
+ */
+export class MemoryEntityStorageFactory {
+    #backend;
+    /**
+     * Creates a factory with a fresh backend, or deliberately shares `backend`.
+     *
+     * @param backend Supplies the backend to share between factory handles.
+     */
+    constructor(backend = new InMemoryStorageBackend()) {
+        this.#backend = backend;
+    }
+    /**
+     * Creates one scoped entity-storage handle.
+     *
+     * @param input Supplies the entity storage configuration.
+     * @returns Returns the scoped in-memory entity storage.
+     */
+    create(input) {
+        return new InMemoryEntityStorage(input, this.backend(input));
+    }
+    /**
+     * Opens the provider-owned maps used by an atomic in-memory commit.
+     *
+     * @param input Supplies the Entity storage configuration.
+     * @returns The compatible backend maps for this Entity scope.
+     */
+    backend(input) {
+        const tenant = TenantBoundary.of(input.context);
+        return InMemoryStorageBackend.bind(this.#backend, "entity", tenant, input.sourceType.typeName, () => ({
+            current: new Map(),
+            mutationQueue: new KeyedSerialQueue(),
+        }));
+    }
+}
+/**
+ * One scoped in-memory current/state/event storage handle.
+ */
+export class InMemoryEntityStorage {
+    // prettier-ignore
+    /**
+     * Provides current-record storage for this entity scope.
+     */
+    current;
+    /**
+     * Provides event-history storage for this entity scope.
+     */
+    events;
+    /**
+     * Provides state-history storage for this entity scope.
+     */
+    states;
+    /**
+     * Creates the current, event, and state storage adapters over `backend`.
+     *
+     * @param input Supplies the entity storage configuration.
+     * @param backend Supplies the scoped in-memory data structures.
+     */
+    constructor(input, backend) {
+        this.current = new MemoryEntityRecordStorage({
+            idKey: input.id.key,
+            idClone: input.id.clone,
+            columns: input.columns,
+            unpackId: input.id.unpack,
+            records: backend.current,
+            queue: backend.mutationQueue,
+        });
+        this.events =
+            input.eventHistoryStorage === undefined
+                ? disabledEventHistoryPort()
+                : new MemoryEntityEventHistory({
+                    id: input.id,
+                    records: input.eventHistoryStorage,
+                    queue: backend.mutationQueue,
+                });
+        this.states =
+            input.stateHistoryStorage === undefined
+                ? disabledStateHistoryPort()
+                : new InMemoryEntityHistory({
+                    id: input.id,
+                    records: input.stateHistoryStorage,
+                    stateSchema: input.stateSchema,
+                    queue: backend.mutationQueue,
+                });
+    }
+    /**
+     * Closes this independently owned provider handle without affecting siblings.
+     */
+    close() {
+        this.events.close();
+        this.states.close();
+    }
+}
+/**
+ * Identifies the single mutation sequence for one physical Entity storage scope.
+ */
+export const ENTITY_SCOPE_MUTATION_KEY = "entity-storage-scope";
+/**
+ * Captures immutable entity values and their durable identity.
+ */
+const EntitySnapshots = {
+    // prettier-ignore
+    /**
+     * Clones one entity ID with the platform structured-clone operation.
+     */
+    cloneId(id) {
+        return storageHost.structuredClone(id);
+    },
+    /**
+     * Copies an immutable latest-state record.
+     */
+    copyCurrent(record) {
+        return clone(EntityRecordSchema, record);
+    },
+};
+/**
+ * In-memory latest-state storage used by all entity families.
+ */
+export class MemoryEntityRecordStorage {
+    #idKey;
+    #idClone;
+    #records;
+    #unpackId;
+    #columns;
+    #queue;
+    /**
+     * Creates a current-record adapter over supplied or fresh record storage.
+     *
+     * @param input Supplies state, ID, column, and record-storage configuration.
+     */
+    constructor(input) {
+        this.#idKey = input.idKey;
+        this.#idClone = input.idClone ?? ((id) => EntitySnapshots.cloneId(id));
+        this.#records = input.records ?? new Map();
+        this.#unpackId = input.unpackId;
+        this.#columns = input.columns;
+        this.#queue = input.queue;
+    }
+    /**
+     * Reads the current record for one entity identifier.
+     *
+     * @param id Supplies the entity identifier to read.
+     * @returns Resolves to an independent current record, when present.
+     */
+    read(id) {
+        return Promise.resolve().then(() => {
+            const record = this.#records.get(this.#idKey(id));
+            return record === undefined ? undefined : EntitySnapshots.copyCurrent(record);
+        });
+    }
+    /**
+     * Stores an independent copy of one current entity record.
+     *
+     * @param record Supplies the current record to store.
+     * @returns Completes when the record is stored.
+     */
+    write(record) {
+        const write = () => {
+            const id = record.entityId === undefined ? undefined : this.#unpackId(record.entityId);
+            if (id === undefined)
+                throw new Error("Entity current record ID does not match its Entity ID schema.");
+            this.#records.set(this.#idKey(id), EntitySnapshots.copyCurrent(record));
+            return Promise.resolve();
+        };
+        return this.#queue === undefined
+            ? Promise.resolve().then(write)
+            : this.#queue.run(ENTITY_SCOPE_MUTATION_KEY, write);
+    }
+    /**
+     * Returns non-deleted current records matching the normalized plan.
+     *
+     * @param plan Supplies the normalized record-query plan.
+     * @returns Resolves to ordered matching current-record entries.
+     */
+    query(plan) {
+        return Promise.resolve().then(() => {
+            StorageQueryPolicy.validate(plan, {
+                comparisons: ["equal", "greaterThan", "lessThan", "greaterOrEqual", "lessOrEqual"],
+                features: ["either", "nested", "order", "mask", "limit"],
+            });
+            const limit = plan.candidateLimit ?? 10_000;
+            const candidates = [];
+            for (const record of this.#records.values()) {
+                if (record.lifecycleFlags?.deleted)
+                    continue;
+                candidates.push(record);
+                if (candidates.length > limit)
+                    break;
+            }
+            if (candidates.length > limit) {
+                throw new Error(`Storage query exceeded the candidate limit of ${String(limit)}.`);
+            }
+            const entries = candidates.flatMap((record) => {
+                const copied = EntitySnapshots.copyCurrent(record);
+                const id = copied.entityId === undefined ? undefined : this.#unpackId(copied.entityId);
+                if (id === undefined)
+                    throw new Error("Entity current record ID does not match its Entity ID schema.");
+                return copied.lifecycleFlags?.deleted
+                    ? []
+                    : [
+                        {
+                            id: this.#idClone(id),
+                            record: copied,
+                            columns: new Map([
+                                ...this.#columns.map((column) => [
+                                    column.name,
+                                    column.valueIn(copied),
+                                ]),
+                            ]),
+                        },
+                    ];
+            });
+            return StorageQueryEvaluator.evaluate(entries, plan);
+        });
+    }
+}
+/**
+ * In-memory immutable diagnostic event-history adapter.
+ */
+export class MemoryEntityEventHistory {
+    #id;
+    #maintenance;
+    #records;
+    #queue;
+    /**
+     * Creates an event-history adapter over grouped generated record storage.
+     *
+     * @param input Supplies the ID codec, generated record storage, and maintenance seam.
+     */
+    constructor(input) {
+        this.#id = input.id;
+        this.#maintenance = input.maintenance;
+        HistoryLimits.requireBatchSize(input.maintenance?.batchSize);
+        HistoryLimits.requirePageSize(input.maintenance?.pageSize);
+        this.#records = input.records;
+        this.#queue = input.queue ?? new KeyedSerialQueue();
+    }
+    /**
+     * Stores one immutable event-history record idempotently.
+     *
+     * @param record Supplies the event-history record to append.
+     * @returns Completes when the record is stored.
+     */
+    async append(record) {
+        this.requireOpen();
+        await this.#queue.run(ENTITY_SCOPE_MUTATION_KEY, async () => {
+            this.requireOpen();
+            const storedEvent = this.validatedEvent(record);
+            const id = this.eventIdIn(storedEvent);
+            const stored = await this.#records.read(id);
+            if (stored !== undefined &&
+                !CanonicalBytes.equal(toBinary(EventSchema, stored), toBinary(EventSchema, storedEvent))) {
+                throw new Error("Event-history retry has divergent content.");
+            }
+            if (stored === undefined)
+                await this.#records.write(storedEvent);
+        });
+    }
+    /**
+     * Reads recent events in descending producer-version order.
+     *
+     * @param entityId Supplies the entity identifier to inspect.
+     * @param depth Limits the number of events returned.
+     * @param startingFromVersion Excludes events at or after this producer version.
+     * @returns Resolves to immutable event snapshots.
+     */
+    async backward(entityId, depth, startingFromVersion) {
+        this.requireOpen();
+        HistoryLimits.requireDepth(depth);
+        const selected = [];
+        await HistoryPaging.scan(this.#records, {
+            filters: [{ column: "entity_id", value: this.#id.pack(entityId) }],
+        }, [
+            { field: "version", direction: "desc" },
+            { field: "created", direction: "desc" },
+            { field: "id", direction: "desc" },
+        ], this.pageSize(), (record, field) => field === "version" ? record.context?.version?.number : record.context?.timestamp, (page) => {
+            for (const { record } of page) {
+                const version = record.context?.version?.number;
+                if (startingFromVersion === undefined ||
+                    (version !== undefined && BigInt(version) < startingFromVersion)) {
+                    selected.push(record);
+                    if (selected.length === depth)
+                        return false;
+                }
+            }
+            return true;
+        });
+        return Object.freeze(selected
+            .sort((left, right) => (right.context?.version?.number ?? 0) - (left.context?.version?.number ?? 0) ||
+            HistoryOrdering.compareTime(right.context?.timestamp ?? create(TimestampSchema), left.context?.timestamp ?? create(TimestampSchema)) ||
+            CanonicalUtf8.compare(right.id?.value ?? "", left.id?.value ?? ""))
+            .slice(0, depth)
+            .map((record) => Object.freeze(clone(EventSchema, record))));
+    }
+    /**
+     * Deletes events created before the supplied timestamp in maintenance chunks.
+     *
+     * @param olderThan Specifies the exclusive event creation-time boundary.
+     * @returns Completes when maintenance finishes.
+     */
+    async truncate(olderThan) {
+        this.requireOpen();
+        await this.#queue.run(ENTITY_SCOPE_MUTATION_KEY, async () => {
+            await this.afterSelection();
+            await HistoryPaging.scan(this.#records, {}, [
+                { field: "created", direction: "asc" },
+                { field: "version", direction: "asc" },
+            ], this.pageSize(), (record, field) => field === "version" ? record.context?.version?.number : record.context?.timestamp, async (page) => {
+                const selected = page.filter((entry) => {
+                    const created = entry.record.context?.timestamp;
+                    return created !== undefined && HistoryOrdering.compareTime(created, olderThan) < 0;
+                });
+                await this.deleteEntries(selected);
+                return selected.length === page.length;
+            });
+        });
+    }
+    /**
+     * Closes this event-history adapter.
+     */
+    close() {
+        this.#records.close();
+    }
+    /**
+     * Returns whether this event-history adapter remains open.
+     *
+     * @returns Returns true while the adapter is open.
+     */
+    isOpen() {
+        return this.#records.isOpen();
+    }
+    eventIdIn(event) {
+        if (event.id === undefined || event.id.value.trim().length === 0) {
+            throw new Error("Event history requires an event ID.");
+        }
+        return event.id;
+    }
+    producerIdIn(event) {
+        const producerId = event.context?.producerId;
+        if (producerId === undefined)
+            throw new Error("Event history requires an EventContext producer ID.");
+        const entityId = this.#id.unpack(producerId);
+        if (entityId === undefined) {
+            throw new Error("Event-history producer ID does not match the configured Entity ID schema.");
+        }
+        return entityId;
+    }
+    validatedEvent(event) {
+        this.eventIdIn(event);
+        this.producerIdIn(event);
+        const context = event.context;
+        if (context?.version === undefined) {
+            throw new Error("Event history requires an EventContext version.");
+        }
+        if (context.timestamp === undefined) {
+            throw new Error("Event history requires an EventContext timestamp.");
+        }
+        const stored = clone(EventSchema, event);
+        if (stored.context !== undefined)
+            stored.context.enrichment = undefined;
+        return stored;
+    }
+    requireOpen() {
+        if (!this.isOpen())
+            throw new Error("Entity history storage is closed.");
+    }
+    async afterSelection() {
+        await this.#maintenance?.afterSelection?.();
+        this.requireOpen();
+    }
+    batchSize() {
+        return this.#maintenance?.batchSize ?? MAINTENANCE_BATCH_SIZE;
+    }
+    pageSize() {
+        return this.#maintenance?.pageSize ?? HISTORY_PAGE_SIZE;
+    }
+    async deleteEntries(entries) {
+        for (let start = 0; start < entries.length; start += this.batchSize()) {
+            for (const entry of entries.slice(start, start + this.batchSize()))
+                await this.#records.delete(entry.id);
+            await this.#maintenance?.onChunk?.();
+            this.requireOpen();
+        }
+    }
+}
+/**
+ * In-memory immutable, versioned state-history adapter.
+ */
+export class InMemoryEntityHistory {
+    #id;
+    #records;
+    #stateSchema;
+    #maintenance;
+    #queue;
+    /**
+     * Creates a state-history adapter over grouped generated record storage.
+     *
+     * @param input Supplies the generated record storage, ID codec, state schema, and maintenance seam.
+     */
+    constructor(input) {
+        this.#id = input.id;
+        this.#records = input.records;
+        this.#stateSchema = input.stateSchema;
+        this.#maintenance = input.maintenance;
+        this.#queue = input.queue ?? new KeyedSerialQueue();
+        HistoryLimits.requireBatchSize(input.maintenance?.batchSize);
+        HistoryLimits.requirePageSize(input.maintenance?.pageSize);
+    }
+    /**
+     * Stores one generated Entity record in the grouped state history.
+     *
+     * @param record Supplies the Entity record to append.
+     * @returns Completes when the record is stored.
+     */
+    async append(record) {
+        this.requireOpen();
+        this.validateRecord(record);
+        await this.#queue.run(ENTITY_SCOPE_MUTATION_KEY, async () => {
+            this.requireOpen();
+            const key = this.keyFor(record);
+            const stored = await this.#records.read(key);
+            if (stored !== undefined && !HistoryIdentity.sameEntityRecord(stored, record)) {
+                throw new Error("State-history retry has divergent content.");
+            }
+            if (stored === undefined)
+                await this.#records.write(record);
+        });
+    }
+    /**
+     * Reads recent state records in descending version and creation-time order.
+     *
+     * @param entityId Supplies the entity identifier to inspect.
+     * @param depth Limits the number of state records returned.
+     * @param startingFromVersion Excludes records at or after this version.
+     * @returns Resolves to cloned generated Entity records.
+     */
+    async backward(entityId, depth, startingFromVersion) {
+        this.requireOpen();
+        HistoryLimits.requireDepth(depth);
+        const selected = [];
+        await HistoryPaging.scan(this.#records, {
+            filters: [{ column: "entity_id", value: this.#id.pack(entityId) }],
+        }, [
+            { field: "version", direction: "desc" },
+            { field: "created", direction: "desc" },
+        ], this.pageSize(), (record, field) => (field === "version" ? record.version?.number : record.version?.timestamp), (page) => {
+            for (const { record } of page) {
+                const version = record.version?.number;
+                if (startingFromVersion === undefined ||
+                    version === undefined ||
+                    BigInt(version) < startingFromVersion) {
+                    selected.push(record);
+                    if (selected.length === depth)
+                        return false;
+                }
+            }
+            return true;
+        });
+        return Object.freeze(selected.map((record) => Object.freeze(clone(EntityRecordSchema, record))));
+    }
+    /**
+     * Reads the latest retained state at or before a timestamp.
+     *
+     * @param entityId Supplies the entity identifier to inspect.
+     * @param time Specifies the inclusive state creation-time boundary.
+     * @returns Resolves to a cloned state, when a compatible record is retained.
+     */
+    async stateAt(entityId, time) {
+        this.requireOpen();
+        let selected;
+        await HistoryPaging.scan(this.#records, {
+            filters: [{ column: "entity_id", value: this.#id.pack(entityId) }],
+        }, [
+            { field: "created", direction: "desc" },
+            { field: "version", direction: "desc" },
+        ], this.pageSize(), (record, field) => (field === "version" ? record.version?.number : record.version?.timestamp), (page) => {
+            selected = page
+                .map((entry) => entry.record)
+                .find((candidate) => {
+                const created = candidate.version?.timestamp;
+                return created !== undefined && HistoryOrdering.compareTime(created, time) <= 0;
+            });
+            return selected === undefined;
+        });
+        return selected === undefined ? undefined : this.unpackState(selected);
+    }
+    /**
+     * Deletes all but the requested number of newest records for one Entity.
+     *
+     * @param entityId Supplies the entity identifier to trim.
+     * @param keepMostRecent Specifies how many newest records to retain.
+     * @returns Completes when bounded deletion chunks finish.
+     */
+    async trim(entityId, keepMostRecent) {
+        this.requireOpen();
+        if (!Number.isSafeInteger(keepMostRecent) || keepMostRecent < 0) {
+            throw new Error("State-history trim count must be a non-negative safe integer.");
+        }
+        await this.#queue.run(ENTITY_SCOPE_MUTATION_KEY, async () => {
+            let skipped = 0;
+            await this.afterSelection();
+            await HistoryPaging.scan(this.#records, { filters: [{ column: "entity_id", value: this.#id.pack(entityId) }] }, [
+                { field: "version", direction: "desc" },
+                { field: "created", direction: "desc" },
+            ], this.pageSize(), (record, field) => field === "version" ? record.version?.number : record.version?.timestamp, async (page) => {
+                const selected = page.slice(Math.max(keepMostRecent - skipped, 0));
+                skipped += page.length;
+                await this.deleteEntries(selected);
+                return true;
+            });
+        });
+    }
+    /**
+     * Deletes records created before the supplied timestamp.
+     *
+     * @param olderThan Specifies the exclusive state creation-time boundary.
+     * @returns Completes when bounded deletion chunks finish.
+     */
+    async truncate(olderThan) {
+        this.requireOpen();
+        await this.#queue.run(ENTITY_SCOPE_MUTATION_KEY, async () => {
+            await this.afterSelection();
+            await HistoryPaging.scan(this.#records, {}, [
+                { field: "created", direction: "asc" },
+                { field: "version", direction: "asc" },
+            ], this.pageSize(), (record, field) => field === "version" ? record.version?.number : record.version?.timestamp, async (page) => {
+                const selected = page.filter((entry) => {
+                    const created = entry.record.version?.timestamp;
+                    return created !== undefined && HistoryOrdering.compareTime(created, olderThan) < 0;
+                });
+                await this.deleteEntries(selected);
+                return selected.length === page.length;
+            });
+        });
+    }
+    /**
+     * Closes the grouped record-storage handle.
+     */
+    close() {
+        this.#records.close();
+    }
+    /**
+     * Returns whether the grouped record-storage handle remains open.
+     *
+     * @returns Returns true while the adapter is open.
+     */
+    isOpen() {
+        return this.#records.isOpen();
+    }
+    async deleteEntries(entries) {
+        for (let start = 0; start < entries.length; start += this.batchSize()) {
+            for (const entry of entries.slice(start, start + this.batchSize())) {
+                await this.#records.delete(entry.id);
+            }
+            await this.afterMaintenanceChunk();
+        }
+    }
+    keyFor(record) {
+        if (record.entityId === undefined || record.version === undefined) {
+            throw new Error("State history requires EntityRecord.entityId and EntityRecord.version.");
+        }
+        return create(EntityStateKeySchema, {
+            entityId: record.entityId,
+            version: record.version.number,
+        });
+    }
+    entityIdIn(record) {
+        if (record.entityId === undefined) {
+            throw new Error("State history requires EntityRecord.entityId.");
+        }
+        const entityId = this.#id.unpack(record.entityId);
+        if (entityId === undefined) {
+            throw new Error("State-history record ID does not match the configured Entity ID schema.");
+        }
+        return entityId;
+    }
+    validateRecord(record) {
+        this.entityIdIn(record);
+        if (record.version?.timestamp === undefined) {
+            throw new Error("State history requires EntityRecord.version and EntityRecord.version.timestamp.");
+        }
+        this.unpackState(record);
+    }
+    unpackState(record) {
+        const state = record.state;
+        if (!state?.typeUrl.endsWith(`/${this.#stateSchema.typeName}`)) {
+            throw new Error("State-history record state does not match the configured Entity state schema.");
+        }
+        return Object.freeze(fromBinary(this.#stateSchema, state.value));
+    }
+    requireOpen() {
+        if (!this.isOpen())
+            throw new Error("Entity history storage is closed.");
+    }
+    async afterSelection() {
+        await this.#maintenance?.afterSelection?.();
+        this.requireOpen();
+    }
+    async afterMaintenanceChunk() {
+        await this.#maintenance?.onChunk?.();
+        this.requireOpen();
+    }
+    batchSize() {
+        return this.#maintenance?.batchSize ?? MAINTENANCE_BATCH_SIZE;
+    }
+    pageSize() {
+        return this.#maintenance?.pageSize ?? HISTORY_PAGE_SIZE;
+    }
+}
+/**
+ * Async FIFO mutexes shared by all history handles for one in-memory backend.
+ */
+export class KeyedSerialQueue {
+    #tails = new Map();
+    /**
+     * Queues an operation after earlier operations with the same key finish.
+     *
+     * @param key Identifies the serialized operation sequence.
+     * @param operation Supplies the operation to run.
+     * @returns Resolves to the operation result.
+     */
+    async run(key, operation) {
+        const previous = this.#tails.get(key);
+        let release;
+        const tail = new Promise((resolve) => {
+            release = resolve;
+        });
+        this.#tails.set(key, tail);
+        if (previous !== undefined)
+            await previous;
+        try {
+            return await operation();
+        }
+        finally {
+            release();
+            if (this.#tails.get(key) === tail)
+                this.#tails.delete(key);
+        }
+    }
+}
+/**
+ * Orders history records by chronology, version, and stable keys.
+ */
+const HistoryOrdering = {
+    // prettier-ignore
+    /**
+     * Compares timestamps by seconds and nanos.
+     */
+    compareTime(left, right) {
+        return Number(left.seconds - right.seconds) || left.nanos - right.nanos;
+    },
+};
+/**
+ * Traverses finite RecordStorage windows with an exact stable keyset continuation.
+ */
+const HistoryPaging = {
+    async scan(records, query, sort, pageSize, valueIn, visit) {
+        let after;
+        do {
+            const page = await records.queryEntries({
+                ...query,
+                sort,
+                limit: pageSize,
+                ...(after === undefined ? {} : { after }),
+            });
+            const last = page.at(-1);
+            after =
+                last === undefined
+                    ? undefined
+                    : {
+                        id: last.id,
+                        values: sort.map((order) => ({
+                            field: order.field,
+                            value: order.field === "id" ? last.id : valueIn(last.record, order.field),
+                        })),
+                    };
+            if (!(await visit(page)) || page.length < pageSize)
+                return;
+        } while (after !== undefined);
+    },
+};
+/**
+ * Compares generated Entity records by durable binary content.
+ */
+const HistoryIdentity = {
+    // prettier-ignore
+    /**
+     * Determines whether two generated Entity records have identical binary content.
+     */
+    sameEntityRecord(left, right) {
+        return CanonicalBytes.equal(toBinary(EntityRecordSchema, left), toBinary(EntityRecordSchema, right));
+    },
+};
+/**
+ * Validates bounded history requests.
+ */
+const HistoryLimits = {
+    requireDepth(depth) {
+        if (!Number.isSafeInteger(depth) || depth <= 0) {
+            throw new Error("History depth must be a positive safe integer.");
+        }
+    },
+    requireBatchSize(batchSize) {
+        if (batchSize !== undefined && (!Number.isSafeInteger(batchSize) || batchSize <= 0)) {
+            throw new Error("In-memory maintenance batch size must be a positive safe integer.");
+        }
+    },
+    requirePageSize(pageSize) {
+        if (pageSize !== undefined && (!Number.isSafeInteger(pageSize) || pageSize <= 0)) {
+            throw new Error("In-memory history page size must be a positive safe integer.");
+        }
+    },
+};
+const MAINTENANCE_BATCH_SIZE = 128;
+const HISTORY_PAGE_SIZE = 10_000;
+/**
+ * Orders canonical UTF-8 values and compares durable bytes.
+ */
+const CanonicalBytes = {
+    // prettier-ignore
+    /**
+     * Compares two durable byte sequences.
+     */
+    equal(left, right) {
+        return left.length === right.length && left.every((value, index) => value === right[index]);
+    },
+};
+//# sourceMappingURL=in-memory-entity-history.js.map