@spine-event-engine/storage 2.0.0-snapshot.23 → 2.0.0-snapshot.24

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

@@ -11,430 +11,298 @@
  * or implied. See the License for the specific language governing permissions and limitations under
  * the License.
  */
-import { clone } from "@bufbuild/protobuf";
+import { toBinary } from "@bufbuild/protobuf";
 import { EventSchema } from "@spine-event-engine/proto";
 import { EntityRecordSchema } from "@spine-event-engine/proto/generated/spine/server/entity/entity_pb.js";
-import { eventStoreAccess, eventStoreRecordSpec } from "../event/event-store.js";
+import { eventStoreRecordSpec } from "../event/event-store.js";
 import { eventHistorySpec, stateHistorySpec } from "../entity/entity-history-record-spec.js";
+import { EntityCommitSnapshots, } from "../internal/entity-commit.js";
 import { TenantBoundary } from "../internal/tenancy.js";
-import { InMemoryEntityStorage, KeyedSerialQueue, MemoryEntityStorageFactory, ENTITY_SCOPE_MUTATION_KEY, } from "./in-memory-entity-history.js";
+import { MemoryEntityStorageFactory, ENTITY_SCOPE_MUTATION_KEY, } from "./in-memory-entity-history.js";
 import { InMemoryRecordStorage } from "./in-memory-record-storage.js";
 import { TenantRecords } from "./tenant-records.js";
 /**
- * Implements provider Entity commits for one shared in-memory backend.
+ * Writes in-memory Entity records in order and retains a completed prefix.
  */
 export class MemoryEntityCommitStorage {
-    #entities;
-    #factory;
-    #openRecords;
-    #input;
+    entities;
+    openRecords;
+    input;
+    /**
+     * Tenant boundary selected by this handle.
+     */
     #tenantKey;
+    /**
+  
+     * Whether this handle uses multitenant storage.
+  
+     */
     #multitenant;
+    /**
+  
+     * Whether this handle accepts commits.
+  
+     */
     #open = true;
     /**
-     * Creates a commit handle bound to one Entity source type.
+     * Creates one source- and tenant-bound commit handle.
      *
-     * @param entities Opens the matching current Entity storage.
-     * @param factory Provides the Event Store coordination lock.
-     * @param openRecords Opens exact generic-record backing slices.
-     * @param input Defines the Entity storage source type.
+     * @param entities Opens current Entity storage.
+     * @param openRecords Opens generated history and Event record slices.
+     * @param input Captures the Entity source and tenant boundary.
      */
-    constructor(entities, factory, openRecords, input) {
-        this.#entities = entities;
-        this.#factory = factory;
-        this.#openRecords = openRecords;
-        this.#input = input;
+    constructor(entities, openRecords, input) {
+        this.entities = entities;
+        this.openRecords = openRecords;
+        this.input = input;
         this.#tenantKey = TenantBoundary.of(input.context).key;
         this.#multitenant = input.context.multitenant;
     }
     /**
-     * Applies one fully preflighted in-memory Entity commit.
+     * Writes history, diagnostics, delivery Events, then current state.
      *
      * @typeParam I Entity identifier type.
      * @typeParam S Entity state type.
-     * @param input Defines the current record, retained histories, and delivery events.
-     * @returns Completion after the in-memory commit.
+     * @param input Supplies the proposed mutation.
+     * @returns Completion after every record has been stored.
      */
     commit(input) {
-        this.#requireOpen();
-        this.#requireCompatible(input);
-        const tenant = TenantBoundary.of(input.context);
-        const context = tenant.tenantId === undefined
-            ? { name: input.context.name, multitenant: false }
-            : { name: input.context.name, multitenant: true, tenantId: tenant.tenantId };
-        const snapshot = {
-            ...input,
-            context,
-            entity: { ...input.entity, context },
-            entityId: input.entity.id.clone(input.entityId),
-            next: clone(EntityRecordSchema, input.next),
-            ...(input.states === undefined
-                ? {}
-                : { states: input.states.map((record) => clone(EntityRecordSchema, record)) }),
-            ...(input.diagnostics === undefined
-                ? {}
-                : { diagnostics: input.diagnostics.map((event) => clone(EventSchema, event)) }),
-            ...(input.events === undefined
-                ? {}
-                : { events: input.events.map((event) => clone(EventSchema, event)) }),
-        };
-        const backend = this.#entities.backend(snapshot.entity);
-        const work = () => backend.mutationQueue.run(ENTITY_SCOPE_MUTATION_KEY, () => this.#commit(snapshot, backend));
-        return snapshot.events === undefined || snapshot.events.length === 0
-            ? work()
-            : eventStoreAccess.withLock(this.#factory, snapshot.context, work);
+        this.requireOpen();
+        this.requireCompatible(input);
+        return this.apply(EntityCommitSnapshots.capture(input));
     }
     /**
-     * Applies an Agent completion only while the current Entity Version matches.
+     * Commits one Agent transition under the Entity scope queue and Version fence.
      *
-     * @typeParam I Typed Entity identifier.
-     * @typeParam S Generated Entity state.
-     * @param entity Existing Entity layout.
-     * @param entityId Typed Entity identifier.
-     * @param expectedVersion Version observed before Agent handlers ran.
-     * @param input Current-state mutation, absent for a no-op.
-     * @param extra Staged execution and history publication with restoration.
-     * @returns Completion after conditional Entity and execution publication.
+     * @typeParam I Entity identifier type.
+     * @typeParam S Entity state type.
+     * @param entity Configured Entity storage layout.
+     * @param entityId Typed Agent Entity identifier.
+     * @param expectedVersion Version read before the Agent handler ran.
+     * @param input Optional changed Entity state and history.
+     * @param extra Applies or restores the Agent execution record with the Entity state.
+     * @returns Completion after the fenced transition is stored.
      */
-    commitConditional(entity, entityId, expectedVersion, input, extra) {
-        this.#requireOpen();
-        const backend = this.#entities.backend(entity);
-        const work = () => backend.mutationQueue.run(ENTITY_SCOPE_MUTATION_KEY, async () => {
-            this.#checkCurrentVersion(backend, entity.id.key(entityId), expectedVersion);
-            if (input === undefined) {
-                try {
-                    extra.apply();
-                }
-                catch (error) {
-                    extra.restore();
-                    throw error;
-                }
-                return;
-            }
-            await this.#commit(input, backend, extra);
-        });
-        return input?.events?.length
-            ? eventStoreAccess.withLock(this.#factory, entity.context, work)
-            : work();
+    commitAgentConditional(entity, entityId, expectedVersion, input, extra) {
+        this.requireOpen();
+        const backend = this.entities.backend(entity);
+        const key = entity.id.key(entityId);
+        const snapshot = input === undefined ? undefined : EntityCommitSnapshots.capture(input);
+        if (snapshot !== undefined) {
+            this.requireCompatible(snapshot);
+            this.requireEnabledHistories(snapshot);
+            this.validateRows(snapshot);
+            if (snapshot.diagnostics?.length || snapshot.events?.length)
+                throw new Error("Agent completion cannot save delivery Events as Entity commit obligations.");
+        }
+        return backend.mutationQueue.run(ENTITY_SCOPE_MUTATION_KEY, () => this.applyAgentConditional(entity, backend, key, expectedVersion, snapshot, extra));
     }
     /**
-     * Checks the current Version while the Entity mutation queue is held.
+     * Applies one prepared Agent transition and restores affected rows on failure.
+     *
+     * @typeParam I Entity identifier type.
+     * @typeParam S Entity state type.
+     * @param entity Configured Entity storage layout.
+     * @param backend Shared current records for this Entity scope.
+     * @param key Canonical Entity ID key.
+     * @param expectedVersion Version read before handler execution.
+     * @param snapshot Optional captured Entity state transition.
+     * @param extra Applies or restores the Agent execution record.
+     * @returns Completion after the transition is stored.
      */
-    #checkCurrentVersion(backend, key, expected) {
-        const current = backend.current.get(key);
-        const actual = current?.version?.number ?? 0;
-        if (actual !== expected)
+    applyAgentConditional(entity, backend, key, expectedVersion, snapshot, extra) {
+        const prior = backend.current.get(key);
+        if ((prior?.version?.number ?? 0) !== expectedVersion)
             throw new Error("Agent execution initial Entity Version is no longer current.");
+        const layout = snapshot?.states?.length ? stateHistorySpec(entity.stateSchema) : undefined;
+        const states = layout === undefined
+            ? undefined
+            : this.openRecords(entity.context, layout.spec, layout.group);
+        const prepared = layout === undefined
+            ? []
+            : (snapshot?.states ?? []).map((record) => layout.spec.materialize(record));
+        const priorStates = prepared.map((record) => states?.capture(record.id));
+        try {
+            this.writeAgentStates(states, prepared);
+            if (snapshot !== undefined)
+                backend.current.set(key, snapshot.next);
+            extra.apply();
+        }
+        catch (error) {
+            extra.restore();
+            if (prior === undefined)
+                backend.current.delete(key);
+            else
+                backend.current.set(key, prior);
+            for (const priorState of priorStates)
+                if (priorState !== undefined)
+                    states?.apply(priorState);
+            throw error;
+        }
+        return Promise.resolve();
+    }
+    /**
+     * Writes immutable Agent state history after checking each Version slot.
+     *
+     * @param states State-history records when that family is configured.
+     * @param prepared Materialized state rows from the captured transition.
+     */
+    writeAgentStates(states, prepared) {
+        if (states === undefined)
+            return;
+        for (const record of prepared) {
+            const existing = states.read(record.id);
+            if (existing !== undefined &&
+                !this.sameBytes(toBinary(EntityRecordSchema, existing), toBinary(EntityRecordSchema, record.record)))
+                throw new Error("Agent state history collides with another Version.");
+            states.write(record);
+        }
     }
     /**
-     * Closes this commit handle without closing sibling handles.
+     * Closes this handle to new commits.
      */
     close() {
         this.#open = false;
     }
     /**
-     * Prepares and publishes one affected-record Entity commit under its existing queue.
+     * Applies one captured mutation without cross-record compensation.
      *
      * @typeParam I Entity identifier type.
      * @typeParam S Entity state type.
-     * @param input Supplies current and immutable records.
-     * @param liveBackend Supplies the live current-record map and queue.
+     * @param input Supplies immutable record snapshots.
+     * @returns Completion after every requested record write.
      */
-    async #commit(input, liveBackend, extra) {
-        const stage = this.stage(input, liveBackend);
+    async apply(input) {
+        this.requireEnabledHistories(input);
+        this.validateRows(input);
+        const [entity, stateStorage, diagnosticStorage, eventStorage] = this.openCommit(input);
         try {
-            await this.#writeStage(input, stage);
-            this.#publish(stage, liveBackend, extra);
+            for (const state of input.states ?? [])
+                await entity.states.append(state);
+            for (const diagnostic of input.diagnostics ?? [])
+                await entity.events.append(diagnostic);
+            for (const event of input.events ?? []) {
+                if (event.id === undefined || eventStorage === undefined)
+                    throw new Error("Entity commit requires delivery-event IDs.");
+                await this.appendEvent(eventStorage, event.id, event);
+            }
+            await entity.current.write(input.next);
         }
         finally {
-            stage.entity.close();
+            entity.close();
+            stateStorage?.close();
+            diagnosticStorage?.close();
+            eventStorage?.close();
         }
     }
     /**
-     * Opens only record families used by one commit.
+     * Opens the record families needed by one captured mutation.
      *
      * @typeParam I Entity identifier type.
      * @typeParam S Entity state type.
-     * @param input Supplies configured histories and delivery Events.
-     * @returns Live affected record families and their layouts.
+     * @param input Supplies requested history and delivery records.
+     * @returns Entity and record handles to close after the mutation.
      */
-    live(input) {
-        this.#requireEnabledHistories(input);
-        const stateLayout = input.states?.length
-            ? stateHistorySpec(input.entity.stateSchema)
-            : undefined;
-        const eventLayout = input.diagnostics?.length
+    openCommit(input) {
+        const states = input.states?.length ? stateHistorySpec(input.entity.stateSchema) : undefined;
+        const diagnostics = input.diagnostics?.length
             ? eventHistorySpec(input.entity.stateSchema)
             : undefined;
-        const states = stateLayout === undefined
+        const stateStorage = states === undefined
             ? undefined
-            : this.#openRecords(input.context, stateLayout.spec, stateLayout.group);
-        const diagnostics = eventLayout === undefined
+            : new InMemoryRecordStorage(input.context, states.spec, () => this.openRecords(input.context, states.spec, states.group));
+        const diagnosticStorage = diagnostics === undefined
             ? undefined
-            : this.#openRecords(input.context, eventLayout.spec, eventLayout.group);
-        const events = input.events?.length
-            ? this.#openRecords(input.context, eventStoreRecordSpec)
+            : new InMemoryRecordStorage(input.context, diagnostics.spec, () => this.openRecords(input.context, diagnostics.spec, diagnostics.group));
+        const eventStorage = input.events?.length
+            ? new InMemoryRecordStorage(input.context, eventStoreRecordSpec, () => this.openRecords(input.context, eventStoreRecordSpec))
             : undefined;
-        return { stateLayout, eventLayout, states, diagnostics, events };
+        const entityInput = { ...input.entity };
+        delete entityInput.stateHistoryStorage;
+        delete entityInput.eventHistoryStorage;
+        const entity = this.entities.create({
+            ...entityInput,
+            ...(stateStorage === undefined ? {} : { stateHistoryStorage: stateStorage }),
+            ...(diagnosticStorage === undefined ? {} : { eventHistoryStorage: diagnosticStorage }),
+        });
+        return [entity, stateStorage, diagnosticStorage, eventStorage];
     }
     /**
-     * Captures affected rows and creates isolated adapters for preparation.
+     * Writes one immutable delivery Event or accepts an identical retry.
      *
-     * @typeParam I Entity identifier type.
-     * @typeParam S Entity state type.
-     * @param input Supplies the proposed record changes.
-     * @param backend Supplies the live current-record map.
-     * @returns The prepared affected-record workspace.
+     * @param storage Supplies atomic single-record insertion.
+     * @param id Identifies the delivery Event.
+     * @param event Supplies the captured Event.
+     * @returns Completion after an identical Event is stored.
      */
-    stage(input, backend) {
-        const live = this.live(input);
-        const key = input.entity.id.key(input.entityId);
-        const previous = backend.current.get(key);
-        const ids = this.#ids(input, live);
-        const stagedBackend = {
-            current: new Map(previous === undefined ? [] : [[key, previous]]),
-            mutationQueue: new KeyedSerialQueue(),
-        };
-        const stagedStates = InMemoryCommitValues.stage(live.states, ids.stateIds);
-        const stagedDiagnostics = InMemoryCommitValues.stage(live.diagnostics, ids.diagnosticIds);
-        const stagedEvents = InMemoryCommitValues.stage(live.events, ids.deliveryIds);
-        const entity = new InMemoryEntityStorage(this.#stagedInput(input.entity, live.stateLayout, stagedStates, live.eventLayout, stagedDiagnostics), stagedBackend);
-        return {
-            live,
-            key,
-            previous,
-            ...ids,
-            stagedBackend,
-            stagedStates,
-            stagedDiagnostics,
-            stagedEvents,
-            entity,
-        };
+    async appendEvent(storage, id, event) {
+        if (await storage.compareAndSet(id, undefined, event))
+            return;
+        const prior = await storage.read(id);
+        if (prior === undefined ||
+            !this.sameBytes(toBinary(EventSchema, prior), toBinary(EventSchema, event))) {
+            throw new Error("Entity commit requires unique delivery-event IDs.");
+        }
     }
     /**
-     * Materializes the storage identities and delivery rows before live application.
+     * Compares two stored Protobuf byte sequences.
      *
-     * @typeParam I Entity identifier type.
-     * @typeParam S Entity state type.
-     * @param input Supplies the changed records.
-     * @param live Supplies generated history layouts.
-     * @returns Affected keys and cloned delivery rows.
+     * @param left First byte sequence.
+     * @param right Second byte sequence.
+     * @returns Whether every byte matches.
      */
-    #ids(input, live) {
-        const stateIds = (input.states ?? []).map((record) => {
-            const layout = live.stateLayout;
-            if (layout === undefined)
-                throw new TypeError("Cannot read properties of undefined (reading 'spec')");
-            return layout.spec.materialize(record).id;
-        });
-        const diagnosticIds = (input.diagnostics ?? []).map((event) => {
-            const layout = live.eventLayout;
-            if (layout === undefined)
-                throw new TypeError("Cannot read properties of undefined (reading 'spec')");
-            return layout.spec.materialize(event).id;
-        });
-        const materialized = (input.events ?? []).map((event) => eventStoreRecordSpec.materialize(clone(eventStoreRecordSpec.recordType, event)));
-        const deliveryIds = materialized.map((record) => record.id);
-        return { stateIds, diagnosticIds, materialized, deliveryIds };
+    sameBytes(left, right) {
+        return left.length === right.length && left.every((value, index) => value === right[index]);
     }
     /**
-     * Validates and writes only staged records before any live change.
+     * Validates current identity and duplicate delivery IDs before writes.
      *
      * @typeParam I Entity identifier type.
      * @typeParam S Entity state type.
-     * @param input Supplies the proposed record changes.
-     * @param stage Supplies affected-record adapters and materialized Events.
+     * @param input Supplies the captured mutation.
      */
-    async #writeStage(input, stage) {
+    validateRows(input) {
         const nextId = input.next.entityId === undefined ? undefined : input.entity.id.unpack(input.next.entityId);
-        if (nextId === undefined || input.entity.id.key(nextId) !== stage.key)
+        if (nextId === undefined || input.entity.id.key(nextId) !== input.entity.id.key(input.entityId))
             throw new Error("Entity commit current record identifies another Entity.");
-        if (new Set(stage.deliveryIds.map((id) => id.value)).size !== stage.deliveryIds.length ||
-            stage.deliveryIds.some((id) => stage.stagedEvents?.read(id) !== undefined))
+        const ids = (input.events ?? []).map((event) => event.id?.value);
+        if (ids.some((id) => id === undefined || id.trim() === "") || new Set(ids).size !== ids.length)
             throw new Error("Entity commit requires unique delivery-event IDs.");
-        await stage.entity.current.write(input.next);
-        for (const state of input.states ?? [])
-            await stage.entity.states.append(state);
-        for (const diagnostic of input.diagnostics ?? [])
-            await stage.entity.events.append(diagnostic);
-        stage.stagedEvents?.writeAll(stage.materialized);
-    }
-    /**
-     * Applies prepared rows synchronously and restores affected entries on failure.
-     *
-     * @param stage Supplies the complete affected-record preparation.
-     * @param backend Supplies the live current-record map.
-     */
-    #publish(stage, backend, extra) {
-        const changes = [
-            ...InMemoryCommitValues.changes(stage.live.states, stage.stagedStates, stage.stateIds),
-            ...InMemoryCommitValues.changes(stage.live.diagnostics, stage.stagedDiagnostics, stage.diagnosticIds),
-            ...InMemoryCommitValues.changes(stage.live.events, stage.stagedEvents, stage.deliveryIds),
-        ];
-        const next = stage.stagedBackend.current.get(stage.key);
-        try {
-            for (const change of changes)
-                change.apply();
-            backend.current.set(stage.key, next);
-            extra?.apply();
-        }
-        catch (error) {
-            extra?.restore();
-            if (stage.previous === undefined)
-                backend.current.delete(stage.key);
-            else
-                backend.current.set(stage.key, stage.previous);
-            for (const change of changes.reverse())
-                change.restore();
-            throw error;
-        }
-    }
-    /**
-     * Connects affected staged history slices to the existing Entity adapters.
-     *
-     * @typeParam I Entity identifier type.
-     * @typeParam S Entity state type.
-     * @param entity Supplies the Entity storage layout.
-     * @param stateLayout Supplies the enabled state-history layout.
-     * @param states Supplies the affected staged state rows.
-     * @param eventLayout Supplies the enabled diagnostic-history layout.
-     * @param diagnostics Supplies the affected staged diagnostic rows.
-     * @returns The staged Entity storage layout.
-     */
-    #stagedInput(entity, stateLayout, states, eventLayout, diagnostics) {
-        const base = { ...entity };
-        delete base.stateHistoryStorage;
-        delete base.eventHistoryStorage;
-        return {
-            ...base,
-            ...(stateLayout === undefined || states === undefined
-                ? {}
-                : {
-                    stateHistoryStorage: new InMemoryRecordStorage(entity.context, stateLayout.spec, () => states),
-                }),
-            ...(eventLayout === undefined || diagnostics === undefined
-                ? {}
-                : {
-                    eventHistoryStorage: new InMemoryRecordStorage(entity.context, eventLayout.spec, () => diagnostics),
-                }),
-        };
     }
     /**
-     * Rejects history rows when their corresponding history is disabled.
+     * Rejects disabled history families.
      *
      * @typeParam I Entity identifier type.
      * @typeParam S Entity state type.
-     * @param input Supplies the requested histories.
+     * @param input Supplies the proposed histories.
      */
-    #requireEnabledHistories(input) {
-        if ((input.states?.length ?? 0) > 0 && !input.entity.stateHistory) {
+    requireEnabledHistories(input) {
+        if ((input.states?.length ?? 0) > 0 && !input.entity.stateHistory)
             throw new Error("Entity commit cannot append state history when it is disabled.");
-        }
-        if ((input.diagnostics?.length ?? 0) > 0 && !input.entity.eventHistory) {
+        if ((input.diagnostics?.length ?? 0) > 0 && !input.entity.eventHistory)
             throw new Error("Entity commit cannot append event history when it is disabled.");
-        }
     }
     /**
-     * Checks the tenant and Entity source type captured by this handle.
+     * Checks the tenant and source captured by this handle.
      *
      * @typeParam I Entity identifier type.
      * @typeParam S Entity state type.
      * @param input Supplies the requested scope.
      */
-    #requireCompatible(input) {
+    requireCompatible(input) {
         if (input.context.multitenant !== this.#multitenant ||
             TenantBoundary.of(input.context).key !== this.#tenantKey ||
             TenantBoundary.of(input.entity.context).key !== this.#tenantKey ||
-            input.entity.sourceType.typeName !== this.#input.sourceType.typeName) {
+            input.entity.sourceType.typeName !== this.input.sourceType.typeName) {
             throw new Error("Entity commit handle cannot commit another Entity storage scope.");
         }
     }
     /**
      * Rejects commits after this handle closes.
      */
-    #requireOpen() {
+    requireOpen() {
         if (!this.#open)
             throw new Error("Entity commit storage is closed.");
     }
 }
-/**
- * Prepares only affected materialized rows for an in-memory commit.
- */
-const InMemoryCommitValues = Object.freeze({
-    /**
-     * Captures the affected live rows in an isolated tenant slice.
-     *
-     * @typeParam I Record identifier type.
-     * @typeParam R Record message type.
-     * @param live Supplies the live tenant slice when enabled.
-     * @param ids Identifies affected slots.
-     * @returns An isolated slice with only affected prior entries.
-     */
-    stage(live, ids) {
-        if (live === undefined)
-            return undefined;
-        const staged = new TenantRecords();
-        for (const id of ids)
-            staged.apply(live.capture(id));
-        return staged;
-    },
-    /**
-     * Builds synchronous apply and restore operations for affected slots.
-     *
-     * @typeParam I Record identifier type.
-     * @typeParam R Record message type.
-     * @param live Supplies the live tenant slice when enabled.
-     * @param staged Supplies fully prepared replacements.
-     * @param ids Identifies affected slots.
-     * @returns Operations that preserve complete prior entries and absence.
-     */
-    changes(live, staged, ids) {
-        if (live === undefined || staged === undefined)
-            return [];
-        const seen = new Set();
-        return ids.flatMap((id) => {
-            const prior = live.capture(id);
-            if (seen.has(prior.key))
-                return [];
-            seen.add(prior.key);
-            const prepared = staged.capture(id);
-            return [new MemoryCommitChange(live, prepared, prior)];
-        });
-    },
-});
-/**
- * Applies one affected materialized row and restores its complete prior slot.
- *
- * @typeParam I Record identifier type.
- * @typeParam R Record message type.
- */
-class MemoryCommitChange {
-    live;
-    prepared;
-    prior;
-    /**
-     * Captures the prepared and prior versions of one slot.
-     *
-     * @param live Supplies the affected tenant slice.
-     * @param prepared Supplies the replacement entry or absence.
-     * @param prior Supplies the complete prior entry or absence.
-     */
-    constructor(live, prepared, prior) {
-        this.live = live;
-        this.prepared = prepared;
-        this.prior = prior;
-    }
-    /**
-     * Applies the fully prepared materialized row.
-     */
-    apply() {
-        this.live.apply(this.prepared);
-    }
-    /**
-     * Restores the complete prior row or absence.
-     */
-    restore() {
-        this.live.apply(this.prior);
-    }
-}
 //# sourceMappingURL=in-memory-entity-commit.js.map