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

package/dist/postgres/entity-commit.js

@@ -11,62 +11,16 @@
  * or implied. See the License for the specific language governing permissions and limitations under
  * the License.
  */
-import { toBinary } from "@bufbuild/protobuf";
+import { clone, toBinary } from "@bufbuild/protobuf";
+import { AgentHistoryEntrySchema, } from "@spine-event-engine/proto/agent";
 import { EntityRecordSchema, } from "@spine-event-engine/proto/generated/spine/server/entity/entity_pb.js";
 import {} from "@spine-event-engine/storage";
-import { TenantBoundary, eventHistorySpec, eventStoreRecordSpec, stateHistorySpec, } from "@spine-event-engine/storage/provider";
-import { PostgresRollbackErrors, PostgresStorageOperationError, PostgresTransactionErrors, } from "./errors.js";
-import { PostgresRecordStorage, } from "./record-storage.js";
+import { TenantBoundary, AgentHistoryRecords, AgentModelPreferences, EntityCommitSnapshots, eventHistorySpec, eventStoreRecordSpec, EventStoreGroups, stateHistorySpec, } from "@spine-event-engine/storage/provider";
+import { AgentHistoryHash } from "./agent-history.js";
+import { PostgresStorageErrors, PostgresStorageOperationError } from "./errors.js";
+import { PostgresRecordStorage } from "./record-storage.js";
 /**
- * Acquires fresh clients for a complete Entity transaction and one safe retry.
- */
-class PostgresEntityCommitCoordinator {
-    lifecycle;
-    /**
-     * Creates a coordinator for one tenant-bound record lifecycle.
-     *
-     * @param lifecycle Acquires transaction clients for the selected database.
-     */
-    constructor(lifecycle) {
-        this.lifecycle = lifecycle;
-    }
-    /**
-     * Commits one complete Entity change with one serialization retry.
-     *
-     * @typeParam T Result returned by the transaction work.
-     * @param work Applies the Entity commit on an acquired client.
-     * @returns The committed work result.
-     */
-    async commit(work) {
-        for (let attempt = 0; attempt < 2; attempt += 1) {
-            const client = await this.lifecycle.acquire();
-            let discard;
-            try {
-                await client.query("BEGIN");
-                const result = await work(client);
-                await client.query("COMMIT");
-                return result;
-            }
-            catch (error) {
-                try {
-                    await client.query("ROLLBACK");
-                }
-                catch {
-                    discard = PostgresRollbackErrors.discard(error);
-                }
-                if (attempt === 0 && PostgresTransactionErrors.retryable(error))
-                    continue;
-                throw PostgresCommitErrors.operation(error);
-            }
-            finally {
-                client.release(discard);
-            }
-        }
-        throw new Error("Unreachable PostgreSQL Entity commit retry.");
-    }
-}
-/**
- * Opens and closes the exact record families participating in one commit.
+ * Stores current and optional record families across commits on one handle.
  *
  * @typeParam I Entity identifier type.
  * @typeParam S Entity state message type.
@@ -76,26 +30,81 @@ class PostgresCommitRecords {
     states;
     diagnostics;
     events;
+    history;
+    preferences;
     #handles;
     /**
-     * Opens the current record family and each enabled immutable family.
+     * Whether this record family is closed.
+     */
+    #closed = false;
+    /**
+     * Acquires the current record family for one Entity scope.
      *
-     * @param input Describes the Entity commit and enabled histories.
      * @param open Opens one record family.
+     * @param entity The Entity persistence contract.
+     */
+    constructor(entity, open) {
+        this.current = open(entity.recordSpec);
+        this.#handles = [this.current];
+    }
+    /**
+     * Acquires only missing requested families, rolling back a failed new group.
+     *
+     * @param input The captured Entity persistence input.
+     * @param open Opens a generated record family.
+     */
+    ensure(input, open) {
+        const acquired = [];
+        try {
+            const states = input.states?.length
+                ? (this.states ?? this.openState(input, open, acquired))
+                : undefined;
+            const diagnostics = input.diagnostics?.length
+                ? (this.diagnostics ?? this.openDiagnostic(input, open, acquired))
+                : undefined;
+            const events = input.events?.length
+                ? (this.events ?? this.openEvents(input, open, acquired))
+                : undefined;
+            this.states = states ?? this.states;
+            this.diagnostics = diagnostics ?? this.diagnostics;
+            this.events = events ?? this.events;
+            this.#handles.push(...acquired);
+        }
+        catch (error) {
+            const failures = this.closeGroup(acquired);
+            if (failures.length)
+                throw new AggregateError([error, ...failures], "PostgreSQL family acquisition failed.");
+            throw error;
+        }
+    }
+    /**
+     * Stores the two Agent record families, rolling back only failed acquisition.
+     * @param open Opens a private record family.
      */
-    constructor(input, open) {
-        const current = open(input.entity.recordSpec);
-        const handles = [current];
-        this.current = current.historyExecutor();
-        this.states = input.states?.length ? this.openState(input, open, handles) : undefined;
-        this.diagnostics = input.diagnostics?.length
-            ? this.openDiagnostic(input, open, handles)
-            : undefined;
-        this.events = input.events?.length ? this.openEvents(open, handles) : undefined;
-        this.#handles = handles;
+    ensureAgent(open) {
+        const acquired = [];
+        try {
+            const history = this.history ??
+                open(AgentHistoryRecords.spec((value) => AgentHistoryHash.value(value)), AgentHistoryRecords.group);
+            if (this.history === undefined)
+                acquired.push(history);
+            const preferences = this.preferences ??
+                open(AgentModelPreferences.spec((value) => AgentHistoryHash.value(value)), AgentModelPreferences.group);
+            if (this.preferences === undefined)
+                acquired.push(preferences);
+            this.history = history;
+            this.preferences = preferences;
+            this.#handles.push(...acquired);
+        }
+        catch (error) {
+            const failures = this.closeGroup(acquired);
+            if (failures.length)
+                throw new AggregateError([error, ...failures], "PostgreSQL Agent family acquisition failed.");
+            throw error;
+        }
     }
     /**
-     * Prepares every record family before the transaction begins.
+     * Prepares every record family before ordered writes begin.
      *
      * @returns Completion after all required tables are ready.
      */
@@ -104,51 +113,99 @@ class PostgresCommitRecords {
             await handle.prepare();
     }
     /**
-     * Closes every temporary record-family handle.
+     * Writes the fenced Entity mutation through the transaction's client.
+     *
+     * @param client Existing conditional-completion transaction client.
+     * @param snapshot Captured immutable Entity mutation.
+     * @param expectedVersion Version checked under the current-record lock.
+     * @returns Completion after current and history records are written.
+     */
+    async applyConditional(client, snapshot, expectedVersion) {
+        const current = await this.current
+            .historyExecutor()
+            .read(client, snapshot.entityId, "for-update");
+        if ((current?.version?.number ?? 0) !== expectedVersion)
+            throw new Error("Agent execution initial Entity Version is no longer current.");
+        for (const state of snapshot.states ?? [])
+            await this.states?.historyExecutor().appendImmutable(client, state);
+        for (const diagnostic of snapshot.diagnostics ?? [])
+            await this.diagnostics?.historyExecutor().appendImmutable(client, diagnostic);
+        for (const event of snapshot.events ?? [])
+            await this.events?.historyExecutor().appendImmutable(client, event);
+        if (!PostgresCommitValues.same(current, snapshot.next))
+            await this.current.historyExecutor().write(client, snapshot.next);
+    }
+    /**
+     * Closes every retained record-family handle.
      */
     close() {
-        for (const handle of this.#handles)
-            handle.close();
+        if (this.#closed)
+            return;
+        this.#closed = true;
+        const failures = this.closeGroup(this.#handles);
+        if (failures.length === 1)
+            throw failures[0];
+        if (failures.length)
+            throw new AggregateError(failures, "PostgreSQL commit records close failed.");
+    }
+    /**
+     * Closes every newly acquired handle and collects cleanup failures.
+     *
+     * @param handles The acquired record handles.
+     * @returns Cleanup failures from acquired handles.
+     */
+    closeGroup(handles) {
+        const failures = [];
+        for (const handle of handles) {
+            try {
+                handle.close();
+            }
+            catch (error) {
+                failures.push(error);
+            }
+        }
+        return failures;
     }
     /**
-     * Opens the Entity state-history record family.
+     * Acquires the Entity state-history record family.
      *
      * @param input Describes the Entity state schema.
      * @param open Opens one record family.
      * @param handles Collects handles that must close after the commit.
-     * @returns The state-history transaction executor.
+     * @returns The state-history record storage.
      */
     openState(input, open, handles) {
         const layout = stateHistorySpec(input.entity.stateSchema);
         const handle = open(layout.spec, layout.group);
         handles.push(handle);
-        return handle.historyExecutor();
+        return handle;
     }
     /**
-     * Opens the Entity diagnostic-event history record family.
+     * Acquires the Entity diagnostic-event history record family.
      *
      * @param input Describes the Entity state schema.
      * @param open Opens one record family.
      * @param handles Collects handles that must close after the commit.
-     * @returns The diagnostic-history transaction executor.
+     * @returns The diagnostic-history record storage.
      */
     openDiagnostic(input, open, handles) {
         const layout = eventHistorySpec(input.entity.stateSchema);
         const handle = open(layout.spec, layout.group);
         handles.push(handle);
-        return handle.historyExecutor();
+        return handle;
     }
     /**
-     * Opens the shared event-store record family.
+     * Acquires the shared event-store record family.
      *
+     * @param input Supplies the context and Event family.
      * @param open Opens one record family.
      * @param handles Collects handles that must close after the commit.
-     * @returns The event-store transaction executor.
+     * @returns The event-store record storage.
      */
-    openEvents(open, handles) {
-        const handle = open(eventStoreRecordSpec);
+    openEvents(input, open, handles) {
+        const handle = open(eventStoreRecordSpec, EventStoreGroups.forContext(input.context.name));
         handles.push(handle);
-        return handle.historyExecutor();
+        return handle;
     }
 }
 /**
@@ -162,20 +219,24 @@ export class PostgresEntityCommitStorage {
     open;
     onClose;
     #open = true;
-    #coordinator;
+    #records;
+    /**
+     * Synchronous idle-close result, including any cleanup failure.
+     */
+    #idleOutcome;
+    #active = new Set();
+    #closing;
     /**
      * Creates a PostgreSQL Entity commit handle for one Entity storage boundary.
      *
      * @param entity Defines the captured Entity source, state, and tenant scope.
-     * @param open Opens temporary current and history record-family handles.
-     * @param lifecycle Acquires transaction clients for the captured database.
+     * @param open Opens current and optional history record-family handles.
      * @param onClose Removes this handle from the factory's live-handle set.
      */
-    constructor(entity, open, lifecycle, onClose) {
+    constructor(entity, open, onClose) {
         this.entity = entity;
         this.open = open;
         this.onClose = onClose;
-        this.#coordinator = new PostgresEntityCommitCoordinator(lifecycle);
     }
     /**
      * Commits one current Entity record and its optional immutable records.
@@ -183,132 +244,337 @@ export class PostgresEntityCommitStorage {
      * @typeParam Id Entity identifier type supplied by the commit.
      * @typeParam State Entity state message type supplied by the commit.
      * @param input Defines the next current record plus histories.
-     * @returns Completion after PostgreSQL commits the mutation.
+     * @returns Completion after every requested record write.
+     */
+    commit(input) {
+        if (!this.#open)
+            return Promise.reject(new PostgresStorageOperationError("Entity commit storage is closed."));
+        return this.track(() => {
+            this.validate(input);
+            const prepared = EntityCommitSnapshots.capture(input);
+            return this.persist(prepared);
+        });
+    }
+    /**
+     * Registers a commit before invoking provider construction callbacks.
+     *
+     * @param action The admitted provider operation.
+     * @returns The admitted provider operation completion.
+     * @typeParam T Result type of the admitted provider operation.
      */
-    async commit(input) {
-        this.validate(input);
-        const records = new PostgresCommitRecords(input, this.open);
+    track(action) {
+        let complete;
+        let fail;
+        const work = new Promise((resolve, reject) => {
+            complete = resolve;
+            fail = reject;
+        });
+        this.#active.add(work);
+        void work.then(() => this.#active.delete(work), () => this.#active.delete(work));
         try {
-            await records.prepare();
-            await this.#coordinator.commit((client) => this.apply(client, input, records));
+            action().then(complete, fail);
         }
-        finally {
-            records.close();
+        catch (error) {
+            fail(error);
         }
+        return work;
+    }
+    /**
+     * Reads one detached preference image through the retained private family.
+     * @param entityId Typed Agent identifier.
+     * @returns Current complete image or absence.
+     */
+    readAgentPreferences(entityId) {
+        if (!this.#open)
+            return Promise.reject(new PostgresStorageOperationError("Entity commit storage is closed."));
+        return this.track(async () => {
+            const key = AgentModelPreferences.key(this.entity, entityId);
+            const records = this.agentRecords();
+            await records.prepare();
+            const slot = `v1:${AgentHistoryHash.value(AgentModelPreferences.text(key))}`;
+            const storage = records.preferences;
+            if (storage === undefined)
+                throw new Error("Agent preference storage is unavailable.");
+            const found = await storage.read(slot);
+            if (found === undefined)
+                return undefined;
+            AgentModelPreferences.requireIdentity(found, key);
+            return AgentModelPreferences.copy(found.preferences);
+        });
+    }
+    /**
+     * Commits state, final audit, and complete preferences in one native transaction.
+     * @param input Captured Agent transition and initial images.
+     * @returns Completion after the conditional group commits.
+     * @typeParam Id Typed Agent identifier.
+     * @typeParam State Generated Agent state.
+     */
+    commitAgent(input) {
+        if (!this.#open)
+            return Promise.reject(new PostgresStorageOperationError("Entity commit storage is closed."));
+        return this.track(async () => {
+            const id = this.entity.id.clone(input.entityId);
+            const key = AgentModelPreferences.key(this.entity, id);
+            const expected = input.expectedPreferences === undefined
+                ? undefined
+                : AgentModelPreferences.copy(input.expectedPreferences);
+            const next = AgentModelPreferences.record(key, input.preferences);
+            const mutation = input.entityCommit && EntityCommitSnapshots.capture(input.entityCommit);
+            const history = input.historyEntries?.map((entry) => clone(AgentHistoryEntrySchema, entry)) ?? [];
+            this.validateAgent(id, input.expectedVersion, mutation);
+            const records = this.agentRecords();
+            if (mutation !== undefined)
+                records.ensure(mutation, this.open);
+            await records.prepare();
+            await this.commitAgentPrepared(records, id, input.expectedVersion, expected, next, mutation, history);
+        });
     }
     /**
-     * Prepares existing Entity record families for an Agent's same-client conditional completion.
+     * Acquires the retained current, Agent audit, and preference families.
      *
-     * @typeParam Id Typed Entity identifier.
-     * @typeParam State Generated Entity state.
-     * @param input Current state and immutable Entity records.
-     * @returns Prepared transaction work and its close operation.
-     */
-    async prepareConditional(input) {
-        this.validate(input);
-        const records = new PostgresCommitRecords(input, this.open);
+     * @returns The retained family group.
+     */
+    agentRecords() {
+        const records = this.#records ?? new PostgresCommitRecords(this.entity, this.open);
         try {
-            await records.prepare();
+            records.ensureAgent(this.open);
+            this.#records ??= records;
+            return records;
         }
         catch (error) {
-            records.close();
+            if (this.#records === undefined) {
+                try {
+                    records.close();
+                }
+                catch (cleanup) {
+                    throw new AggregateError([error, cleanup], "PostgreSQL Agent family cleanup failed.");
+                }
+            }
             throw error;
         }
-        return {
-            apply: (client, expectedVersion) => this.apply(client, input, records, expectedVersion),
-            close: () => {
-                records.close();
-            },
-        };
     }
     /**
-     * Closes this handle to new commits while allowing started work to settle.
+     * Checks the captured Entity scope and next version before native writes.
+     * @param id Captured Agent identifier.
+     * @param version Initial Entity version.
+     * @param mutation Optional prepared Entity mutation.
+     * @typeParam Id Typed Agent identifier.
+     * @typeParam State Generated Agent state.
      */
-    close() {
-        if (this.#open) {
-            this.#open = false;
-            this.onClose();
+    validateAgent(id, version, mutation) {
+        if (!Number.isSafeInteger(version) || version < 0)
+            throw new TypeError("Agent commit requires a valid initial Entity Version.");
+        if (mutation === undefined)
+            return;
+        this.validate(mutation);
+        if (this.entity.id.key(id) !== this.entity.id.key(mutation.entityId) ||
+            mutation.next.version?.number !== version + 1)
+            throw new Error("Agent commit requires the same Entity ID and one new Version.");
+    }
+    /**
+     * Applies one transaction lock even when preference and current rows are absent.
+     * @param records Retained families.
+     * @param id Captured Agent ID.
+     * @param version Initial Entity version.
+     * @param expected Initial preference image.
+     * @param next Complete replacement record.
+     * @param mutation Optional Entity mutation.
+     * @param history Final audit entries.
+     * @typeParam Id Typed Agent identifier.
+     * @typeParam State Generated Agent state.
+     * @returns Completion after the conditional Agent transaction commits.
+     */
+    async commitAgentPrepared(records, id, version, expected, next, mutation, history) {
+        const preferenceStorage = records.preferences;
+        const historyStorage = records.history;
+        if (preferenceStorage === undefined || historyStorage === undefined || next.key === undefined)
+            throw new Error("Agent commit storage is incomplete.");
+        const preferences = preferenceStorage.historyExecutor();
+        const key = next.key;
+        const slot = `v1:${AgentHistoryHash.value(AgentModelPreferences.text(key))}`;
+        await preferences.transaction(async (client) => {
+            await client.query("SELECT pg_advisory_xact_lock($1)", [
+                preferences.lock("agent-preferences", slot),
+            ]);
+            const prior = await preferences.read(client, slot, "for-update");
+            if (prior !== undefined)
+                AgentModelPreferences.requireIdentity(prior, key);
+            if (!AgentModelPreferences.same(prior?.preferences, expected))
+                throw new Error("Agent model preferences changed during the live turn.");
+            if (mutation === undefined) {
+                const current = await records.current.historyExecutor().read(client, id, "for-update");
+                if ((current?.version?.number ?? 0) !== version)
+                    throw new Error("Agent initial Entity Version is no longer current.");
+            }
+            else
+                await records.applyConditional(client, mutation, version);
+            await this.appendAgentHistory(client, historyStorage, id, history);
+            await preferences.write(client, next);
+        });
+    }
+    /**
+     * Adds final Agent audit through the admitted transaction client.
+     * @param client Active native transaction.
+     * @param storage Retained Agent history family.
+     * @param id Captured Agent identifier.
+     * @param history Final audit entries.
+     * @returns Completion after final audit rows are appended.
+     */
+    async appendAgentHistory(client, storage, id, history) {
+        const executor = storage.historyExecutor();
+        for (const entry of history)
+            await executor.appendImmutable(client, AgentHistoryRecords.record(this.entity.stateSchema.typeName, this.entity.id.key(id), entry));
+    }
+    /**
+     * Persists an admitted captured mutation, including a safe retry.
+     *
+     * @param prepared The immutable prepared mutation.
+     * @returns Completion after the captured mutation is persisted.
+     * @typeParam Id Entity identifier or record type.
+     * @typeParam State Generated Entity state message type.
+     */
+    async persist(prepared) {
+        let records = this.#records;
+        let fresh = false;
+        try {
+            if (records === undefined) {
+                records = new PostgresCommitRecords(this.entity, this.open);
+                fresh = true;
+            }
+            records.ensure(prepared, this.open);
+            this.#records ??= records;
+            await records.prepare();
+            try {
+                await this.apply(prepared, records);
+            }
+            catch (error) {
+                if (!this.retryable(error))
+                    throw error;
+                await this.apply(prepared, records);
+            }
+        }
+        catch (error) {
+            if (fresh && this.#records === undefined) {
+                try {
+                    records?.close();
+                }
+                catch (cleanup) {
+                    throw new AggregateError([error, cleanup], "PostgreSQL commit acquisition failed.");
+                }
+            }
+            throw PostgresStorageErrors.operation(error);
         }
     }
     /**
-     * Applies one validated Entity commit on an active transaction.
+     * Determines whether a driver serialization failure occurred through provider error causes.
      *
-     * @typeParam Id Entity identifier type supplied by the commit.
-     * @typeParam State Entity state message type supplied by the commit.
-     * @param client PostgreSQL transaction client.
-     * @param input Defines the Entity records to commit.
-     * @param records Provides the prepared record families.
-     * @returns Completion after records are committed.
-     * @param expectedVersion Expected current Entity Version.
+     * @param error Supplies the operation failure.
+     * @returns Whether one captured-input retry is safe.
      */
-    async apply(client, input, records, expectedVersion) {
-        await this.locks(client, input, records);
-        const current = await records.current.read(client, input.entityId, "for-update");
-        if (expectedVersion !== undefined && (current?.version?.number ?? 0) !== expectedVersion)
-            throw new Error("Agent execution initial Entity Version is no longer current.");
-        await this.preflight(client, input, records);
-        await this.append(client, input, records);
-        if (!PostgresCommitValues.same(current, input.next))
-            await records.current.write(client, input.next);
+    retryable(error) {
+        let current = error;
+        for (let depth = 0; depth < 4; depth += 1) {
+            if (typeof current !== "object" || current === null)
+                return false;
+            const failure = current;
+            if (failure.code === "40P01" || failure.code === "40001")
+                return true;
+            current = failure.cause;
+        }
+        return false;
     }
     /**
-     * Acquires locks for each mutable or append-only family in the commit.
+     * Closes this handle to new commits while allowing started work to settle.
      *
-     * @typeParam Id Entity identifier type supplied by the commit.
-     * @typeParam State Entity state message type supplied by the commit.
-     * @param client PostgreSQL transaction client.
-     * @param input Defines the Entity records to commit.
-     * @param records Provides the prepared record families.
-     * @returns Completion after all transaction locks are acquired.
+     * @returns Completion after admitted work and retained records close.
      */
-    async locks(client, input, records) {
-        if (records.states)
-            await client.query("SELECT pg_advisory_xact_lock_shared($1)", [
-                records.states.lock("history-family", records.states.table()),
-            ]);
-        if (records.diagnostics)
-            await client.query("SELECT pg_advisory_xact_lock_shared($1)", [
-                records.diagnostics.lock("history-family", records.diagnostics.table()),
-            ]);
-        await client.query("SELECT pg_advisory_xact_lock($1)", [
-            records.current.lock("entity-mutation", input.entity.sourceType.typeName, this.entity.id.key(input.entityId)),
-        ]);
+    close() {
+        this.#open = false;
+        if (this.#idleOutcome !== undefined)
+            return (this.#closing ??=
+                this.#idleOutcome.error === undefined
+                    ? Promise.resolve()
+                    : Promise.reject(this.#idleOutcome.error));
+        return (this.#closing ??= this.drain());
+    }
+    /**
+     * Closes only when no commit remains admitted.
+     */
+    closeIdle() {
+        if (this.#active.size)
+            throw new Error("Entity commit cannot close idle while work is active.");
+        if (this.#idleOutcome !== undefined) {
+            if (this.#idleOutcome.error !== undefined)
+                throw this.#idleOutcome.error;
+            return;
+        }
+        if (this.#closing !== undefined)
+            throw new Error("Entity commit close is in progress.");
+        this.#open = false;
+        const errors = [];
+        try {
+            this.#records?.close();
+        }
+        catch (error) {
+            errors.push(error);
+        }
+        this.#records = undefined;
+        try {
+            this.onClose();
+        }
+        catch (error) {
+            errors.push(error);
+        }
+        const failure = errors.length > 1 ? new AggregateError(errors) : errors[0];
+        this.#idleOutcome = failure === undefined ? {} : { error: failure };
+        if (failure !== undefined)
+            throw failure;
     }
     /**
-     * Verifies that every immutable record can be appended.
+     * Waits for admitted commits before releasing factory tracking.
      *
-     * @typeParam Id Entity identifier type supplied by the commit.
-     * @typeParam State Entity state message type supplied by the commit.
-     * @param client PostgreSQL transaction client.
-     * @param input Defines the immutable records to verify.
-     * @param records Provides the prepared record families.
-     * @returns Completion after all immutable checks pass.
+     * @returns Completion after admitted work and cleanup settle.
      */
-    async preflight(client, input, records) {
-        for (const record of input.states ?? [])
-            await records.states?.assertImmutable(client, record);
-        for (const record of input.diagnostics ?? [])
-            await records.diagnostics?.assertImmutable(client, record);
-        for (const record of input.events ?? [])
-            await records.events?.assertImmutable(client, record);
+    async drain() {
+        await Promise.allSettled([...this.#active]);
+        const errors = [];
+        try {
+            this.#records?.close();
+        }
+        catch (error) {
+            errors.push(error);
+        }
+        this.#records = undefined;
+        try {
+            this.onClose();
+        }
+        catch (error) {
+            errors.push(error);
+        }
+        if (errors.length === 1)
+            throw errors[0];
+        if (errors.length)
+            throw new AggregateError(errors, "PostgreSQL commit close failed.");
     }
     /**
-     * Stores every immutable history and event-store record.
+     * Applies one validated Entity commit as ordered independent writes.
      *
      * @typeParam Id Entity identifier type supplied by the commit.
      * @typeParam State Entity state message type supplied by the commit.
-     * @param client PostgreSQL transaction client.
-     * @param input Defines the immutable records to append.
+     * @param input Defines the Entity records to commit.
      * @param records Provides the prepared record families.
-     * @returns Completion after all records are appended.
+     * @returns Completion after records are committed.
      */
-    async append(client, input, records) {
+    async apply(input, records) {
         for (const record of input.states ?? [])
-            await records.states?.appendImmutable(client, record);
+            await records.states?.writeImmutable(record);
         for (const record of input.diagnostics ?? [])
-            await records.diagnostics?.appendImmutable(client, record);
+            await records.diagnostics?.writeImmutable(record);
         for (const record of input.events ?? [])
-            await records.events?.appendImmutable(client, record);
+            await records.events?.writeImmutable(record);
+        const current = await records.current.read(input.entityId);
+        if (!PostgresCommitValues.same(current, input.next))
+            await records.current.write(input.next);
     }
     /**
      * Validates the commit against the Entity boundary captured by this handle.
@@ -318,8 +584,6 @@ export class PostgresEntityCommitStorage {
      * @param input Defines the Entity records to validate.
      */
     validate(input) {
-        if (!this.#open)
-            throw new PostgresStorageOperationError("Entity commit storage is closed.");
         if (input.entity.sourceType.typeName !== this.entity.sourceType.typeName)
             throw new PostgresStorageOperationError("Entity commit source type is incompatible.");
         if (input.entity.stateSchema.typeName !== this.entity.stateSchema.typeName)
@@ -391,17 +655,4 @@ const PostgresCommitValues = Object.freeze({
         return TenantBoundary.of(left).key === TenantBoundary.of(right).key;
     },
 });
-const PostgresCommitErrors = Object.freeze({
-    /**
-     * Converts an internal commit failure to the stable provider error.
-     *
-     * @param error Failure raised during the Entity commit.
-     * @returns Stable public commit error.
-     */
-    operation(error) {
-        return error instanceof PostgresStorageOperationError
-            ? error
-            : new PostgresStorageOperationError("PostgreSQL Entity commit failed.");
-    },
-});
 //# sourceMappingURL=entity-commit.js.map