@abloatai/humans 0.56.0 → 0.58.0

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/mutationInput.d.ts

@@ -0,0 +1,40 @@
+/**
+ * The input a queued mutation carries, derived from a local model.
+ *
+ * Six small rules that answer one question: given a model and what changed on
+ * it, what does the commit actually send? They sat as private methods on
+ * `MutationQueue` because that is where they were called, which is how a queue
+ * ends up also owning the payload vocabulary.
+ *
+ * The before-image rule is the one worth reading twice, and it is stated in
+ * `previousDataFor` rather than here.
+ */
+import type { LocalModel } from '../../localModelContract.js';
+import type { RuntimeContext } from '../../RuntimeContext.js';
+import { type MutationInput } from './commitPayload.js';
+/** A queued transaction's local identity, unique per process and monotonic enough to sort. */
+export declare function generateTransactionId(): string;
+/** Local values win: they are the edit the caller made, remote is the base. */
+export declare function mergeMutationData(local: MutationInput | undefined, remote: MutationInput | undefined): MutationInput;
+/** A create sends the whole row, `undefined` included, so absence is explicit. */
+export declare function createDataFor(model: LocalModel, runtime?: RuntimeContext): MutationInput;
+/** An arbitrary change set, projected the way an update is. */
+export declare function changesToInput(modelName: string, changes: Record<string, unknown>, runtime?: RuntimeContext): MutationInput;
+/** An update sends only what changed. */
+export declare function updateDataFor(model: LocalModel, runtime?: RuntimeContext): MutationInput;
+/**
+ * The before-image an undo reverts to.
+ *
+ * When the update's written keys are known, capture a before-image for exactly
+ * those keys, so the recorded undo inverse reverts them and nothing else — a
+ * full-row inverse would clobber concurrent edits to unrelated fields.
+ * `fallbackToLive: false` makes `Model.capturePreviousValues` omit any key it
+ * cannot resolve, and `buildUndoOps` then drops an un-revertible inverse rather
+ * than inventing one. With no `updateInput` (a full extract) it falls back to
+ * every tracked field.
+ *
+ * Model-specific special cases do not belong here: a model that needs to
+ * surface previous state beyond `modifiedProperties` should expose a typed
+ * `getPreviousData()` accessor for this to call.
+ */
+export declare function previousDataFor(model: LocalModel, updateInput?: MutationInput): MutationInput;

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

@@ -0,0 +1,53 @@
+/**
+ * The input a queued mutation carries, derived from a local model.
+ *
+ * Six small rules that answer one question: given a model and what changed on
+ * it, what does the commit actually send? They sat as private methods on
+ * `MutationQueue` because that is where they were called, which is how a queue
+ * ends up also owning the payload vocabulary.
+ *
+ * The before-image rule is the one worth reading twice, and it is stated in
+ * `previousDataFor` rather than here.
+ */
+import { projectCommitPayload } from './commitPayload.js';
+/** A queued transaction's local identity, unique per process and monotonic enough to sort. */
+export function generateTransactionId() {
+    return `tx_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
+}
+/** Local values win: they are the edit the caller made, remote is the base. */
+export function mergeMutationData(local, remote) {
+    return { ...(remote ?? {}), ...(local ?? {}) };
+}
+/** A create sends the whole row, `undefined` included, so absence is explicit. */
+export function createDataFor(model, runtime) {
+    return projectCommitPayload(model.getModelName(), model.toJSON(), { dropUndefined: false }, runtime);
+}
+/** An arbitrary change set, projected the way an update is. */
+export function changesToInput(modelName, changes, runtime) {
+    return projectCommitPayload(modelName, changes, { dropUndefined: true }, runtime);
+}
+/** An update sends only what changed. */
+export function updateDataFor(model, runtime) {
+    return projectCommitPayload(model.getModelName(), model.getChanges(), { dropUndefined: true }, runtime);
+}
+/**
+ * The before-image an undo reverts to.
+ *
+ * When the update's written keys are known, capture a before-image for exactly
+ * those keys, so the recorded undo inverse reverts them and nothing else — a
+ * full-row inverse would clobber concurrent edits to unrelated fields.
+ * `fallbackToLive: false` makes `Model.capturePreviousValues` omit any key it
+ * cannot resolve, and `buildUndoOps` then drops an un-revertible inverse rather
+ * than inventing one. With no `updateInput` (a full extract) it falls back to
+ * every tracked field.
+ *
+ * Model-specific special cases do not belong here: a model that needs to
+ * surface previous state beyond `modifiedProperties` should expose a typed
+ * `getPreviousData()` accessor for this to call.
+ */
+export function previousDataFor(model, updateInput) {
+    const keys = updateInput
+        ? Object.keys(updateInput)
+        : [...(model.modifiedProperties instanceof Map ? model.modifiedProperties.keys() : [])];
+    return { id: model.id, ...model.capturePreviousValues(keys, { fallbackToLive: false }) };
+}

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", "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,14 +22,14 @@
  */
 export const PUBLIC_MODEL_VERBS = [
     'get',
-    'retrieve',
+    'read',
     'list',
+    'listAll',
     'local',
     'create',
     'update',
     'delete',
     'claim',
-    'track',
     'join',
     'onChange',
 ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abloatai/humans",
-  "version": "0.56.0",
+  "version": "0.58.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.56.0",
+    "@abloatai/transaction": "^0.58.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;
   }
 

package/src/client.ts

@@ -18,19 +18,21 @@ import type {
   InferCreate,
   InferRow,
 } from '@abloatai/transaction/schema/schema';
-import type { PresenceStream, Snapshot } from '@abloatai/transaction/types/streams';
+import type { PresenceStream } from '@abloatai/transaction/types/streams';
 import type { InstanceCache } from './local/InstanceCache.js';
 import type { SyncStoreContract } from './react/context.js';
 import type { SyncWebSocket, CoreSyncEventMap } from './local/sync/SyncWebSocket.js';
 import type { SyncStatus } from './local/BaseSyncedStore.js';
-import type { ModelOperations } from './local/client/createModelProxy.js';
+import type { ModelOperations } from './local/client/createModelOperations.js';
 import type {
   ClaimResource,
   CommitResource,
   CreateAgentClientParams,
   SessionResource,
-} from '@abloatai/transaction/resources/httpResources';
+} from '@abloatai/transaction/client/resources/httpResources';
 import type { EffectiveAuthority } from '@abloatai/transaction/auth';
+import type { ReadDependency } from '@abloatai/transaction/coordination';
+import type { CapturedRow } from '@abloatai/transaction/transport/http';
 export type { LocalReadOptions } from './local/client/resourceTypes.js';
 
 /** The typed sync engine client — one property per model in the schema */
@@ -310,25 +312,7 @@ export type AbloClient<S extends SchemaRecord> = {
    * Canonical low-level mutation API. Every untyped model write compiles
    * down to `commits.create(...)`.
    */
-  readonly commits: CommitResource;
-
-  /**
-   * Capture a context-staleness watermark over a set of entities.
-   * Returns a flat snapshot with `stamp` (thread into writes as
-   * `readAt`), `signal` (aborts on any captured-entity delta), and
-   * `onChange` (callback form). Reads from the engine's InstanceCache;
-   * subscription is on the engine's existing transport.
-   *
-   * Use before an LLM call to prevent the model from completing
-   * against now-stale data:
-   * ```ts
-   * const snap = engine.snapshot({ sections: report.sectionIds });
-   * await streamText({ messages, signal: snap.signal });
-   * ```
-   */
-  snapshot<ModelName extends keyof S & string>(
-    entities: Readonly<Record<ModelName, string | readonly string[]>>,
-  ): Snapshot<Schema<S>, ModelName>;
+  readonly commits: CommitResource<ReadDependency | CapturedRow>;
 
   /**
    * Subscribe to pushed frames — deltas, presence updates, claim grants and

package/src/core.ts

@@ -92,7 +92,7 @@ export {
 export {
   awaitClaimGrant,
   type GrantTransport,
-} from '@abloatai/transaction/coordination/awaitClaimGrant';
+} from '@abloatai/transaction/claims';
 
 // An enum naming the strategies for loading a model's data. Referenced when
 // registering models in extension code.