@abloatai/humans 0.56.0 → 0.58.0

package/dist/local/client/options.d.ts

@@ -7,8 +7,8 @@
 import type { Schema, SchemaRecord } from '@abloatai/transaction/schema/schema';
 import type { RuntimeConfig, Logger, MutationExecutor, ObservabilityProvider, Analytics, SessionErrorDetector, OnlineStatusProvider } from '../interfaces/index.js';
 import type { AbloPersistence } from '../persistence.js';
-import type { DurableWriteStore, DurableWritesConfig } from '@abloatai/transaction/durableWrites';
-import type { CommitOutboxScope } from '@abloatai/transaction/transactions/confirmation/commitEnvelope';
+import type { DurableWriteStore, DurableWritesConfig } from '@abloatai/transaction/commit';
+import type { CommitOutboxScope } from '@abloatai/transaction/commit';
 /**
  * An async function that resolves an apiKey at request time. Use it for credential
  * rotation — read from a vault, refresh from session storage, or pull from an

package/dist/local/client/reactiveEngine.js

@@ -12,7 +12,7 @@
  * design step (docs/plans/package-split.md).
  */
 import { omittedModelError } from '@abloatai/transaction/schema/select';
-import { durableCommitOperationSchema, } from '@abloatai/transaction/transactions/confirmation/commitEnvelope';
+import { durableCommitOperationSchema, } from '@abloatai/transaction/commit';
 import { AbloAuthenticationError, AbloConnectionError, AbloValidationError, claimedError } from '@abloatai/transaction/errors';
 import { batchFence, claimIdFor, fenceTokenFor, modelTarget, streamTarget, subTarget, } from '@abloatai/transaction/coordination';
 import { validateAbloOptions } from './validateAbloOptions.js';
@@ -21,16 +21,17 @@ import { revokeCapability, rotateCapability, } from '@abloatai/transaction/auth/
 import { modelWireNames } from '@abloatai/transaction/auth/capability';
 import { startStoreLifecycle } from './storeLifecycle.js';
 import { createClaimStream } from '../sync/createClaimStream.js';
-import { awaitClaimGrant } from '@abloatai/transaction/coordination/awaitClaimGrant';
-import { createSnapshot } from '../sync/createSnapshot.js';
+import { awaitClaimGrant } from '@abloatai/transaction/claims';
+import { bindClaimLifetime, claimLifetimeOf, } from '@abloatai/transaction/claims/lifetime';
 import { createParticipantManager } from '../sync/participants.js';
 import { resolveApiKeyValue, resolveBootstrapBaseUrl } from '@abloatai/transaction/auth/apiKey';
-import { claimAttemptFailure, emitClaimStatus, } from '@abloatai/transaction/resources/modelOperations';
-import { createModelProxy } from './createModelProxy.js';
-import { assertWriteOptions } from '@abloatai/transaction/resources/writeOptionsSchema';
+import { claimAttemptFailure, emitClaimStatus, } from '@abloatai/transaction/client/resources/modelOperations';
+import { createModelOperations } from './createModelOperations.js';
+import { assertWriteOptions } from '@abloatai/transaction/client/resources/writeOptionsSchema';
 import { modelReadResponseSchema, commitRecordSchema, commitRecordListSchema, commitRecordWhereSchema, } from '@abloatai/transaction/wire';
-import { translateHttpError } from '@abloatai/transaction/errors';
-import { kReadEvidence } from '@abloatai/transaction/internal/read-set';
+import { translateHttpError, } from '@abloatai/transaction/errors';
+import { kReadEvidence, prepareReadSet, } from '@abloatai/transaction/internal/read-set';
+import { contextOnChange } from '../sync/contextOnChange.js';
 export function buildReactiveEngine(inputs) {
     const { options, internalOptions, url, logger, configuredApiKey, configuredAuthToken, credentialResolver, authCredentials, transport, participantId, kind, presence, cluster, createSibling, } = inputs;
     const schema = options.schema;
@@ -186,7 +187,6 @@ export function buildReactiveEngine(inputs) {
             transactionId: op.transactionId ?? undefined,
             claimId: op.claimId ?? claimIdFor(claim?.target, claim?.id, op.model, op.id ?? null) ?? undefined,
             readAt: op.readAt ?? defaults.readAt ?? undefined,
-            onStale: op.onStale ?? defaults.onStale ?? undefined,
             fenceToken: op.fenceToken ?? fenceTokenFor(fence, op.model, op.id ?? null) ?? undefined,
         });
     }
@@ -292,7 +292,7 @@ export function buildReactiveEngine(inputs) {
         // the one `awaitClaimGrant` read there; retain the handle fallback for
         // wire-compatible transports that already stamped it locally.
         const resolvedFenceToken = fenceToken ?? claim.fenceToken;
-        return {
+        const wrapped = {
             object: 'claim',
             id: claim.id,
             description: claim.description,
@@ -308,6 +308,8 @@ export function buildReactiveEngine(inputs) {
             heartbeat: claim.heartbeat,
             [Symbol.asyncDispose]: release,
         };
+        const lifetime = claimLifetimeOf(claim);
+        return lifetime ? bindClaimLifetime(wrapped, lifetime) : wrapped;
     }
     const publicClaims = Object.assign(claimStream, {
         async create(claimOptions) {
@@ -406,22 +408,17 @@ export function buildReactiveEngine(inputs) {
     const modelProxies = {};
     for (const [schemaKey, modelDef] of Object.entries(schema.models)) {
         const registeredModelName = modelDef.typename ?? schemaKey;
-        modelProxies[schemaKey] = createModelProxy(schemaKey, registeredModelName, objectPool, syncClient, modelRegistry, hydration, {
+        modelProxies[schemaKey] = createModelOperations(schemaKey, registeredModelName, objectPool, syncClient, modelRegistry, hydration, {
             createClaim: (claimOptions) => publicClaims.create(claimOptions),
+            // Lazily referenced: `commits` is declared below this loop, and this
+            // only runs when someone actually writes a batch.
+            commitBatch: (commitOptions) => commits.create(commitOptions),
             readPoint,
-            createSnapshot: (modelKey, id) => createSnapshot({
-                pool: objectPool,
-                transport,
-                // `position.readFloor` is the value claims and snapshots stamp as
-                // `readAt` (max of the pool-applied cursor and the acked
-                // watermark for our own writes — see logPosition.ts).
-                // Stamping a bare stream cursor made a claim taken right after
-                // an ack-confirmed write stale against that write's own delta.
-                // The socket/store cursors are persistence-gated and therefore
-                // never ahead of `applied` — no extra max() needed here.
-                getLastSyncId: () => syncClient.position.readFloor,
-                entities: { [modelKey]: id },
-            }),
+            // A claim needs the post-read watermark, not the legacy snapshot
+            // object. `readFloor` is max(applied, acked-own-write), so a claim
+            // taken immediately after its own confirmed mutation is not stale
+            // against an echo that has not materialised locally yet.
+            currentReadAt: () => syncClient.position.readFloor,
             queue: (target) => publicClaims.queueFor(streamTarget(target)),
             reorder: (target, order) => { publicClaims.reorder(streamTarget(target), order); },
             // One row can have several holders — sub-row claims on disjoint
@@ -466,23 +463,24 @@ export function buildReactiveEngine(inputs) {
     const commits = {
         async create(commitOptions) {
             await ready();
+            const prepared = prepareReadSet(cluster.readSetContext, syncClient, commitOptions.readAt, commitOptions.idempotencyKey, commitOptions.reads);
             // Same runtime contract as the per-model writes — one schema.
             assertWriteOptions({
-                idempotencyKey: commitOptions.idempotencyKey,
-                readAt: commitOptions.readAt,
-                onStale: commitOptions.onStale,
+                idempotencyKey: prepared.idempotencyKey,
+                readAt: prepared.readAt,
                 wait: commitOptions.wait,
                 claim: commitOptions.claim,
+                reads: prepared.reads,
             }, 'commits.create');
-            const clientTxId = createClientTxId(commitOptions.idempotencyKey);
+            const clientTxId = createClientTxId(prepared.idempotencyKey);
             // A claim handle supplies the batch stale-guard defaults — same
             // semantics as `ablo.<model>.update({ id, data, claim })`, so the
             // two write doors speak one claim vocabulary. Explicit options win.
             const claim = commitOptions.claim ?? null;
             const operations = normalizeCommitOperations({
-                ...commitOptions,
-                readAt: commitOptions.readAt ?? claim?.readAt ?? null,
-                onStale: commitOptions.onStale ?? (claim?.readAt !== undefined ? 'reject' : null),
+                operations: commitOptions.operations,
+                ...(commitOptions.claim !== undefined ? { claim: commitOptions.claim } : {}),
+                readAt: prepared.readAt ?? claim?.readAt ?? null,
             }, batchFence(claim?.target, claim?.fenceToken));
             const wait = commitOptions.wait ?? 'confirmed';
             // Route through the MutationQueue's commit lane so the call
@@ -496,19 +494,18 @@ export function buildReactiveEngine(inputs) {
             // no need to leak an accessor through BaseSyncedStore.
             const queue = syncClient.getMutationQueue();
             await queue.enqueueCommit(clientTxId, operations, {
-                ...(commitOptions.reads ? { reads: [...commitOptions.reads] } : {}),
-                ...(commitOptions.track ? { track: [...commitOptions.track] } : {}),
+                ...(prepared.reads ? { reads: [...prepared.reads] } : {}),
             });
             if (wait === 'queued') {
                 return { id: clientTxId, status: 'queued' };
             }
-            const { lastSyncId, notifications, missingIds } = await queue.waitForCommitReceipt(clientTxId);
+            const { lastSyncId, missingIds, operationResults } = await queue.waitForCommitReceipt(clientTxId);
             return {
                 id: clientTxId,
                 status: 'confirmed',
                 lastSyncId,
-                ...(notifications && notifications.length > 0 ? { notifications } : {}),
                 ...(missingIds && missingIds.length > 0 ? { missingIds } : {}),
+                ...(operationResults && operationResults.length > 0 ? { operationResults } : {}),
             };
         },
         async get({ id }) {
@@ -677,6 +674,7 @@ export function buildReactiveEngine(inputs) {
                 const sessionParams = {
                     agent: { id },
                     can: params.can,
+                    ...(params.onBehalfOf ? { onBehalfOf: params.onBehalfOf } : {}),
                     ...(params.syncGroups ? { syncGroups: params.syncGroups } : {}),
                     ...(params.ttlSeconds !== undefined ? { ttlSeconds: params.ttlSeconds } : {}),
                     ...(userMeta ? { userMeta } : {}),
@@ -764,18 +762,13 @@ export function buildReactiveEngine(inputs) {
         /** Claim livestream — same socket. Stable reference. */
         claims: publicClaims,
         commits,
-        /** Context-staleness snapshot — see `engine.snapshot(...)` JSDoc. */
-        snapshot(entities) {
-            return createSnapshot({
-                pool: objectPool,
-                transport,
-                getLastSyncId: () => transport.getLastSyncId(),
-                entities,
-            });
-        },
     };
     Object.defineProperty(engine, kReadEvidence, {
-        value: { context: cluster.readSetContext, client: syncClient },
+        value: {
+            context: cluster.readSetContext,
+            client: syncClient,
+            onChange: (reads, listener) => contextOnChange(syncClient, objectPool, reads, listener),
+        },
         enumerable: false,
     });
     // A model the schema projection left out answers with an error naming the

package/dist/local/client/resourceTypes.d.ts

@@ -7,6 +7,6 @@
  * that stay here — `ModelOperations` chief among them, because it returns the
  * live participant handle.
  */
-export * from '@abloatai/transaction/resources/httpResources';
-export type { LocalCountOptions, LocalReadOptions, ModelListScope, ServerReadOptions, ModelRetrieveParams, ModelWriteOptions, ModelCreateParams, ModelUpdateParams, ModelDeleteParams, ClaimOptions, ClaimParams, ClaimContentionOptions, ClaimAttemptEvent, ClaimQueueView, ClaimLookupParams, ClaimReorderParams, Claim, ClaimHeartbeat, ClaimHeartbeatOptions, HeldClaim, HeldLease, } from '@abloatai/transaction/resources/modelOperations';
-export type { ModelOperations } from './createModelProxy.js';
+export * from '@abloatai/transaction/client/resources/httpResources';
+export type { LocalCountOptions, LocalReadOptions, ModelListScope, ServerReadOptions, ModelReadParams, ModelWriteOptions, ModelCreateParams, ModelUpdateParams, ModelDeleteParams, ClaimOptions, ClaimParams, ClaimContentionOptions, ClaimAttemptEvent, ClaimQueueView, ClaimLookupParams, ClaimReorderParams, Claim, ClaimHeartbeat, ClaimHeartbeatOptions, HeldClaim, HeldLease, } from '@abloatai/transaction/client/resources/modelOperations';
+export type { ModelOperations } from './createModelOperations.js';

package/dist/local/client/resourceTypes.js

@@ -7,4 +7,4 @@
  * that stay here — `ModelOperations` chief among them, because it returns the
  * live participant handle.
  */
-export * from '@abloatai/transaction/resources/httpResources';
+export * from '@abloatai/transaction/client/resources/httpResources';

package/dist/local/client/wsMutationExecutor.d.ts

@@ -4,10 +4,10 @@
  * commit time because it does not exist yet when the executor is created. A
  * client wires this up automatically unless you supply your own executor.
  */
-import type { ReadDependency, TrackDependency } from '@abloatai/transaction/coordination/schema';
+import type { ReadDependency } from '@abloatai/transaction/coordination/schema';
 import type { MutationExecutor, MutationOperation } from '../interfaces/index.js';
 import type { CommitAck } from '../sync/commitFrames.js';
-import type { CommitReceiptWire } from '@abloatai/transaction/wire/commit';
+import type { CommitReceiptWire } from '@abloatai/transaction/commit';
 import { type ReadSetContext } from '@abloatai/transaction/internal/read-set';
 /**
  * Creates the default mutation executor, which sends each change as a `commit`
@@ -25,6 +25,6 @@ import { type ReadSetContext } from '@abloatai/transaction/internal/read-set';
  * generation below exists only for direct, one-shot executor consumers.
  */
 export declare function createDefaultMutationExecutor(getWs: () => {
-    sendCommitReceipt?: (operations: readonly MutationOperation[], clientTxId: string, timeoutMs?: number, reads?: readonly ReadDependency[] | null, track?: readonly TrackDependency[] | null) => Promise<CommitReceiptWire>;
-    sendCommit?: (operations: readonly MutationOperation[], clientTxId: string, timeoutMs?: number, reads?: readonly ReadDependency[] | null, track?: readonly TrackDependency[] | null) => Promise<CommitAck>;
+    sendCommitReceipt?: (operations: readonly MutationOperation[], clientTxId: string, timeoutMs?: number, reads?: readonly ReadDependency[] | null) => Promise<CommitReceiptWire>;
+    sendCommit?: (operations: readonly MutationOperation[], clientTxId: string, timeoutMs?: number, reads?: readonly ReadDependency[] | null) => Promise<CommitAck>;
 } | null, readSetContext?: ReadSetContext): MutationExecutor;

package/dist/local/client/wsMutationExecutor.js

@@ -5,7 +5,7 @@
  * client wires this up automatically unless you supply your own executor.
  */
 import { recordWebSocketCommitReceipt, } from '@abloatai/transaction/internal/read-set';
-import { commitAckSchema } from '@abloatai/transaction/wire/commit';
+import { commitAckSchema } from '@abloatai/transaction/commit';
 import { AbloError, AbloConnectionError } from '@abloatai/transaction/errors';
 // ── Default mutation executor (wire: `commit` frame over WebSocket) ──────
 /**
@@ -36,20 +36,19 @@ export function createDefaultMutationExecutor(getWs, readSetContext) {
                 : `tx_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`);
         try {
             if (ws.sendCommitReceipt) {
-                const receipt = await ws.sendCommitReceipt(operations, clientTxId, undefined, options?.reads, options?.track);
+                const receipt = await ws.sendCommitReceipt(operations, clientTxId, undefined, options?.reads);
                 recordWebSocketCommitReceipt(readSetContext, {
                     receipt,
                     operations,
                     reads: options?.reads,
-                    track: options?.track,
                 });
                 return commitAckSchema.parse({
                     status: receipt.status,
                     statusAt: receipt.statusAt,
                     lastSyncId: receipt.lastSyncId,
                     ...(receipt.correlationId ? { correlationId: receipt.correlationId } : {}),
-                    ...(receipt.notifications ? { notifications: receipt.notifications } : {}),
                     ...(receipt.missingIds ? { missingIds: receipt.missingIds } : {}),
+                    ...(receipt.operationResults ? { operationResults: receipt.operationResults } : {}),
                 });
             }
             if (!ws.sendCommit) {
@@ -58,7 +57,7 @@ export function createDefaultMutationExecutor(getWs, readSetContext) {
                 });
             }
             return await ws.sendCommit(operations, clientTxId, undefined, // use sendCommit's built-in 15s default; no per-call override
-            options?.reads, options?.track);
+            options?.reads);
         }
         catch (err) {
             // Wrap transport-level failures as connection errors so the transaction

package/dist/local/coordination/ClaimLog.d.ts

@@ -5,10 +5,10 @@
  * `ObservabilityProvider`, preserving `Ablo({ observability: new ClaimLog() })`
  * without leaking bootstrap, storage, or WebSocket vocabulary into the core.
  */
-import { ClaimLog as CoordinationClaimLog } from '@abloatai/transaction/coordination/trace';
+import { ClaimLog as CoordinationClaimLog } from '@abloatai/transaction/claims';
 import type { ObservabilityProvider } from '../interfaces/index.js';
-export { formatClaim, formatConflict } from '@abloatai/transaction/coordination/trace';
-export type { ClaimLogEntry } from '@abloatai/transaction/coordination/trace';
+export { formatClaim, formatConflict } from '@abloatai/transaction/claims';
+export type { ClaimLogEntry } from '@abloatai/transaction/claims';
 export declare class ClaimLog extends CoordinationClaimLog implements ObservabilityProvider {
     setContext(): void;
     setConnectionState(): void;

package/dist/local/coordination/ClaimLog.js

@@ -5,8 +5,8 @@
  * `ObservabilityProvider`, preserving `Ablo({ observability: new ClaimLog() })`
  * without leaking bootstrap, storage, or WebSocket vocabulary into the core.
  */
-import { ClaimLog as CoordinationClaimLog } from '@abloatai/transaction/coordination/trace';
-export { formatClaim, formatConflict } from '@abloatai/transaction/coordination/trace';
+import { ClaimLog as CoordinationClaimLog } from '@abloatai/transaction/claims';
+export { formatClaim, formatConflict } from '@abloatai/transaction/claims';
 export class ClaimLog extends CoordinationClaimLog {
     // Client-lifecycle hooks the claim log has no notion of. Every body below is
     // deliberately inert: the log records claims and conflicts, nothing else.

package/dist/local/interfaces/index.d.ts

@@ -6,9 +6,8 @@
  * session-error detection, online-status checks, and the transport that carries
  * mutations to your backend. The SDK ships sensible no-op defaults where it can.
  */
-import type { MutationCommitResultInput } from '@abloatai/transaction/wire/commit';
-import type { OnStaleMode } from '@abloatai/transaction/coordination/schema';
-export type { ClaimEvent, ConflictEvent } from '@abloatai/transaction/coordination/events';
+import type { MutationCommitResultInput } from '@abloatai/transaction/commit';
+export type { ClaimEvent, ConflictEvent } from '@abloatai/transaction/claims/events';
 import type { CoordinationObservability } from '@abloatai/transaction/observability';
 export type { CoordinationObservability } from '@abloatai/transaction/observability';
 export type { Logger } from '@abloatai/transaction/logger';
@@ -133,8 +132,8 @@ export interface ModelDebugLoggerContract {
  * while every explicit queued result requires a WAL correlation.
  */
 export type MutationCommitResult = MutationCommitResultInput;
-export type { MutationOptions } from '@abloatai/transaction/resources/mutationOptions';
-import type { MutationOptions } from '@abloatai/transaction/resources/mutationOptions';
+export type { MutationOptions } from '@abloatai/transaction/client/resources/mutationOptions';
+import type { MutationOptions } from '@abloatai/transaction/client/resources/mutationOptions';
 /**
  * The subset of {@link MutationOptions} that travels with each write as it is
  * queued offline and sent on the wire. A single shared type keeps the public
@@ -142,7 +141,7 @@ import type { MutationOptions } from '@abloatai/transaction/resources/mutationOp
  * `claim` are deliberately absent: both are resolved on the client before a write
  * is staged, so neither reaches this layer.
  */
-export type WriteOptions = Pick<MutationOptions, 'readAt' | 'onStale' | 'idempotencyKey' | 'label' | 'fenceToken' | 'claimRef'>;
+export type WriteOptions = Pick<MutationOptions, 'readAt' | 'idempotencyKey' | 'label' | 'fenceToken' | 'claimRef'>;
 /** A single mutation within a batch. Its `options` travel with it so the server
  *  can cache and replay the operation for idempotent retries. */
 export interface MutationOperation {
@@ -165,7 +164,6 @@ export interface MutationOperation {
     /** Server-issued claim identity the operation is attributed to. */
     claimId?: string | null;
     readAt?: number | null;
-    onStale?: OnStaleMode | null;
     /**
      * The fencing token (Option B) carried on the wire for this op — the held
      * claim's token, validated against the entity's high-water at commit.

package/dist/local/mutators/mutateActions.d.ts

@@ -17,8 +17,9 @@ type UpdatePatch<S extends Schema, K extends keyof S['models'] & string> = {
 } & Partial<InferModel<S, K>>;
 export interface MutateActions<S extends Schema, K extends keyof S['models'] & string> {
     /**
-     * Create one entity, or an array of entities in a single tick. ID,
-     * createdAt, updatedAt, organizationId default automatically per row.
+     * Create one entity, or an array of entities in a single tick. The id and
+     * the tenancy value default per row; every other column, audit timestamps
+     * included, comes from the declared fields.
      */
     create(data: InferCreate<S, K>): Promise<InferModel<S, K>>;
     create(data: InferCreate<S, K>[]): Promise<InferModel<S, K>[]>;

package/dist/local/query/types.d.ts

@@ -13,8 +13,8 @@
  * key — for example, fetching every block whose `sectionId` falls in a set of
  * ids.
  */
-export type { WherePrimitive, WhereOp, WhereClause, LoadWhere, } from '@abloatai/transaction/resources/where';
-import type { WhereClause } from '@abloatai/transaction/resources/where';
+export type { WherePrimitive, WhereOp, WhereClause, LoadWhere, } from '@abloatai/transaction/client/resources/where';
+import type { WhereClause } from '@abloatai/transaction/client/resources/where';
 import type { ModelListEvidence } from '@abloatai/transaction/wire';
 /** A single structured fetch request. */
 export interface Query {

package/dist/local/stores/syncAction.d.ts

@@ -10,10 +10,10 @@ export declare const syncActionSchema: z.ZodObject<{
     modelName: z.ZodString;
     modelId: z.ZodString;
     action: z.ZodEnum<{
+        A: "A";
         I: "I";
         U: "U";
         D: "D";
-        A: "A";
         V: "V";
         C: "C";
         G: "G";

package/dist/local/stores/syncAction.js

@@ -5,7 +5,7 @@
  * schema, while this one adds the local `__class` discriminator IndexedDB uses.
  */
 import { z } from 'zod';
-import { syncDeltaActionSchema } from '@abloatai/transaction/wire/delta';
+import { syncDeltaActionSchema } from '@abloatai/transaction/observation';
 export const syncActionSchema = z.object({
     id: z.number(),
     modelName: z.string(),

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

@@ -5,4 +5,4 @@
  * unchanged; the reactive store mirrors its transitions through
  * `ConnectionCallbacks.onStateChange` into its own observable `syncStatus`.
  */
-export { ConnectionManager, type ConnectionState, type ConnectionEvent, type ConnectionCallbacks, type ConnectionManagerOptions, } from '@abloatai/transaction/transport/connectionManager';
+export { ConnectionManager, type ConnectionState, type ConnectionEvent, type ConnectionCallbacks, type ConnectionManagerOptions, } from '@abloatai/transaction/transport/connection';

package/dist/local/sync/ConnectionManager.js

@@ -5,4 +5,4 @@
  * unchanged; the reactive store mirrors its transitions through
  * `ConnectionCallbacks.onStateChange` into its own observable `syncStatus`.
  */
-export { ConnectionManager, } from '@abloatai/transaction/transport/connectionManager';
+export { ConnectionManager, } from '@abloatai/transaction/transport/connection';

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

@@ -34,7 +34,7 @@ import type { ModelRegistry } from '../ModelRegistry.js';
 import type { RuntimeContext } from '../RuntimeContext.js';
 import type { RecoveryClass } from '@abloatai/transaction/errorCodes';
 import type { LoadWhere, WhereClause } from '../query/types.js';
-import { normalizeWhere } from '@abloatai/transaction/resources/where';
+import { normalizeWhere } from '@abloatai/transaction/client/resources/where';
 import type { Schema } from '@abloatai/transaction/schema/schema';
 import type { LogPositionPort } from '../logPosition.js';
 export interface OnDemandLoaderOptions {

package/dist/local/sync/OnDemandLoader.js

@@ -30,7 +30,7 @@
 import { ModelScope } from '../InstanceCache.js';
 import { AbloValidationError } from '@abloatai/transaction/errors';
 import { postQuery } from '../query/client.js';
-import { normalizeWhere } from '@abloatai/transaction/resources/where';
+import { normalizeWhere } from '@abloatai/transaction/client/resources/where';
 const LOCAL = { kind: 'local' };
 /**
  * The position a returned row provably reflects: the greater of its own

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

@@ -9,10 +9,10 @@
  * and open/close hooks with the materialisation the transport deliberately
  * does not do.
  */
-import { type ClientSyncDelta } from '@abloatai/transaction/wire/delta';
-import { WsTransport, type WsTransportOptions, type EventMap, type DefaultCollaborationEvents } from '@abloatai/transaction/transport/wsTransport';
+import { type ClientSyncDelta } from '@abloatai/transaction/observation';
+import { WsTransport, type WsTransportOptions, type EventMap, type DefaultCollaborationEvents } from '@abloatai/transaction/transport/websocket';
 export type { CommitAck } from './commitFrames.js';
-export type { SyncCapabilities, BootstrapHint, BootstrapDataEvent, PresenceUpdate, CoreSyncEventMap, DefaultCollaborationEvents, EventMap, SyncWebSocketEventMap, } from '@abloatai/transaction/transport/wsTransport';
+export type { SyncCapabilities, BootstrapHint, BootstrapDataEvent, PresenceUpdate, CoreSyncEventMap, DefaultCollaborationEvents, EventMap, SyncWebSocketEventMap, } from '@abloatai/transaction/transport/websocket';
 /**
  * The wire delta the client receives. It is inferred from the canonical
  * `clientSyncDeltaSchema` so the client and server share one contract rather

package/dist/local/sync/SyncWebSocket.js

@@ -10,9 +10,9 @@
  * does not do.
  */
 import { getContext } from '../context.js';
-import { clientSyncDeltaSchema } from '@abloatai/transaction/wire/delta';
+import { clientSyncDeltaSchema } from '@abloatai/transaction/observation';
 import { drainProfilingEnabled, observeDrainStage } from './drainProfile.js';
-import { WsTransport, } from '@abloatai/transaction/transport/wsTransport';
+import { WsTransport, } from '@abloatai/transaction/transport/websocket';
 import { isRecord } from './wsFrameHandlers.js';
 // Sync-position state (lastSyncId watermark, version vector, server cursor).
 import { SyncCursor } from './syncCursor.js';

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

@@ -5,4 +5,4 @@
  * takes the structural `CommitFrameOperation` slice, which this package's
  * `MutationOperation` satisfies.
  */
-export { buildCommitFrame, parseNotifications, recordClaim, type CommitAck, type CommitFrameOperation, type ClaimTracePorts, } from '@abloatai/transaction/transport/commitFrames';
+export { buildCommitFrame, recordClaim, type CommitAck, type CommitFrameOperation, type ClaimTracePorts, } from '@abloatai/transaction/transport/websocket';

package/dist/local/sync/commitFrames.js

@@ -5,4 +5,4 @@
  * takes the structural `CommitFrameOperation` slice, which this package's
  * `MutationOperation` satisfies.
  */
-export { buildCommitFrame, parseNotifications, recordClaim, } from '@abloatai/transaction/transport/commitFrames';
+export { buildCommitFrame, recordClaim, } from '@abloatai/transaction/transport/websocket';

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

@@ -0,0 +1,8 @@
+import type { ReadDependency } from '@abloatai/transaction/coordination';
+import { AbloStaleContextError } from '@abloatai/transaction/errors';
+import type { InstanceCache } from '../InstanceCache.js';
+export interface ContextOnChangeTransport {
+    subscribe(event: string, listener: (value?: unknown) => void): () => void;
+}
+/** Match context reads on the reactive client's existing delta connection. */
+export declare function contextOnChange(transport: ContextOnChangeTransport, pool: Pick<InstanceCache, 'peek' | 'watermarks'>, reads: readonly ReadDependency[], listener: (error: AbloStaleContextError) => void): () => void;

package/dist/local/sync/contextOnChange.js

@@ -0,0 +1,65 @@
+import { AbloStaleContextError } from '@abloatai/transaction/errors';
+/** Match context reads on the reactive client's existing delta connection. */
+export function contextOnChange(transport, pool, reads, listener) {
+    let stopped = false;
+    const rowReads = reads.filter((read) => 'model' in read);
+    const stopDelta = transport.subscribe('delta', (value) => {
+        if (isDelta(value))
+            changedBy([value]);
+    });
+    const stopBatch = transport.subscribe('delta_batch', (value) => {
+        if (Array.isArray(value))
+            changedBy(value.filter(isDelta));
+    });
+    function stop() {
+        if (stopped)
+            return;
+        stopped = true;
+        stopDelta();
+        stopBatch();
+    }
+    function changedBy(deltas) {
+        if (stopped)
+            return;
+        for (const delta of deltas) {
+            const read = rowReads.find((candidate) => candidate.model.toLowerCase() === delta.modelName.toLowerCase() &&
+                candidate.id === delta.modelId &&
+                delta.id > candidate.readAt);
+            if (!read)
+                continue;
+            stop();
+            listener(staleError(read.model, read.id, read.readAt, delta.id));
+            return;
+        }
+    }
+    // Subscribe first, then inspect the resident row. A delta that lands between
+    // the original read and this attachment is either observed above or has
+    // already advanced this exact row in the pool.
+    for (const read of rowReads) {
+        const resident = pool.peek(read.id);
+        if (!resident || resident.getModelName().toLowerCase() !== read.model.toLowerCase()) {
+            continue;
+        }
+        const observed = pool.watermarks.of(resident);
+        if (observed !== undefined && observed > read.readAt) {
+            stop();
+            listener(staleError(read.model, read.id, read.readAt, observed));
+            break;
+        }
+    }
+    return stop;
+}
+function staleError(model, id, readAt, observedSyncId) {
+    return new AbloStaleContextError('Context changed after read.', {
+        code: 'stale_context',
+        readAt,
+        conflicts: [{ model, id, observedSyncId }],
+    });
+}
+function isDelta(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        typeof value.id === 'number' &&
+        typeof value.modelName === 'string' &&
+        typeof value.modelId === 'string');
+}

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

@@ -21,7 +21,7 @@
  *   • Inbound `claim_rejected` — the server refused the claim, with conflict
  *       metadata.
  */
-import type { WsTransport } from '@abloatai/transaction/transport/wsTransport';
+import type { WsTransport } from '@abloatai/transaction/transport/websocket';
 import type { ClaimOptions, Claim, ClaimStream, PresenceTarget } from '@abloatai/transaction/types/streams';
 import { type Logger } from '@abloatai/transaction/logger';
 /**