@abloatai/humans 0.57.0 → 0.59.0

package/dist/local/sync/createClaimStream.js

@@ -24,10 +24,11 @@
 import { asyncIteratorFrom } from '@abloatai/transaction/utils/asyncIterator';
 import { toMs } from '@abloatai/transaction/utils/duration';
 import { claimDescription, descriptionFromMeta, participantKindFromWire, } from '@abloatai/transaction/coordination/schema';
-import { isTargetTuple, subTarget, streamTarget, wireTarget, } from '@abloatai/transaction/coordination/locator';
-import { declaredMeta } from '@abloatai/transaction/coordination/claimMeta';
+import { isTargetTuple, subTarget, streamTarget, wireTarget, } from '@abloatai/transaction/claims';
+import { bindClaimLifetime, createClaimLifetime, } from '@abloatai/transaction/claims/lifetime';
+import { declaredMeta } from '@abloatai/transaction/claims';
 import { AbloClaimedError, AbloConnectionError } from '@abloatai/transaction/errors';
-import { resolveHeartbeatOptions } from '@abloatai/transaction/coordination/claimHeartbeatLoop';
+import { resolveHeartbeatOptions } from '@abloatai/transaction/claims';
 import { noopLogger } from '@abloatai/transaction/logger';
 /** Readable target for the coordination trace: `documents:abc` / `documents:abc.title`. */
 function claimLabel(type, id, field) {
@@ -47,7 +48,7 @@ export function createClaimStream(config, transport = null) {
     // ── State: others' open claims, keyed by claimId ───────────────
     const activeByClaimId = new Map();
     let claimsSnapshot = Object.freeze([]);
-    // ── State: our own open claims (for re-announce on reconnect) ───
+    // ── State: our own open grants, keyed by the exact claim id ─────
     const ownClaims = new Map();
     // ── State: per-entity wait queues, from `claim_queue` frames ────
     // Keyed `type:id`; the value is the FIFO line of queued claims. Powers
@@ -157,15 +158,18 @@ export function createClaimStream(config, transport = null) {
         unsubs.push(t.subscribe('claim_rejected', (rejection) => {
             if (!rejection.claimId)
                 return;
-            if (ownClaims.has(rejection.claimId)) {
+            const own = ownClaims.get(rejection.claimId);
+            if (own) {
                 const tgt = rejection.target
                     ? claimLabel(rejection.target.entityType, rejection.target.entityId, rejection.target.field)
                     : rejection.claimId;
                 logger.info(`claim: rejected ${tgt}${rejection.heldBy ? ` — held by ${rejection.heldBy}` : ''}`, { claimId: rejection.claimId, reason: rejection.reason });
             }
-            // Drop the rejected own-claim so reconnect doesn't re-announce
-            // a claim the server already rejected (would just spam both
-            // sides with conflicts).
+            own?.lifetime.end(new AbloClaimedError(rejection.message ?? `Claim ${rejection.claimId} was rejected.`, {
+                code: rejection.reason === 'conflict'
+                    ? 'claim_conflict'
+                    : 'claim_lease_unavailable',
+            }));
             ownClaims.delete(rejection.claimId);
             // A holder on another server may have claimed before this client joined
             // the row group, so its one-shot presence frame was missed. A conflict
@@ -193,12 +197,12 @@ export function createClaimStream(config, transport = null) {
         // The frame is validated by the transport's dispatcher against the same
         // schema this parameter's type comes from, so it arrives proven.
         t.subscribe('claim_lost', (lost) => {
-            if (ownClaims.has(lost.claimId)) {
-                const c = ownClaims.get(lost.claimId);
-                logger.info(`claim: lost ${c ? claimLabel(c.entityType, c.entityId, c.field) : lost.claimId} (preempted or expired)`, { claimId: lost.claimId });
+            const own = ownClaims.get(lost.claimId);
+            if (own) {
+                const c = own.claim;
+                logger.info(`claim: lost ${claimLabel(c.entityType, c.entityId, c.field)} (preempted or expired)`, { claimId: lost.claimId });
             }
-            // Drop the lost own-claim so reconnect doesn't re-announce a lease we
-            // no longer hold.
+            own?.lifetime.end(new AbloClaimedError(`Claim ${lost.claimId} was lost because it ${lost.reason === 'expired' ? 'expired' : 'was preempted'}. Re-acquire it before continuing.`, { code: 'claim_lost' }));
             ownClaims.delete(lost.claimId);
             for (const l of lostListeners) {
                 try {
@@ -260,17 +264,27 @@ export function createClaimStream(config, transport = null) {
                     });
                     return;
                 }
-                const c = ownClaims.get(ack.claimId);
-                reject(new AbloClaimedError(`The lease behind ${c ? claimLabel(c.entityType, c.entityId, c.field) : `claim ${ack.claimId}`} is no longer held — it expired or was granted onward while this participant was working. Re-acquire the claim and retry; a write attempted under the old lease is rejected by its \`readAt\` guard.`, { code: 'claim_lost' }));
+                const own = ownClaims.get(ack.claimId);
+                const c = own?.claim;
+                const error = new AbloClaimedError(`The lease behind ${c ? claimLabel(c.entityType, c.entityId, c.field) : `claim ${ack.claimId}`} is no longer held — it expired or was granted onward while this participant was working. Re-acquire the claim and retry; a write attempted under the old lease is rejected by its \`readAt\` guard.`, { code: 'claim_lost' });
+                own?.lifetime.end(error);
+                ownClaims.delete(ack.claimId);
+                reject(error);
             });
         }));
-        // (3) On reconnect, re-announce every open self-claim — the
-        //     server's claim state is in-memory and is lost across
-        //     restarts. Without this, peers would see our claims vanish
-        //     whenever the connection blipped.
-        unsubs.push(t.subscribe('connected', () => {
-            for (const [claimId, claim] of ownClaims) {
-                sendBegin(claimId, claim);
+        // (3) A granted handle belongs to this connection's exact grant. The server
+        //     releases the participant's claims when its last socket leaves; trying
+        //     to recreate them on `connected` silently swapped the lease beneath an
+        //     old `data` / `readAt` / fenceToken tuple. End them instead. A caller
+        //     reconnects, re-reads, and takes a fresh handle.
+        unsubs.push(t.subscribe('disconnected', () => {
+            const error = new AbloConnectionError('The connection holding this claim ended. Reconnect and acquire a fresh claim before continuing.');
+            for (const { lifetime } of ownClaims.values()) {
+                lifetime.end(error);
+            }
+            ownClaims.clear();
+            for (const claimId of [...pendingHeartbeats.keys()]) {
+                settleHeartbeat(claimId, ({ reject }) => reject(error));
             }
         }));
     }
@@ -308,14 +322,14 @@ export function createClaimStream(config, transport = null) {
     }
     /**
      * Send one heartbeat and await its ack. Rejects with
-     * {@link AbloConnectionError} (transient — the auto-heartbeat loop retries
-     * on its next tick) when the socket is down or the ack times out, and with
+     * {@link AbloConnectionError} when the socket is down or the ack times out,
+     * and with
      * {@link AbloClaimedError} (definitive) when the server answers that the
      * lease is no longer ours.
      */
     function sendHeartbeat(claimId, claim, options) {
         if (!attached?.isConnected()) {
-            return Promise.reject(new AbloConnectionError(`The heartbeat for ${claimLabel(claim.entityType, claim.entityId, claim.field)} was skipped because the connection is down. The keepalive renews held leases automatically on reconnect; the next beat retries.`));
+            return Promise.reject(new AbloConnectionError(`The heartbeat for ${claimLabel(claim.entityType, claim.entityId, claim.field)} was skipped because the connection is down. This connection's grant has ended; reconnect and acquire a fresh claim.`));
         }
         return new Promise((resolve, reject) => {
             settleHeartbeat(claimId, ({ reject: rejectPrior }) => {
@@ -371,7 +385,8 @@ export function createClaimStream(config, transport = null) {
             estimatedMs,
             queue: args.queue,
         };
-        ownClaims.set(claimId, claim);
+        const lifetime = createClaimLifetime();
+        ownClaims.set(claimId, { claim, lifetime });
         sendBegin(claimId, claim);
         // Coordination trace (info): the creator can see their human/agent claims.
         logger.info(`claim: requesting ${claimLabel(claim.entityType, claim.entityId, claim.field)} for "${claim.description}"` +
@@ -381,11 +396,12 @@ export function createClaimStream(config, transport = null) {
             if (revoked)
                 return;
             revoked = true;
+            lifetime.end();
             ownClaims.delete(claimId);
             sendAbandon(claimId, claim);
             logger.info(`claim: released ${claimLabel(claim.entityType, claim.entityId, claim.field)}`, { claimId });
         };
-        return {
+        return bindClaimLifetime({
             object: 'claim',
             id: claimId,
             status: 'active',
@@ -403,7 +419,7 @@ export function createClaimStream(config, transport = null) {
             [Symbol.asyncDispose]: async () => {
                 revoke();
             },
-        };
+        }, lifetime);
     }
     function resolveTarget(target) {
         if (isTargetTuple(target))
@@ -471,6 +487,9 @@ export function createClaimStream(config, transport = null) {
                     reject(new AbloConnectionError('The claim stream was disposed while this heartbeat was awaiting its reply.'));
                 });
             }
+            const error = new AbloConnectionError('The claim stream was disposed. Acquire a fresh claim before continuing.');
+            for (const { lifetime } of ownClaims.values())
+                lifetime.end(error);
             listeners.clear();
             rejectionListeners.clear();
             lostListeners.clear();

package/dist/local/sync/credentialLifecycle.d.ts

@@ -4,4 +4,4 @@
  * as much as a browser does. This path re-exports it so existing importers
  * stay unchanged.
  */
-export { DEFAULT_PREROLL_INTERVAL_MS, MIN_PREROLL_DELAY_MS, computePrerollDelayMs, CredentialLifecycle, type CredentialRefreshOutcome, type CredentialRecoveryOutcome, type CredentialRefreshResult, type CredentialRefresher, type CredentialLifecycleContext, } from '@abloatai/transaction/transport/credentialLifecycle';
+export { DEFAULT_PREROLL_INTERVAL_MS, MIN_PREROLL_DELAY_MS, computePrerollDelayMs, CredentialLifecycle, type CredentialRefreshOutcome, type CredentialRecoveryOutcome, type CredentialRefreshResult, type CredentialRefresher, type CredentialLifecycleContext, } from '@abloatai/transaction/transport/connection';

package/dist/local/sync/credentialLifecycle.js

@@ -4,4 +4,4 @@
  * as much as a browser does. This path re-exports it so existing importers
  * stay unchanged.
  */
-export { DEFAULT_PREROLL_INTERVAL_MS, MIN_PREROLL_DELAY_MS, computePrerollDelayMs, CredentialLifecycle, } from '@abloatai/transaction/transport/credentialLifecycle';
+export { DEFAULT_PREROLL_INTERVAL_MS, MIN_PREROLL_DELAY_MS, computePrerollDelayMs, CredentialLifecycle, } from '@abloatai/transaction/transport/connection';

package/dist/local/sync/participants.d.ts

@@ -1,4 +1,4 @@
-import type { JoinOptions } from '@abloatai/transaction/resources/modelOperations';
+import type { JoinOptions } from '@abloatai/transaction/client/resources/modelOperations';
 import type { SyncWebSocket } from './SyncWebSocket.js';
 import type { Schema } from '@abloatai/transaction/schema/schema';
 import type { Claim, Activity, ClaimTarget, ClaimStream, Peer, PresenceStream, PresenceTarget } from '@abloatai/transaction/types/streams';

package/dist/local/sync/schemaDrift.d.ts

@@ -19,6 +19,16 @@ export interface ServerSchemaModel {
     readonly key: string;
     /** Per-model content hash; absent on servers older than this check. */
     readonly hash?: string;
+    readonly fields?: Readonly<Record<string, {
+        readonly type: string;
+        readonly isOptional: boolean;
+    }>>;
+}
+export interface SchemaFieldDrift {
+    readonly model: string;
+    readonly field: string;
+    readonly direction: 'client_only' | 'active_only' | 'changed';
+    readonly detail: string;
 }
 export type SchemaDriftFinding = 
 /** Every model this client declares exists server-side with matching content
@@ -38,13 +48,17 @@ export type SchemaDriftFinding =
     readonly kind: 'changed';
     readonly models: readonly string[];
     readonly unpushed: readonly string[];
+    readonly fields?: readonly SchemaFieldDrift[];
 }
 /** The server surface carries no per-model hashes (older server) — the
  *  caller falls back to the whole-hash comparison. */
  | {
     readonly kind: 'unknown';
 };
-export declare function classifySchemaDrift(clientModels: Readonly<Record<string, string>>, serverModels: readonly ServerSchemaModel[]): SchemaDriftFinding;
+export declare function classifySchemaDrift(clientModels: Readonly<Record<string, string>>, serverModels: readonly ServerSchemaModel[], clientShapes?: Readonly<Record<string, Readonly<Record<string, {
+    readonly type: string;
+    readonly isOptional: boolean;
+}>>>>): SchemaDriftFinding;
 /**
  * The warning for a real, named divergence. Calm and specific: which models,
  * what that means for this client, and the one next step. Never speaks about

package/dist/local/sync/schemaDrift.js

@@ -14,22 +14,38 @@
  *
  * Pure and transport-free; the BootstrapFetcher owns fetching the surface.
  */
-export function classifySchemaDrift(clientModels, serverModels) {
+import { reconcileClientToActive } from '@abloatai/transaction/schema';
+export function classifySchemaDrift(clientModels, serverModels, clientShapes = {}) {
     if (serverModels.length > 0 && serverModels.every((m) => !m.hash)) {
         return { kind: 'unknown' };
     }
     const server = new Map(serverModels.map((m) => [m.key, m.hash]));
     const unpushed = [];
     const changed = [];
+    const fields = [];
     for (const [key, hash] of Object.entries(clientModels)) {
         const serverHash = server.get(key);
         if (serverHash === undefined)
             unpushed.push(key);
-        else if (serverHash !== hash)
+        else if (serverHash !== hash) {
             changed.push(key);
+            const clientFields = clientShapes[key];
+            const activeFields = serverModels.find((model) => model.key === key)?.fields;
+            if (clientFields && activeFields)
+                for (const field of new Set([...Object.keys(clientFields), ...Object.keys(activeFields)])) {
+                    const client = clientFields[field];
+                    const active = activeFields[field];
+                    if (!active)
+                        fields.push({ model: key, field, direction: 'client_only', detail: 'present in this build but absent from the active schema' });
+                    else if (!client)
+                        fields.push({ model: key, field, direction: 'active_only', detail: 'present in the active schema but absent from this build' });
+                    else if (client.type !== active.type || client.isOptional !== active.isOptional)
+                        fields.push({ model: key, field, direction: 'changed', detail: `${client.type}${client.isOptional ? ' optional' : ' required'} in this build and ${active.type}${active.isOptional ? ' optional' : ' required'} in the active schema` });
+                }
+        }
     }
     if (changed.length > 0)
-        return { kind: 'changed', models: changed, unpushed };
+        return { kind: 'changed', models: changed, unpushed, ...(fields.length ? { fields } : {}) };
     if (unpushed.length > 0)
         return { kind: 'unpushed', models: unpushed };
     return { kind: 'aligned' };
@@ -40,14 +56,15 @@ export function classifySchemaDrift(clientModels, serverModels) {
  * hashes — the point of the semantic check is that nobody has to compare hex.
  */
 export function describeSchemaDrift(finding, serverLabel) {
-    if (finding.kind === 'unpushed') {
-        return (`Ablo: This build declares models the server at ${serverLabel} doesn't have yet ` +
-            `(${finding.models.join(', ')}). Writes to them will be declined until the schema is ` +
-            `pushed — run \`ablo push\` (and \`ablo status\` to confirm it targets this server).`);
-    }
-    const alsoUnpushed = finding.unpushed.length > 0 ? ` (${finding.unpushed.join(', ')} not pushed yet)` : '';
-    return (`Ablo: These models differ between this build and the server at ${serverLabel}: ` +
-        `${finding.models.join(', ')}${alsoUnpushed}. Reads and writes touching what changed may be ` +
-        `declined — \`ablo status\` shows the deployed shape; pushing your schema or deploying a ` +
-        `current build aligns them.`);
+    const findings = finding.kind === 'unpushed'
+        ? reconcileClientToActive([], finding.models, serverLabel)
+        : reconcileClientToActive(finding.models, finding.unpushed, serverLabel, finding.fields ?? []);
+    const changed = findings.filter(({ code }) => code === 'model_changed').map(({ model }) => model).filter(Boolean);
+    const unpushed = findings.filter(({ code }) => code === 'model_unpushed').map(({ model }) => model).filter(Boolean);
+    const summary = [
+        ...findings.filter(({ field }) => field !== undefined).map(({ message }) => message),
+        ...(changed.length ? [`Models ${changed.join(', ')} differ between this build and the active schema at ${serverLabel}.`] : []),
+        ...(unpushed.length ? [`Models ${unpushed.join(', ')} are declared by this build but are not active at ${serverLabel}.`] : []),
+    ];
+    return `Ablo: ${summary.join(' ')} ${findings.map(({ action }) => action).filter((value, index, all) => all.indexOf(value) === index).join(' ')}`;
 }

package/dist/local/sync/schemas.d.ts

@@ -20,10 +20,10 @@ export declare const ServerDeltaSchema: z.ZodObject<{
     id: z.ZodNumber;
     data: z.ZodNullable<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodString]>>;
     actionType: z.ZodEnum<{
+        A: "A";
         I: "I";
         U: "U";
         D: "D";
-        A: "A";
         V: "V";
         C: "C";
         G: "G";
@@ -44,10 +44,10 @@ export declare const BootstrapResponseSchema: z.ZodObject<{
         id: z.ZodNumber;
         data: z.ZodNullable<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodString]>>;
         actionType: z.ZodEnum<{
+            A: "A";
             I: "I";
             U: "U";
             D: "D";
-            A: "A";
             V: "V";
             C: "C";
             G: "G";

package/dist/local/sync/schemas.js

@@ -8,7 +8,7 @@
 import { z } from 'zod';
 import { globalRuntime } from "../context.js";
 import { AbloValidationError } from "@abloatai/transaction/errors";
-import { syncDeltaWireCoreSchema } from '@abloatai/transaction/wire/delta';
+import { syncDeltaWireCoreSchema } from '@abloatai/transaction/observation';
 // ─── Server Delta Schema ─────────────────────────────────────────────────────
 /**
  * A delta as it arrives in a bootstrap payload.

package/dist/local/sync/wsFrameHandlers.d.ts

@@ -5,4 +5,4 @@
  * the transport object. This path re-exports it so existing importers stay
  * unchanged.
  */
-export { isRecord, readWsInboundFrame, wsFrameHandlers, dispatchWsFrame, type PendingCommit, type PendingClaim, type PendingSubscription, type WsInboundFrame, type WsSession, type WsFrameHandler, } from '@abloatai/transaction/transport/wsFrameHandlers';
+export { isRecord, readWsInboundFrame, wsFrameHandlers, dispatchWsFrame, type PendingCommit, type PendingClaim, type PendingSubscription, type WsInboundFrame, type WsSession, type WsFrameHandler, } from '@abloatai/transaction/transport/websocket';

package/dist/local/sync/wsFrameHandlers.js

@@ -5,4 +5,4 @@
  * the transport object. This path re-exports it so existing importers stay
  * unchanged.
  */
-export { isRecord, readWsInboundFrame, wsFrameHandlers, dispatchWsFrame, } from '@abloatai/transaction/transport/wsFrameHandlers';
+export { isRecord, readWsInboundFrame, wsFrameHandlers, dispatchWsFrame, } from '@abloatai/transaction/transport/websocket';

package/dist/local/transactions/databaseCommitOutbox.d.ts

@@ -1,5 +1,5 @@
-import type { DurableWriteStore } from '@abloatai/transaction/durableWrites';
-import type { PendingWrite } from '@abloatai/transaction/transactions/confirmation/pendingWrite';
+import type { DurableWriteStore } from '@abloatai/transaction/commit';
+import type { PendingWrite } from '@abloatai/transaction/commit';
 export interface CommitOutboxDatabase {
     sealTransactionRecord(record: PendingWrite, consumedRecordIds: readonly string[]): Promise<unknown>;
     getPersistedTransactions(): Promise<readonly unknown[]>;

package/dist/local/transactions/mutations/MutationQueue.d.ts

@@ -17,10 +17,10 @@ import type { MutationPersistencePort } from '../../mutationPersistence.js';
 import type { RuntimeContext } from '../../RuntimeContext.js';
 import { type LogPositionPort } from '../../logPosition.js';
 import type { WriteOptions } from '../../interfaces/index.js';
-import type { StaleNotification, ReadDependency, TrackDependency } from '@abloatai/transaction/coordination/schema';
-import { type CommitOperationResult } from '@abloatai/transaction/wire/commit';
+import type { ReadDependency } from '@abloatai/transaction/coordination/schema';
+import { type CommitOperationResult } from '@abloatai/transaction/commit';
 import { type MutationInput, type QueuedMutation, type UserContext } from './commitPayload.js';
-import { type CommitOutboxScope } from '@abloatai/transaction/transactions/confirmation/commitEnvelope';
+import { type CommitOutboxScope } from '@abloatai/transaction/commit';
 import type { DurableWriteStore } from './durableWriteStore.js';
 import { type LocalMutationPort } from './localMutation.js';
 import { type CommitTransaction } from './commitLane.js';
@@ -151,7 +151,7 @@ export declare class MutationQueue extends EventEmitter {
     private get queueCoalescingContext();
     private get batchProcessingContext();
     private get failureHandlingContext();
-    private get conflictPolicyContext();
+    private get conflictResolutionContext();
     private get processingSchedulerContext();
     private get pendingDrainContext();
     private get durableCommitRestoreContext();
@@ -163,18 +163,6 @@ export declare class MutationQueue extends EventEmitter {
     private computePriorityScore;
     private ensureDerivedFields;
     private entityKey;
-    /** Collision-safe receipt target identity across models sharing a row id. */
-    private receiptTargetKey;
-    /**
-     * Relates stale notifications back to write targets without assuming the
-     * server's canonical model name uses the same spelling as the public schema
-     * key (`Item` versus `items`). Exact `(model,id)` wins; a globally unique id
-     * is the compatibility fallback. An ambiguous same-id cross-model mismatch
-     * is deliberately left unclassified, so it cannot falsely settle a queued
-     * write. A notification with no write-target id (or an explicit group) is a
-     * declared-read conflict and holds the whole batch.
-     */
-    private classifyReceiptNotifications;
     private resolveConfirmation;
     private takeUnsentCreateForModel;
     private cancelUnsentCreateForDelete;
@@ -185,7 +173,6 @@ export declare class MutationQueue extends EventEmitter {
     private config;
     private executingCount;
     private readonly localMutationPort;
-    private commitNotifications;
     /** Zero-row targets returned on a successful atomic commit receipt. */
     private commitMissingIds;
     private readonly deltaConfirmation;
@@ -367,12 +354,10 @@ export declare class MutationQueue extends EventEmitter {
     /** Enqueues a pre-built atomic commit through the commit API coordinator. */
     enqueueCommit(clientTxId: string, operations: CommitTransaction['operations'], options?: {
         reads?: ReadDependency[] | null;
-        track?: TrackDependency[] | null;
     }): Promise<void>;
     private processCommitLane;
     waitForCommitReceipt(clientTxId: string): Promise<{
         lastSyncId: number;
-        notifications?: StaleNotification[];
         missingIds?: string[];
         operationResults?: CommitOperationResult[];
     }>;

package/dist/local/transactions/mutations/MutationQueue.js

@@ -16,7 +16,7 @@ import { v4 as uuid } from 'uuid';
 import { globalRuntime } from '../../context.js';
 import { AbloConnectionError, AbloIdempotencyError, } from '@abloatai/transaction/errors';
 import { LogPosition, } from '../../logPosition.js';
-import {} from '@abloatai/transaction/wire/commit';
+import {} from '@abloatai/transaction/commit';
 import { computePriorityScore, normalizeModelKey, } from './commitPayload.js';
 import { generateTransactionId, mergeMutationData, createDataFor, changesToInput, updateDataFor, previousDataFor, } from './mutationInput.js';
 import { MutationStore } from './MutationStore.js';
@@ -24,8 +24,7 @@ import { entityKey, takeUnsentCreateForModel, findCreateBarrierForDelete, deferD
 import { DeltaConfirmationTracker } from './deltaConfirmation.js';
 import { deserializePersistedTransaction, isNonReplayablePersistedRow, pendingMutationRecordId, } from './replayValidation.js';
 import { deserializeLegacyPendingMutation, loadPersistedTransactions, persistQueuedTransaction, removePersistedTransaction, settlePersistedFailure, } from './mutationPersistence.js';
-import { createCommitEnvelopeMember, } from '@abloatai/transaction/transactions/confirmation/commitEnvelope';
-import { stableStringify } from '@abloatai/transaction/utils/json';
+import { createCommitEnvelopeMember, } from '@abloatai/transaction/commit';
 import { createLocalMutationPort, } from './localMutation.js';
 import { dispatchCommitBounded, parseMutationCommitResult, persistDurableCommitAcceptance, removeDurableCommit, sealDurableCommit, } from './commitTransport.js';
 import { processCommitLane, waitForCommitReceipt, } from './commitLane.js';
@@ -131,7 +130,6 @@ export class MutationQueue extends EventEmitter {
                 retryBackoff: this.config.retryBackoff,
             },
             commitLane: this.commitLane,
-            commitNotifications: this.commitNotifications,
             commitMissingIds: this.commitMissingIds,
             commitProcessing: this.commitProcessing,
             setCommitProcessing: (value) => { this.commitProcessing = value; },
@@ -141,7 +139,6 @@ export class MutationQueue extends EventEmitter {
             dispatchCommit: async (envelope) => this.parseMutationCommitResult(await this.dispatchCommitBounded(envelope.operations, {
                 idempotencyKey: envelope.idempotencyKey,
                 ...(envelope.commitOptions.reads ? { reads: envelope.commitOptions.reads } : {}),
-                ...(envelope.commitOptions.track ? { track: envelope.commitOptions.track } : {}),
             })),
             persistDurableCommitAcceptance: (envelope, result) => this.persistDurableCommitAcceptance(envelope, result),
             removeDurableCommit: (idempotencyKey) => this.removeDurableCommit(idempotencyKey),
@@ -165,7 +162,6 @@ export class MutationQueue extends EventEmitter {
     get commitReceiptContext() {
         return {
             commitStore: this.commitStore,
-            commitNotifications: this.commitNotifications,
             commitMissingIds: this.commitMissingIds,
             replicationLagErrors: this.replicationLagErrors,
             on: (event, listener) => this.on(event, listener),
@@ -248,7 +244,6 @@ export class MutationQueue extends EventEmitter {
             store: this.store,
             enqueue: (transaction) => { this.enqueue(transaction); },
             optimisticUpdates: this.localMutationPort.updates,
-            commitNotifications: this.commitNotifications,
             commitMissingIds: this.commitMissingIds,
             sourceMutationIdsFor: (batch) => this.sourceMutationIdsFor(batch),
             dispatchCommitBounded: (...args) => this.dispatchCommitBounded(...args),
@@ -258,8 +253,6 @@ export class MutationQueue extends EventEmitter {
             assertEnvelopeInsideReplayWindow: (envelope) => { this.assertEnvelopeInsideReplayWindow(envelope); },
             sealDurableCommit: (input) => this.sealDurableCommit(input),
             noteAck: (syncId) => { this.noteAck(syncId); },
-            classifyReceiptNotifications: (operations, notifications) => this.classifyReceiptNotifications(operations, notifications),
-            receiptTargetKey: (modelName, modelId) => this.receiptTargetKey(modelName, modelId),
             scheduleReplicationLagTimeout: (transactionId, clientTxId, correlationId) => { this.scheduleReplicationLagTimeout(transactionId, clientTxId, correlationId); },
             scheduleDeltaConfirmationTimeout: (transaction, timeoutMs) => { this.scheduleDeltaConfirmationTimeout(transaction, timeoutMs); },
             clearReplicationLagState: (transactionId) => { this.clearReplicationLagState(transactionId); },
@@ -288,7 +281,7 @@ export class MutationQueue extends EventEmitter {
             emit: (event, payload) => this.emit(event, payload),
         };
     }
-    get conflictPolicyContext() {
+    get conflictResolutionContext() {
         return {
             config: this.config,
             store: this.store,
@@ -409,59 +402,7 @@ export class MutationQueue extends EventEmitter {
     entityKey(modelName, modelId) {
         return entityKey(modelName, modelId);
     }
-    /** Collision-safe receipt target identity across models sharing a row id. */
-    receiptTargetKey(modelName, modelId) {
-        return stableStringify([normalizeModelKey(modelName), modelId]);
-    }
-    /**
-     * Relates stale notifications back to write targets without assuming the
-     * server's canonical model name uses the same spelling as the public schema
-     * key (`Item` versus `items`). Exact `(model,id)` wins; a globally unique id
-     * is the compatibility fallback. An ambiguous same-id cross-model mismatch
-     * is deliberately left unclassified, so it cannot falsely settle a queued
-     * write. A notification with no write-target id (or an explicit group) is a
-     * declared-read conflict and holds the whole batch.
-     */
-    classifyReceiptNotifications(operations, notifications) {
-        const targets = operations.map((operation) => ({
-            id: operation.id,
-            key: this.receiptTargetKey(operation.model, operation.id),
-        }));
-        const heldTargets = new Set();
-        const notificationsByTarget = new Map();
-        let holdsEntireBatch = false;
-        for (const notification of notifications) {
-            // Scope is decided before any target matching. A group premise fires over
-            // the WHOLE batch by convention, and its `target` now names the row that
-            // actually moved — which may well be a row this batch is writing, so
-            // matching first would misread a batch-wide hold as a per-row one.
-            if (notification.scope === 'group') {
-                holdsEntireBatch = true;
-                continue;
-            }
-            const candidates = targets.filter((target) => target.id === notification.target.id);
-            const notificationKey = this.receiptTargetKey(notification.target.model, notification.target.id);
-            const exactTargets = candidates.filter((target) => target.key === notificationKey);
-            const candidateKeys = new Set((exactTargets.length > 0 ? exactTargets : candidates).map((target) => target.key));
-            if (candidates.length === 0) {
-                holdsEntireBatch = true;
-                continue;
-            }
-            if (candidateKeys.size !== 1) {
-                // Same id across multiple differently named models with no exact match:
-                // the id-only compatibility fallback is ambiguous. Await the echo.
-                continue;
-            }
-            const [targetKey] = candidateKeys;
-            if (!targetKey)
-                continue;
-            heldTargets.add(targetKey);
-            const targetNotifications = notificationsByTarget.get(targetKey) ?? [];
-            targetNotifications.push(notification);
-            notificationsByTarget.set(targetKey, targetNotifications);
-        }
-        return { holdsEntireBatch, heldTargets, notificationsByTarget };
-    }
+    /* Stale receipt classification was removed; stale premises now reject. */
     resolveConfirmation(transaction) {
         const resolver = this.confirmationResolvers.get(transaction.id);
         if (!resolver)
@@ -543,11 +484,6 @@ export class MutationQueue extends EventEmitter {
     // Track executing transactions for backpressure
     executingCount = 0;
     localMutationPort;
-    // Stale-context notifications, keyed by transaction id. When the server
-    // accepts a commit but reports that an operation's premise had moved,
-    // the notification lands here from the commit acknowledgement and is drained
-    // by `waitForCommitReceipt`, so the receipt can carry it back to the caller.
-    commitNotifications = new Map();
     /** Zero-row targets returned on a successful atomic commit receipt. */
     commitMissingIds = new Map();
     // Delta-confirmation tracking (ack watermark advance + the awaiting_delta
@@ -1266,7 +1202,7 @@ export class MutationQueue extends EventEmitter {
         await handleFailure(this.failureHandlingContext, transaction, error);
     }
     async handleConflict(transaction, serverData) {
-        await resolveConflict(this.conflictPolicyContext, transaction, serverData);
+        await resolveConflict(this.conflictResolutionContext, transaction, serverData);
     }
     applyOptimisticCreate(model, transaction) {
         this.localMutationPort.applyCreate(model, transaction);
@@ -1518,7 +1454,6 @@ export class MutationQueue extends EventEmitter {
         this.recentDeltaCorrelations.clear();
         this.commitLane = [];
         this.commitStore.clear();
-        this.commitNotifications.clear();
         this.commitMissingIds.clear();
         // Clear event listeners
         this.removeAllListeners();

package/dist/local/transactions/mutations/batchProcessing.d.ts

@@ -3,9 +3,8 @@ import type { MutationQueueConfig } from './MutationQueue.js';
 import type { MutationInput, QueuedMutation } from './commitPayload.js';
 import type { MutationStore } from './MutationStore.js';
 import type { OptimisticUpdateEntry } from './localMutation.js';
-import type { StaleNotification } from '@abloatai/transaction/coordination/schema';
-import type { MutationCommitResult } from '@abloatai/transaction/wire/commit';
-import type { DurableCommitEnvelope } from '@abloatai/transaction/transactions/confirmation/commitEnvelope';
+import type { MutationCommitResult } from '@abloatai/transaction/commit';
+import type { DurableCommitEnvelope } from '@abloatai/transaction/commit';
 export interface BatchProcessingContext {
     readonly runtime: RuntimeContext;
     readonly config: MutationQueueConfig;
@@ -28,7 +27,6 @@ export interface BatchProcessingContext {
     readonly store: MutationStore;
     readonly enqueue: (transaction: QueuedMutation) => void;
     readonly optimisticUpdates: Map<string, OptimisticUpdateEntry>;
-    readonly commitNotifications: Map<string, StaleNotification[]>;
     readonly commitMissingIds: Map<string, string[]>;
     readonly sourceMutationIdsFor: (batch: readonly QueuedMutation[]) => string[];
     readonly dispatchCommitBounded: (...args: Parameters<import('../../interfaces/index.js').MutationExecutor['commit']>) => ReturnType<import('../../interfaces/index.js').MutationExecutor['commit']>;
@@ -38,15 +36,6 @@ export interface BatchProcessingContext {
     readonly assertEnvelopeInsideReplayWindow: (envelope: DurableCommitEnvelope) => void;
     readonly sealDurableCommit: (input: Parameters<typeof import('./commitTransport.js').sealDurableCommit>[1]) => Promise<DurableCommitEnvelope>;
     readonly noteAck: (syncId: number | undefined) => void;
-    readonly classifyReceiptNotifications: (operations: readonly {
-        model: string;
-        id: string;
-    }[], notifications: readonly StaleNotification[]) => {
-        holdsEntireBatch: boolean;
-        heldTargets: Set<string>;
-        notificationsByTarget: Map<string, StaleNotification[]>;
-    };
-    readonly receiptTargetKey: (modelName: string, modelId: string) => string;
     readonly scheduleReplicationLagTimeout: (transactionId: string, clientTxId?: string, correlationId?: string) => void;
     readonly scheduleDeltaConfirmationTimeout: (transaction: QueuedMutation, timeoutMs: number) => void;
     readonly clearReplicationLagState: (transactionId: string) => void;