@abloatai/humans 0.57.0 → 0.59.0

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

@@ -87,17 +87,6 @@ export async function processBatch(ctx) {
                     }));
                     await ctx.persistDurableCommitAcceptance(durableEnvelope, result);
                     const lastSyncId = result.lastSyncId;
-                    const notifications = result.notifications;
-                    const { holdsEntireBatch, heldTargets, notificationsByTarget, } = ctx.classifyReceiptNotifications(batchOps.map(({ op }) => ({ model: op.model, id: op.id })), notifications ?? []);
-                    for (const { tx } of batchOps) {
-                        const txTarget = ctx.receiptTargetKey(tx.modelKey, tx.modelId);
-                        const txNotifs = holdsEntireBatch
-                            ? notifications
-                            : notificationsByTarget.get(txTarget);
-                        if (txNotifs && txNotifs.length > 0) {
-                            ctx.commitNotifications.set(tx.id, txNotifs);
-                        }
-                    }
                     const missingIds = new Set(result.missingIds ?? []);
                     const settlingBatchOps = [];
                     for (const entry of batchOps) {
@@ -106,15 +95,6 @@ export async function processBatch(ctx) {
                             await ctx.handleFailure(tx, new AbloNotFoundError(`${tx.modelName}/${tx.modelId} was not found or is outside this credential's scope.`, [tx.modelId]));
                             continue;
                         }
-                        if (holdsEntireBatch ||
-                            heldTargets.has(ctx.receiptTargetKey(tx.modelKey, tx.modelId))) {
-                            await ctx.rollbackOptimistic(tx, 'conflict_server_wins');
-                            ctx.store.updateStatus(tx.id, 'completed');
-                            ctx.emit('transaction:completed', tx);
-                            ctx.emit(`transaction:completed:${tx.id}`, tx);
-                            ctx.optimisticUpdates.delete(tx.id);
-                            continue;
-                        }
                         settlingBatchOps.push(entry);
                     }
                     // A forwarded write has been accepted, but the source database

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

@@ -1,5 +1,5 @@
-import type { ReadDependency, TrackDependency } from '@abloatai/transaction/coordination/schema';
-import type { DurableCommitEnvelope } from '@abloatai/transaction/transactions/confirmation/commitEnvelope';
+import type { ReadDependency } from '@abloatai/transaction/coordination/schema';
+import type { DurableCommitEnvelope } from '@abloatai/transaction/commit';
 import type { CommitTransaction } from './commitLane.js';
 import type { SealDurableCommitInput } from './commitTransport.js';
 export interface CommitApiContext {
@@ -15,5 +15,4 @@ export interface CommitApiContext {
 }
 export declare function enqueueCommit(ctx: CommitApiContext, clientTxId: string, operations: CommitTransaction['operations'], options?: {
     reads?: ReadDependency[] | null;
-    track?: TrackDependency[] | null;
 }): Promise<void>;

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

@@ -8,12 +8,10 @@ export async function enqueueCommit(ctx, clientTxId, operations, options = {}) {
         const existingIntent = stableStringify({
             operations: existing.operations,
             reads: existing.reads ?? null,
-            track: existing.track ?? null,
         });
         const incomingIntent = stableStringify({
             operations,
             reads: options.reads ?? null,
-            track: options.track ?? null,
         });
         if (existingIntent !== incomingIntent) {
             throw new AbloIdempotencyError('Idempotency key reused with a different atomic commit request', { code: 'idempotency_conflict' });
@@ -34,7 +32,6 @@ export async function enqueueCommit(ctx, clientTxId, operations, options = {}) {
         kind: 'commit',
         operations: [...operations],
         ...(options.reads ? { reads: options.reads } : {}),
-        ...(options.track ? { track: options.track } : {}),
         status: 'pending',
         createdAt: now,
         attempts: 0,
@@ -48,7 +45,6 @@ export async function enqueueCommit(ctx, clientTxId, operations, options = {}) {
         operations: tx.operations,
         commitOptions: {
             ...(tx.reads ? { reads: tx.reads } : {}),
-            ...(tx.track ? { track: tx.track } : {}),
         },
         createdAt: tx.createdAt,
         sealedAt: tx.sealedAt,

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

@@ -1,7 +1,7 @@
 import type { RuntimeContext } from '../../RuntimeContext.js';
-import type { ReadDependency, TrackDependency, OnStaleMode, StaleNotification } from '@abloatai/transaction/coordination/schema';
-import type { CommitOperationResult, MutationCommitResult } from '@abloatai/transaction/wire/commit';
-import type { DurableCommitEnvelope, DurableCommitOperation } from '@abloatai/transaction/transactions/confirmation/commitEnvelope';
+import type { ReadDependency } from '@abloatai/transaction/coordination/schema';
+import type { CommitOperationResult, MutationCommitResult } from '@abloatai/transaction/commit';
+import type { DurableCommitEnvelope, DurableCommitOperation } from '@abloatai/transaction/commit';
 import type { SealDurableCommitInput } from './commitTransport.js';
 export interface CommitTransaction {
     id: string;
@@ -13,10 +13,8 @@ export interface CommitTransaction {
         input?: Record<string, unknown>;
         transactionId?: string;
         readAt?: number | null;
-        onStale?: OnStaleMode | null;
     }[];
     reads?: ReadDependency[] | null;
-    track?: TrackDependency[] | null;
     status: 'pending' | 'executing' | 'awaiting_delta' | 'completed' | 'failed';
     createdAt: number;
     attempts: number;
@@ -44,7 +42,6 @@ export interface CommitLaneContext {
         };
     };
     readonly commitLane: CommitTransaction[];
-    readonly commitNotifications: Map<string, StaleNotification[]>;
     readonly commitMissingIds: Map<string, string[]>;
     readonly commitProcessing: boolean;
     readonly setCommitProcessing: (value: boolean) => void;
@@ -65,7 +62,6 @@ export interface CommitLaneContext {
 }
 export interface CommitReceiptContext {
     readonly commitStore: Map<string, CommitTransaction>;
-    readonly commitNotifications: Map<string, StaleNotification[]>;
     readonly commitMissingIds: Map<string, string[]>;
     readonly replicationLagErrors: Map<string, Error>;
     readonly on: (event: string, listener: (payload: object) => void) => void;
@@ -73,7 +69,6 @@ export interface CommitReceiptContext {
 }
 export declare function waitForCommitReceipt(ctx: CommitReceiptContext, clientTxId: string): Promise<{
     lastSyncId: number;
-    notifications?: StaleNotification[];
     missingIds?: string[];
     operationResults?: CommitOperationResult[];
 }>;

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

@@ -1,12 +1,5 @@
 import { transientRetryDelayMs } from './failureHandling.js';
 export function waitForCommitReceipt(ctx, clientTxId) {
-    const drainNotifications = () => {
-        const notifications = ctx.commitNotifications.get(clientTxId);
-        if (!notifications)
-            return undefined;
-        ctx.commitNotifications.delete(clientTxId);
-        return notifications.length > 0 ? notifications : undefined;
-    };
     const drainMissingIds = () => {
         const ids = ctx.commitMissingIds.get(clientTxId);
         if (!ids)
@@ -18,7 +11,6 @@ export function waitForCommitReceipt(ctx, clientTxId) {
         const missingIds = drainMissingIds();
         return {
             lastSyncId,
-            notifications: drainNotifications(),
             ...(transaction.operationResults
                 ? { operationResults: transaction.operationResults }
                 : {}),
@@ -81,7 +73,6 @@ export async function processCommitLane(ctx) {
                     sourceMutationIds: tx.sourceMutationIds,
                     commitOptions: {
                         ...(tx.reads ? { reads: tx.reads } : {}),
-                        ...(tx.track ? { track: tx.track } : {}),
                     },
                     createdAt: tx.createdAt,
                     sealedAt: tx.sealedAt,
@@ -95,8 +86,6 @@ export async function processCommitLane(ctx) {
                 tx.lastSyncId = result.lastSyncId;
                 if (result.operationResults?.length)
                     tx.operationResults = [...result.operationResults];
-                if (result.notifications?.length)
-                    ctx.commitNotifications.set(tx.id, result.notifications);
                 if (result.missingIds?.length)
                     ctx.commitMissingIds.set(tx.id, result.missingIds);
                 ctx.commitLane.shift();

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

@@ -10,9 +10,8 @@
  */
 import type { RuntimeContext } from '../../RuntimeContext.js';
 import { MutationOperationType } from '@abloatai/transaction/types';
-import type { OnStaleMode } from '@abloatai/transaction/coordination/schema';
 import type { MutationOptions, WriteOptions } from '../../interfaces/index.js';
-import type { CommitEnvelopeMember } from '@abloatai/transaction/transactions/confirmation/commitEnvelope';
+import type { CommitEnvelopeMember } from '@abloatai/transaction/commit';
 export interface UserContext {
     userId: string;
     organizationId: string;
@@ -128,14 +127,13 @@ export declare function hasStaleWriteOptions(options?: WriteOptions): boolean;
 export declare function hasCommitCoalescingBarrier(options?: WriteOptions): boolean;
 export interface WriteOperationFields {
     readAt?: number | null;
-    onStale?: OnStaleMode | null;
     fenceToken?: number | null;
     claimId?: string;
     options?: Pick<MutationOptions, 'idempotencyKey' | 'label'>;
 }
 /**
  * Copies a transaction's `writeOptions` onto the wire operation. The
- * stale-context guards (`readAt` and `onStale`) sit at the operation's root,
+ * stale-context guard (`readAt`) sits at the operation's root,
  * while `idempotencyKey` and `label` go in its `options` slot — the
  * `mutation_log` cache key and audit tag. This is the one place caller-supplied
  * write options cross onto the wire.

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

@@ -104,8 +104,7 @@ export const TX_TYPE_TO_MUTATION_OP = {
     unarchive: MutationOperationType.UNARCHIVE,
 };
 export function hasStaleWriteOptions(options) {
-    return (options?.readAt !== undefined ||
-        options?.onStale !== undefined);
+    return options?.readAt !== undefined;
 }
 /** Options whose identity/audit semantics forbid merging two caller writes. */
 export function hasCommitCoalescingBarrier(options) {
@@ -117,7 +116,7 @@ export function hasCommitCoalescingBarrier(options) {
 }
 /**
  * Copies a transaction's `writeOptions` onto the wire operation. The
- * stale-context guards (`readAt` and `onStale`) sit at the operation's root,
+ * stale-context guard (`readAt`) sits at the operation's root,
  * while `idempotencyKey` and `label` go in its `options` slot — the
  * `mutation_log` cache key and audit tag. This is the one place caller-supplied
  * write options cross onto the wire.
@@ -130,9 +129,6 @@ export function applyWriteOptions(op, transaction) {
     if (writeOptions.readAt !== undefined) {
         operation.readAt = writeOptions.readAt;
     }
-    if (writeOptions.onStale !== undefined) {
-        operation.onStale = writeOptions.onStale;
-    }
     if (writeOptions.fenceToken !== undefined) {
         operation.fenceToken = writeOptions.fenceToken;
     }

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

@@ -1,8 +1,8 @@
 import type { RuntimeContext } from '../../RuntimeContext.js';
 import type { MutationExecutor } from '../../interfaces/index.js';
-import type { ReadDependency, TrackDependency } from '@abloatai/transaction/coordination/schema';
-import { type MutationCommitResult } from '@abloatai/transaction/wire/commit';
-import { type CommitOutboxScope, type DurableCommitEnvelope, type DurableCommitOperation } from '@abloatai/transaction/transactions/confirmation/commitEnvelope';
+import type { ReadDependency } from '@abloatai/transaction/coordination/schema';
+import { type MutationCommitResult } from '@abloatai/transaction/commit';
+import { type CommitOutboxScope, type DurableCommitEnvelope, type DurableCommitOperation } from '@abloatai/transaction/commit';
 import type { DurableWriteStore } from './durableWriteStore.js';
 export interface CommitTransportContext {
     readonly runtime: RuntimeContext;
@@ -22,7 +22,6 @@ export interface SealDurableCommitInput {
     sourceMutationIds?: string[];
     commitOptions?: {
         reads?: readonly ReadDependency[] | null;
-        track?: readonly TrackDependency[] | null;
     };
     createdAt: number;
     sealedAt: number;

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

@@ -1,6 +1,6 @@
 import { AbloConnectionError, AbloError, AbloIdempotencyError, } from '@abloatai/transaction/errors';
-import { mutationCommitResultSchema, } from '@abloatai/transaction/wire/commit';
-import { createDurableCommitEnvelope, commitEnvelopeRecordId, durableCommitEnvelopeSchema, } from '@abloatai/transaction/transactions/confirmation/commitEnvelope';
+import { mutationCommitResultSchema, } from '@abloatai/transaction/commit';
+import { createDurableCommitEnvelope, commitEnvelopeRecordId, durableCommitEnvelopeSchema, } from '@abloatai/transaction/commit';
 export async function sealDurableCommit(ctx, input, pendingMutationRecordId) {
     const sourceMutationIds = [...new Set(input.sourceMutationIds ?? [])];
     const envelope = createDurableCommitEnvelope({
@@ -12,9 +12,6 @@ export async function sealDurableCommit(ctx, input, pendingMutationRecordId) {
             ...(input.commitOptions?.reads !== undefined
                 ? { reads: input.commitOptions.reads === null ? null : [...input.commitOptions.reads] }
                 : {}),
-            ...(input.commitOptions?.track !== undefined
-                ? { track: input.commitOptions.track === null ? null : [...input.commitOptions.track] }
-                : {}),
         },
         ...(ctx.commitOutboxScope ? { scope: ctx.commitOutboxScope } : {}),
         createdAt: input.createdAt,

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

@@ -1,6 +1,6 @@
 import type { RuntimeContext } from '../../RuntimeContext.js';
 import type { CommitTransaction } from './commitLane.js';
-import type { CommitOutboxScope } from '@abloatai/transaction/transactions/confirmation/commitEnvelope';
+import type { CommitOutboxScope } from '@abloatai/transaction/commit';
 import type { DurableWriteStore } from './durableWriteStore.js';
 export interface DurableCommitRestoreContext {
     readonly config: {

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

@@ -1,5 +1,5 @@
 import { AbloIdempotencyError, AbloValidationError } from '@abloatai/transaction/errors';
-import { durableCommitEnvelopeSchema } from '@abloatai/transaction/transactions/confirmation/commitEnvelope';
+import { durableCommitEnvelopeSchema } from '@abloatai/transaction/commit';
 export async function restoreDurableCommits(ctx) {
     if (!ctx.config.enablePersistence)
         return new Set();
@@ -61,9 +61,6 @@ export async function restoreDurableCommits(ctx) {
                 ...(envelope.commitOptions.reads
                     ? { reads: [...envelope.commitOptions.reads] }
                     : {}),
-                ...(envelope.commitOptions.track
-                    ? { track: [...envelope.commitOptions.track] }
-                    : {}),
                 status: 'pending',
                 createdAt: envelope.createdAt,
                 sealedAt: envelope.sealedAt,

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

@@ -6,9 +6,9 @@
  *
  * The port and its config live in the core's `durableWrites` module (a behavior
  * contract, not a persisted shape); the records that cross it are owned by
- * `transactions/confirmation/pendingWrite`.
+ * `commit/confirmation/pendingWrite`.
  */
-export { durableWriteStoreSchema, durableWritesConfigSchema, } from '@abloatai/transaction/durableWrites';
-export type { DurableWriteStore, DurableWritesConfig, } from '@abloatai/transaction/durableWrites';
-export { pendingWriteSchema } from '@abloatai/transaction/transactions/confirmation/pendingWrite';
-export type { PendingWrite } from '@abloatai/transaction/transactions/confirmation/pendingWrite';
+export { durableWriteStoreSchema, durableWritesConfigSchema, } from '@abloatai/transaction/commit';
+export type { DurableWriteStore, DurableWritesConfig, } from '@abloatai/transaction/commit';
+export { pendingWriteSchema } from '@abloatai/transaction/commit';
+export type { PendingWrite } from '@abloatai/transaction/commit';

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

@@ -6,7 +6,7 @@
  *
  * The port and its config live in the core's `durableWrites` module (a behavior
  * contract, not a persisted shape); the records that cross it are owned by
- * `transactions/confirmation/pendingWrite`.
+ * `commit/confirmation/pendingWrite`.
  */
-export { durableWriteStoreSchema, durableWritesConfigSchema, } from '@abloatai/transaction/durableWrites';
-export { pendingWriteSchema } from '@abloatai/transaction/transactions/confirmation/pendingWrite';
+export { durableWriteStoreSchema, durableWritesConfigSchema, } from '@abloatai/transaction/commit';
+export { pendingWriteSchema } from '@abloatai/transaction/commit';

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

@@ -3,11 +3,11 @@ import type { MutationQueueConfig } from './MutationQueue.js';
 import type { MutationStore } from './MutationStore.js';
 export declare function isPermanentError(error: Error): boolean;
 export declare function isDefinitiveRejection(error: Error): boolean;
-export interface ConflictPolicyContext {
+export interface ConflictResolutionContext {
     readonly config: Pick<MutationQueueConfig, 'conflictResolution'>;
     readonly store: MutationStore;
     readonly rollbackOptimistic: (transaction: QueuedMutation, reason: string) => Promise<void>;
     readonly mergeData: (local: MutationInput | undefined, remote: MutationInput) => MutationInput;
     readonly enqueue: (transaction: QueuedMutation) => void;
 }
-export declare function handleConflict(ctx: ConflictPolicyContext, transaction: QueuedMutation, serverData: MutationInput): Promise<void>;
+export declare function handleConflict(ctx: ConflictResolutionContext, transaction: QueuedMutation, serverData: MutationInput): Promise<void>;

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

@@ -1,7 +1,7 @@
 import type { RuntimeContext } from '../../RuntimeContext.js';
 import type { MutationPersistencePort } from '../../mutationPersistence.js';
 import type { MutationQueueConfig } from './MutationQueue.js';
-import type { CommitOutboxScope } from '@abloatai/transaction/transactions/confirmation/commitEnvelope';
+import type { CommitOutboxScope } from '@abloatai/transaction/commit';
 import type { QueuedMutation } from './commitPayload.js';
 import { MutationStore } from './MutationStore.js';
 import { deserializePersistedTransaction } from './replayValidation.js';

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

@@ -2,8 +2,8 @@ import type { RuntimeContext } from '../../RuntimeContext.js';
 import type { QueuedMutation } from './commitPayload.js';
 import type { MutationStore } from './MutationStore.js';
 import type { OptimisticUpdateEntry } from './localMutation.js';
-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 PendingDrainContext {
     readonly runtime: RuntimeContext;
     readonly config: {

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

@@ -56,11 +56,6 @@ export declare const persistedTransactionSchema: z.ZodObject<{
     sourceMutationIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
     writeOptions: z.ZodOptional<z.ZodObject<{
         readAt: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-        onStale: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
-            reject: "reject";
-            overwrite: "overwrite";
-            notify: "notify";
-        }>>>;
         idempotencyKey: z.ZodOptional<z.ZodString>;
         label: z.ZodOptional<z.ZodString>;
         fenceToken: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
@@ -102,11 +97,6 @@ export declare const persistedMutationSchema: z.ZodObject<{
     capturedChanges: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     writeOptions: z.ZodOptional<z.ZodObject<{
         readAt: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-        onStale: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
-            reject: "reject";
-            overwrite: "overwrite";
-            notify: "notify";
-        }>>>;
         idempotencyKey: z.ZodOptional<z.ZodString>;
         label: z.ZodOptional<z.ZodString>;
         fenceToken: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
@@ -141,11 +131,6 @@ export declare const legacyPendingMutationRecordSchema: z.ZodObject<{
         capturedChanges: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         writeOptions: z.ZodOptional<z.ZodObject<{
             readAt: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-            onStale: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
-                reject: "reject";
-                overwrite: "overwrite";
-                notify: "notify";
-            }>>>;
             idempotencyKey: z.ZodOptional<z.ZodString>;
             label: z.ZodOptional<z.ZodString>;
             fenceToken: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
@@ -179,11 +164,6 @@ export declare const pendingMutationRecordSchema: z.ZodObject<{
         capturedChanges: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         writeOptions: z.ZodOptional<z.ZodObject<{
             readAt: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-            onStale: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
-                reject: "reject";
-                overwrite: "overwrite";
-                notify: "notify";
-            }>>>;
             idempotencyKey: z.ZodOptional<z.ZodString>;
             label: z.ZodOptional<z.ZodString>;
             fenceToken: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;

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

@@ -17,13 +17,11 @@
 import { z } from 'zod';
 import { computePriorityScore, normalizeModelKey } from './commitPayload.js';
 import { globalRuntime } from '../../context.js';
-import { commitEnvelopeMemberSchema, commitOutboxScopeSchema, } from '@abloatai/transaction/transactions/confirmation/commitEnvelope';
-import { onStaleModeSchema } from '@abloatai/transaction/coordination/schema';
+import { commitEnvelopeMemberSchema, commitOutboxScopeSchema, } from '@abloatai/transaction/commit';
 /** The subset of a write's options that is stored with each transaction or queued mutation. */
 const persistedWriteOptionsSchema = z
     .object({
     readAt: z.number().nullable().optional(),
-    onStale: onStaleModeSchema.nullable().optional(),
     idempotencyKey: z.string().optional(),
     label: z.string().optional(),
     // Aligned with the `WriteOptions` type: a claimed write persisted locally

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

@@ -1,4 +1,3 @@
-import type { OnStaleMode } from '@abloatai/transaction/coordination/schema';
 type ModelData = Record<string, unknown>;
 /** One mutation retained in the durable local transaction journal. */
 interface PersistedMutation {
@@ -8,7 +7,6 @@ interface PersistedMutation {
     timestamp: string;
     writeOptions?: {
         readAt?: number | null;
-        onStale?: OnStaleMode | null;
     };
 }
 /**

package/dist/plugin.d.ts

@@ -17,9 +17,9 @@ import type { ParticipantKind } from '@abloatai/transaction/types/participant';
 import type { ErrorCodeSpec } from '@abloatai/transaction/errorCodes';
 import type { Logger } from '@abloatai/transaction/logger';
 import type { CoordinationObservability } from '@abloatai/transaction/observability';
-import type { WsTransport } from '@abloatai/transaction/transport/wsTransport';
+import type { WsTransport } from '@abloatai/transaction/transport/websocket';
 import type { AuthCredentialSource } from '@abloatai/transaction/auth/credentialSource';
-import type { SyncDeltaWireCore } from '@abloatai/transaction/wire/delta';
+import type { SyncDeltaWireCore } from '@abloatai/transaction/observation';
 import type { ModelData } from '@abloatai/transaction/types/modelData';
 /**
  * A string type that keeps literal inference alive: `id: 'humans'` stays the

package/dist/presenceStream.d.ts

@@ -22,7 +22,7 @@
  *   • Inbound — the same frame, with `kind` one of `enter`, `update`, or
  *       `leave`.
  */
-import type { WsTransport } from '@abloatai/transaction/transport/wsTransport';
+import type { WsTransport } from '@abloatai/transaction/transport/websocket';
 import type { PresenceStream } from '@abloatai/transaction/types/streams';
 import type { ParticipantKind } from '@abloatai/transaction/types/participant';
 /**

package/dist/react/createAbloReact.d.ts

@@ -23,7 +23,7 @@ import { type ReactElement } from 'react';
 import { type AbloProviderProps } from './AbloProvider.js';
 import { type AbloSelector, type ModelClientSelector, type UseAbloHydratedModelResult, type UseAbloModelOptions, type UseAbloModelResult } from './useAblo.js';
 import type { AbloClient as Ablo } from '../client.js';
-import type { ModelOperations } from '../local/client/createModelProxy.js';
+import type { ModelOperations } from '../local/client/createModelOperations.js';
 import type { Schema, SchemaRecord } from '@abloatai/transaction/schema/schema';
 /** What a binding returns: the provider and the hook, with `S` fixed. */
 export interface AbloReactBinding<S extends SchemaRecord> {

package/dist/react/useAblo.d.ts

@@ -1,6 +1,6 @@
 import type { AbloClient as Ablo, AbloReads } from '../client.js';
 import type { ModelClaim } from '@abloatai/transaction/coordination';
-import { type ModelOperations } from '../local/client/createModelProxy.js';
+import { type ModelOperations } from '../local/client/createModelOperations.js';
 import type { SchemaRecord } from '@abloatai/transaction/schema/schema';
 import type { ResolveSchema } from '@abloatai/transaction/types/global';
 /**
@@ -54,7 +54,7 @@ export type UseAbloHydratedModelResult<T> = Omit<UseAbloModelResult<T>, 'data'>
  * // With the Register augmentation (recommended):
  * const ablo = useAblo();
  * if (!ablo) return <Loading />;
- * const doc = await ablo.records.get({ id }); // async server read
+ * const doc = await ablo.records.get({ id }); // observational async server read
  *
  * // Reactive selector (a synchronous local snapshot). The selector's reads
  * // are typed as snapshot rows — data fields + computeds, no relation

package/dist/react/useAblo.js

@@ -1,7 +1,7 @@
 'use client';
 import { useContext, useEffect, useState } from 'react';
 import { AbloInternalContext } from './internalContext.js';
-import { getModelClientMeta, } from '../local/client/createModelProxy.js';
+import { getModelClientMeta, } from '../local/client/createModelOperations.js';
 import { Model } from '../local/Model.js';
 import { useReactive } from '../useReactive.js';
 const EMPTY_CLAIMS = Object.freeze([]);

package/dist/surface.d.ts

@@ -19,7 +19,7 @@
  * tuple, so it is the one list of model-verb names a generated summary can
  * describe.
  */
-export declare const PUBLIC_MODEL_VERBS: readonly ["get", "retrieve", "list", "listAll", "local", "create", "update", "delete", "claim", "track", "join", "onChange"];
+export declare const PUBLIC_MODEL_VERBS: readonly ["get", "read", "list", "listAll", "local", "create", "update", "delete", "claim", "join", "onChange"];
 /**
  * The option keys accepted by `local.list` and `onChange`, matching the
  * keys of {@link LocalReadOptions}. Note that the lifecycle filter is named

package/dist/surface.js

@@ -22,7 +22,7 @@
  */
 export const PUBLIC_MODEL_VERBS = [
     'get',
-    'retrieve',
+    'read',
     'list',
     'listAll',
     'local',
@@ -30,7 +30,6 @@ export const PUBLIC_MODEL_VERBS = [
     'update',
     'delete',
     'claim',
-    'track',
     'join',
     'onChange',
 ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abloatai/humans",
-  "version": "0.57.0",
+  "version": "0.59.0",
   "description": "The optional human-facing local-state package for Ablo: presence, live queries, and React bindings.",
   "license": "Apache-2.0",
   "type": "module",
@@ -84,7 +84,7 @@
     "directory": "packages/humans"
   },
   "dependencies": {
-    "@abloatai/transaction": "^0.57.0",
+    "@abloatai/transaction": "^0.59.0",
     "mobx": "^6.13.7",
     "uuid": "^11.1.0",
     "zod": "^4.4.3"

package/src/Ablo.ts

@@ -224,7 +224,7 @@ export function Ablo<const S extends SchemaRecord>(
 //
 // One default import, with types hung underneath via namespace dots:
 // `import { Ablo } from "@abloatai/humans"` gets the factory, its return type, and
-// every type a typical consumer references (`Ablo.Peer`, `Ablo.Snapshot<S, K>`,
+// every type a typical consumer references (`Ablo.Peer`,
 // and so on) — all purely type-level, with zero runtime cost.
 //
 // The types still live in their canonical homes (`types/streams`, `principal`,
@@ -233,7 +233,6 @@ export function Ablo<const S extends SchemaRecord>(
 
 import type * as _Streams from '@abloatai/transaction/types/streams';
 import type * as _Participants from './local/sync/participants.js';
-import type * as _Policy from '@abloatai/transaction/policy/types';
 import type * as _Mutators from './local/mutators/defineMutators.js';
 import type * as _Tx from './local/mutators/Transaction.js';
 import type * as _Undo from './local/mutators/UndoManager.js';
@@ -292,12 +291,6 @@ export namespace Ablo {
   export type ClaimHeartbeat = _Streams.ClaimHeartbeat;
   export type ClaimHeartbeatOptions = _Streams.ClaimHeartbeatOptions;
 
-  // ── Singletons (flat — no cohort) ─────────────────────────────────
-  export type Snapshot<
-    TSchema extends _SchemaTypes.Schema = _SchemaTypes.Schema,
-    K extends keyof TSchema['models'] = keyof TSchema['models'],
-  > = _Streams.Snapshot<TSchema, K>;
-
   // ── Auth (sub-namespace — actor attribution) ──────────────────────
   // eslint-disable-next-line @typescript-eslint/no-namespace
   export namespace Auth {
@@ -359,17 +352,6 @@ export namespace Ablo {
     export type InferModelNames<S extends _SchemaTypes.Schema> = _SchemaTypes.InferModelNames<S>;
   }
 
-  // ── Conflict (type + sub-namespace via declaration merge) ─────────
-  export type Conflict = _Policy.Conflict;
-  // eslint-disable-next-line @typescript-eslint/no-namespace
-  export namespace Conflict {
-    export type Kind = _Policy.ConflictKind;
-    export type Operation = _Policy.ConflictOperation;
-    export type Decision = _Policy.ConflictDecision;
-    export type Policy = _Policy.ConflictPolicy;
-    export type Axis = _Policy.ConflictAxis;
-  }
-
   // ── Commit (sub-namespace — write-side cohort) ────────────────────
   // eslint-disable-next-line @typescript-eslint/no-namespace
   export namespace Commit {
@@ -389,11 +371,11 @@ export namespace Ablo {
     export type CreateOptions = import('./local/client/resourceTypes.js').ClaimCreateOptions;
     export type WaitOptions = import('./local/client/resourceTypes.js').ClaimWaitOptions;
     export type ContentionOptions =
-      import('@abloatai/transaction/resources/modelOperations').ClaimContentionOptions;
+      import('@abloatai/transaction/client/resources/modelOperations').ClaimContentionOptions;
     export type AttemptEvent =
-      import('@abloatai/transaction/resources/modelOperations').ClaimAttemptEvent;
+      import('@abloatai/transaction/client/resources/modelOperations').ClaimAttemptEvent;
     export type QueueView =
-      import('@abloatai/transaction/resources/modelOperations').ClaimQueueView;
+      import('@abloatai/transaction/client/resources/modelOperations').ClaimQueueView;
     export type Client = import('./local/client/resourceTypes.js').ClaimResource;
   }
 
@@ -402,18 +384,18 @@ export namespace Ablo {
   export namespace Model {
     export type Target = import('./local/client/resourceTypes.js').ModelTarget;
     export type Claim = import('./local/client/resourceTypes.js').ModelClaim;
-    export type Operations<T, CreateInput = T> = import('./local/client/createModelProxy.js').ModelOperations<
+    export type Operations<T, CreateInput = T> = import('./local/client/createModelOperations.js').ModelOperations<
       T,
       CreateInput
     >;
     export type ClaimOptions<T = Record<string, unknown>> =
-      import('./local/client/createModelProxy.js').ClaimOptions<T>;
+      import('./local/client/createModelOperations.js').ClaimOptions<T>;
     export type ClaimParams<T = Record<string, unknown>> =
-      import('./local/client/createModelProxy.js').ClaimParams<T>;
+      import('./local/client/createModelOperations.js').ClaimParams<T>;
     export type ClaimLookupParams<T = Record<string, unknown>> =
-      import('./local/client/createModelProxy.js').ClaimLookupParams<T>;
+      import('./local/client/createModelOperations.js').ClaimLookupParams<T>;
     export type ClaimReorderParams<T = Record<string, unknown>> =
-      import('./local/client/createModelProxy.js').ClaimReorderParams<T>;
+      import('./local/client/createModelOperations.js').ClaimReorderParams<T>;
     export type MutationOptions = import('./local/client/resourceTypes.js').ModelMutationOptions;
   }