@abloatai/humans 0.56.0 → 0.58.0

package/src/local/transactions/mutations/commitApi.ts

@@ -1,7 +1,7 @@
 import { AbloIdempotencyError } from '@abloatai/transaction/errors';
-import type { ReadDependency, TrackDependency } from '@abloatai/transaction/coordination/schema';
+import type { ReadDependency } from '@abloatai/transaction/coordination/schema';
 import { stableStringify } from '@abloatai/transaction/utils/json';
-import type { DurableCommitEnvelope } from '@abloatai/transaction/transactions/confirmation/commitEnvelope';
+import type { DurableCommitEnvelope } from '@abloatai/transaction/commit';
 import type { CommitTransaction } from './commitLane.js';
 import type { SealDurableCommitInput } from './commitTransport.js';
 
@@ -21,7 +21,7 @@ export async function enqueueCommit(
   ctx: CommitApiContext,
   clientTxId: string,
   operations: CommitTransaction['operations'],
-  options: { reads?: ReadDependency[] | null; track?: TrackDependency[] | null } = {},
+  options: { reads?: ReadDependency[] | null } = {},
 ): Promise<void> {
   ctx.assertDurableReplayOpen();
   const existing = ctx.commitStore.get(clientTxId);
@@ -30,12 +30,10 @@ export async function enqueueCommit(
     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(
@@ -59,7 +57,6 @@ export async function enqueueCommit(
     kind: 'commit',
     operations: [...operations],
     ...(options.reads ? { reads: options.reads } : {}),
-    ...(options.track ? { track: options.track } : {}),
     status: 'pending',
     createdAt: now,
     attempts: 0,
@@ -73,7 +70,6 @@ export async function enqueueCommit(
     operations: tx.operations,
     commitOptions: {
       ...(tx.reads ? { reads: tx.reads } : {}),
-      ...(tx.track ? { track: tx.track } : {}),
     },
     createdAt: tx.createdAt,
     sealedAt: tx.sealedAt,

package/src/local/transactions/mutations/commitLane.ts

@@ -1,10 +1,13 @@
 import type { RuntimeContext } from '../../RuntimeContext.js';
-import type { ReadDependency, TrackDependency, OnStaleMode, StaleNotification } from '@abloatai/transaction/coordination/schema';
-import type { MutationCommitResult } from '@abloatai/transaction/wire/commit';
+import type { ReadDependency } from '@abloatai/transaction/coordination/schema';
+import type {
+  CommitOperationResult,
+  MutationCommitResult,
+} from '@abloatai/transaction/commit';
 import type {
   DurableCommitEnvelope,
   DurableCommitOperation,
-} from '@abloatai/transaction/transactions/confirmation/commitEnvelope';
+} from '@abloatai/transaction/commit';
 import type { SealDurableCommitInput } from './commitTransport.js';
 import { transientRetryDelayMs } from './failureHandling.js';
 
@@ -18,16 +21,16 @@ 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;
   transientAttempts?: number;
   firstTransientFailureAt?: number;
   lastSyncId?: number;
+  /** Fresh transport rows. Deliberately transient: durable server replays redact row data. */
+  operationResults?: CommitOperationResult[];
   correlationId?: string;
   error?: Error;
   sealedAt: number;
@@ -45,7 +48,6 @@ export interface CommitLaneContext {
     retryBackoff: { baseMs: number; capMs: number };
   };
   readonly commitLane: CommitTransaction[];
-  readonly commitNotifications: Map<string, StaleNotification[]>;
   readonly commitMissingIds: Map<string, string[]>;
   readonly commitProcessing: boolean;
   readonly setCommitProcessing: (value: boolean) => void;
@@ -67,7 +69,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;
@@ -77,34 +78,38 @@ export interface CommitReceiptContext {
 export function waitForCommitReceipt(
   ctx: CommitReceiptContext,
   clientTxId: string,
-): Promise<{ lastSyncId: number; notifications?: StaleNotification[]; missingIds?: string[] }> {
-  const drainNotifications = (): StaleNotification[] | undefined => {
-    const notifications = ctx.commitNotifications.get(clientTxId);
-    if (!notifications) return undefined;
-    ctx.commitNotifications.delete(clientTxId);
-    return notifications.length > 0 ? notifications : undefined;
-  };
+): Promise<{
+  lastSyncId: number;
+  missingIds?: string[];
+  operationResults?: CommitOperationResult[];
+}> {
   const drainMissingIds = (): string[] | undefined => {
     const ids = ctx.commitMissingIds.get(clientTxId);
     if (!ids) return undefined;
     ctx.commitMissingIds.delete(clientTxId);
     return ids.length > 0 ? ids : undefined;
   };
-  const receipt = (lastSyncId: number) => {
+  const receipt = (transaction: CommitTransaction, lastSyncId: number) => {
     const missingIds = drainMissingIds();
     return {
       lastSyncId,
-      notifications: drainNotifications(),
+      ...(transaction.operationResults
+        ? { operationResults: transaction.operationResults }
+        : {}),
       ...(missingIds ? { missingIds } : {}),
     };
   };
   return new Promise((resolve, reject) => {
     const existing = ctx.commitStore.get(clientTxId);
-    if (existing?.status === 'completed') { resolve(receipt(existing.lastSyncId ?? 0)); return; }
+    if (existing?.status === 'completed') { resolve(receipt(existing, existing.lastSyncId ?? 0)); return; }
     if (existing?.status === 'failed' && existing.error) { reject(existing.error); return; }
     const lagError = ctx.replicationLagErrors.get(clientTxId);
     if (lagError) { reject(lagError); return; }
-    const onCompleted = (tx: object) => { cleanup(); resolve(receipt((tx as CommitTransaction).lastSyncId ?? 0)); };
+    const onCompleted = (tx: object) => {
+      cleanup();
+      const completed = tx as CommitTransaction;
+      resolve(receipt(completed, completed.lastSyncId ?? 0));
+    };
     const onFailed = (payload: object) => { cleanup(); reject((payload as { error: Error }).error); };
     const onLagged = (payload: object) => { cleanup(); reject((payload as { error: Error }).error); };
     const cleanup = () => {
@@ -140,7 +145,6 @@ export async function processCommitLane(ctx: CommitLaneContext): Promise<void> {
           sourceMutationIds: tx.sourceMutationIds,
           commitOptions: {
             ...(tx.reads ? { reads: tx.reads } : {}),
-            ...(tx.track ? { track: tx.track } : {}),
           },
           createdAt: tx.createdAt,
           sealedAt: tx.sealedAt,
@@ -152,7 +156,7 @@ export async function processCommitLane(ctx: CommitLaneContext): Promise<void> {
         const result = await ctx.dispatchCommit(durableEnvelope);
         tx.durableEnvelope = await ctx.persistDurableCommitAcceptance(durableEnvelope, result);
         tx.lastSyncId = result.lastSyncId;
-        if (result.notifications?.length) ctx.commitNotifications.set(tx.id, result.notifications);
+        if (result.operationResults?.length) tx.operationResults = [...result.operationResults];
         if (result.missingIds?.length) ctx.commitMissingIds.set(tx.id, result.missingIds);
         ctx.commitLane.shift();
         if (result.status === 'queued') {

package/src/local/transactions/mutations/commitPayload.ts

@@ -13,9 +13,8 @@ import { globalRuntime } from '../../context.js';
 import type { RuntimeContext } from '../../RuntimeContext.js';
 import { MutationOperationType } from '@abloatai/transaction/types';
 import { snapshotJsonValue } from '@abloatai/transaction/utils/json';
-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;
@@ -198,10 +197,7 @@ export const TX_TYPE_TO_MUTATION_OP: Record<QueuedMutation['type'], MutationOper
 };
 
 export function hasStaleWriteOptions(options?: WriteOptions): boolean {
-  return (
-    options?.readAt !== undefined ||
-    options?.onStale !== undefined
-  );
+  return options?.readAt !== undefined;
 }
 
 /** Options whose identity/audit semantics forbid merging two caller writes. */
@@ -217,7 +213,6 @@ export function hasCommitCoalescingBarrier(options?: WriteOptions): boolean {
 
 export interface WriteOperationFields {
   readAt?: number | null;
-  onStale?: OnStaleMode | null;
   fenceToken?: number | null;
   claimId?: string;
   options?: Pick<MutationOptions, 'idempotencyKey' | 'label'>;
@@ -225,7 +220,7 @@ export interface WriteOperationFields {
 
 /**
  * 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.
@@ -240,9 +235,6 @@ export function applyWriteOptions<T extends object>(
   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/src/local/transactions/mutations/commitTransport.ts

@@ -1,6 +1,6 @@
 import type { RuntimeContext } from '../../RuntimeContext.js';
 import type { MutationExecutor } from '../../interfaces/index.js';
-import type { ReadDependency, TrackDependency } from '@abloatai/transaction/coordination/schema';
+import type { ReadDependency } from '@abloatai/transaction/coordination/schema';
 import {
   AbloConnectionError,
   AbloError,
@@ -9,7 +9,7 @@ import {
 import {
   mutationCommitResultSchema,
   type MutationCommitResult,
-} from '@abloatai/transaction/wire/commit';
+} from '@abloatai/transaction/commit';
 import {
   createDurableCommitEnvelope,
   commitEnvelopeRecordId,
@@ -17,7 +17,7 @@ import {
   type CommitOutboxScope,
   type DurableCommitEnvelope,
   type DurableCommitOperation,
-} from '@abloatai/transaction/transactions/confirmation/commitEnvelope';
+} from '@abloatai/transaction/commit';
 import type { DurableWriteStore } from './durableWriteStore.js';
 
 export interface CommitTransportContext {
@@ -39,7 +39,6 @@ export interface SealDurableCommitInput {
   sourceMutationIds?: string[];
   commitOptions?: {
     reads?: readonly ReadDependency[] | null;
-    track?: readonly TrackDependency[] | null;
   };
   createdAt: number;
   sealedAt: number;
@@ -63,9 +62,6 @@ export async function sealDurableCommit(
       ...(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/src/local/transactions/mutations/durableCommitRestore.ts

@@ -1,9 +1,9 @@
 import { AbloIdempotencyError, AbloValidationError } from '@abloatai/transaction/errors';
 import type { RuntimeContext } from '../../RuntimeContext.js';
 import type { CommitTransaction } from './commitLane.js';
-import type { DurableCommitEnvelope, CommitOutboxScope } from '@abloatai/transaction/transactions/confirmation/commitEnvelope';
+import type { DurableCommitEnvelope, CommitOutboxScope } from '@abloatai/transaction/commit';
 import type { DurableWriteStore } from './durableWriteStore.js';
-import { durableCommitEnvelopeSchema } from '@abloatai/transaction/transactions/confirmation/commitEnvelope';
+import { durableCommitEnvelopeSchema } from '@abloatai/transaction/commit';
 
 export interface DurableCommitRestoreContext {
   readonly config: { enablePersistence: boolean };
@@ -95,9 +95,6 @@ export async function restoreDurableCommits(ctx: DurableCommitRestoreContext): P
           ...(envelope.commitOptions.reads
             ? { reads: [...envelope.commitOptions.reads] }
             : {}),
-          ...(envelope.commitOptions.track
-            ? { track: [...envelope.commitOptions.track] }
-            : {}),
           status: 'pending',
           createdAt: envelope.createdAt,
           sealedAt: envelope.sealedAt,

package/src/local/transactions/mutations/durableWriteStore.ts

@@ -6,16 +6,16 @@
  *
  * 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';
+} from '@abloatai/transaction/commit';
 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';
+} from '@abloatai/transaction/commit';
+export { pendingWriteSchema } from '@abloatai/transaction/commit';
+export type { PendingWrite } from '@abloatai/transaction/commit';

package/src/local/transactions/mutations/failurePolicy.ts

@@ -25,7 +25,7 @@ export function isDefinitiveRejection(error: Error): boolean {
   return status !== undefined && status >= 400 && status < 500 && status !== 429;
 }
 
-export interface ConflictPolicyContext {
+export interface ConflictResolutionContext {
   readonly config: Pick<MutationQueueConfig, 'conflictResolution'>;
   readonly store: MutationStore;
   readonly rollbackOptimistic: (transaction: QueuedMutation, reason: string) => Promise<void>;
@@ -34,7 +34,7 @@ export interface ConflictPolicyContext {
 }
 
 export async function handleConflict(
-  ctx: ConflictPolicyContext,
+  ctx: ConflictResolutionContext,
   transaction: QueuedMutation,
   serverData: MutationInput,
 ): Promise<void> {

package/src/local/transactions/mutations/mutationInput.ts

@@ -0,0 +1,69 @@
+/**
+ * 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 { projectCommitPayload, type MutationInput } from './commitPayload.js';
+
+/** A queued transaction's local identity, unique per process and monotonic enough to sort. */
+export function generateTransactionId(): string {
+  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: MutationInput | undefined,
+  remote: MutationInput | undefined,
+): MutationInput {
+  return { ...(remote ?? {}), ...(local ?? {}) };
+}
+
+/** A create sends the whole row, `undefined` included, so absence is explicit. */
+export function createDataFor(model: LocalModel, runtime?: RuntimeContext): MutationInput {
+  return projectCommitPayload(model.getModelName(), model.toJSON(), { dropUndefined: false }, runtime);
+}
+
+/** An arbitrary change set, projected the way an update is. */
+export function changesToInput(
+  modelName: string,
+  changes: Record<string, unknown>,
+  runtime?: RuntimeContext,
+): MutationInput {
+  return projectCommitPayload(modelName, changes, { dropUndefined: true }, runtime);
+}
+
+/** An update sends only what changed. */
+export function updateDataFor(model: LocalModel, runtime?: RuntimeContext): MutationInput {
+  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: LocalModel, updateInput?: MutationInput): MutationInput {
+  const keys = updateInput
+    ? Object.keys(updateInput)
+    : [...(model.modifiedProperties instanceof Map ? model.modifiedProperties.keys() : [])];
+  return { id: model.id, ...model.capturePreviousValues(keys, { fallbackToLive: false }) };
+}

package/src/local/transactions/mutations/mutationPersistence.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 { normalizeModelKey } from './commitPayload.js';

package/src/local/transactions/mutations/pendingDrain.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';
 import { applyWriteOptions, TX_TYPE_TO_MUTATION_OP } from './commitPayload.js';
 
 export interface PendingDrainContext {

package/src/local/transactions/mutations/replayValidation.ts

@@ -23,14 +23,12 @@ import type { RuntimeContext } from '../../RuntimeContext.js';
 import {
   commitEnvelopeMemberSchema,
   commitOutboxScopeSchema,
-} from '@abloatai/transaction/transactions/confirmation/commitEnvelope';
-import { onStaleModeSchema } from '@abloatai/transaction/coordination/schema';
+} 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/src/local/transactions/persistedTransaction.ts

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

package/src/plugin.ts

@@ -19,9 +19,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';
 
 /**

package/src/presenceStream.ts

@@ -23,8 +23,8 @@
  *       `leave`.
  */
 
-import type { WsTransport } from '@abloatai/transaction/transport/wsTransport';
-import type { PresenceUpdate } from '@abloatai/transaction/transport/wsTransport';
+import type { WsTransport } from '@abloatai/transaction/transport/websocket';
+import type { PresenceUpdate } from '@abloatai/transaction/transport/websocket';
 import type {
   Activity,
   Peer,

package/src/react/createAbloReact.ts

@@ -36,7 +36,7 @@ import {
   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. */

package/src/react/useAblo.ts

@@ -7,7 +7,7 @@ import type { ModelClaim } from '@abloatai/transaction/coordination';
 import {
   getModelClientMeta,
   type ModelOperations,
-} from '../local/client/createModelProxy.js';
+} from '../local/client/createModelOperations.js';
 import { Model } from '../local/Model.js';
 import type { SchemaRecord } from '@abloatai/transaction/schema/schema';
 import type { ResolveSchema } from '@abloatai/transaction/types/global';
@@ -138,7 +138,7 @@ function snapshotValue<T>(value: T): T {
  * // 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/src/surface.ts

@@ -14,7 +14,7 @@
  * written by hand, since prose cannot be type-checked.
  */
 
-import type { ModelOperations, LocalReadOptions } from './local/client/createModelProxy.js';
+import type { ModelOperations, LocalReadOptions } from './local/client/createModelOperations.js';
 import type { AbloOptions } from './Ablo.js';
 
 // ── compile-time exact-equality (no runtime, no casts) ─────────────────────
@@ -33,14 +33,14 @@ type Expect<T extends true> = T;
  */
 export const PUBLIC_MODEL_VERBS = [
   'get',
-  'retrieve',
+  'read',
   'list',
+  'listAll',
   'local',
   'create',
   'update',
   'delete',
   'claim',
-  'track',
   'join',
   'onChange',
 ] as const;

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

@@ -1,29 +0,0 @@
-/**
- * Captures a local {@link Snapshot} of a chosen set of entities, along with a
- * watermark, so a caller can detect when that state has gone stale. This is
- * what an LLM caller threads into a prompt: `stamp` flows into later writes as
- * `readAt`, so the server rejects a mutation premised on data that has since
- * changed; `signal` is an `AbortSignal` that fires as soon as any captured
- * entity receives a delta, so a mid-generation invalidation can abort the token
- * stream instead of producing output against stale context.
- *
- * It reads the current entity state from the in-memory pool, reads the engine's
- * current `lastSyncId` as the watermark, and subscribes to delta frames on the
- * existing sync connection — no second connection.
- */
-import type { InstanceCache } from '../InstanceCache.js';
-import type { Schema } from '@abloatai/transaction/schema/schema';
-import type { SyncWebSocket } from './SyncWebSocket.js';
-import type { Snapshot } from '@abloatai/transaction/types/streams';
-export interface CreateSnapshotArgs<TSchema extends Schema = Schema, K extends keyof TSchema['models'] & string = keyof TSchema['models'] & string> {
-    pool: InstanceCache;
-    /** Live transport for delta subscriptions. May be null if the engine
-     *  hasn't connected yet — the snapshot still resolves with current
-     *  pool state, but `signal` won't fire until reconnect. */
-    transport: SyncWebSocket | null;
-    /** Returns the engine's current `lastSyncId`. Read at snapshot time
-     *  to stamp the watermark; not re-read after. */
-    getLastSyncId: () => number;
-    entities: Readonly<Record<K, string | readonly string[]>>;
-}
-export declare function createSnapshot<TSchema extends Schema, K extends keyof TSchema['models'] & string>(args: CreateSnapshotArgs<TSchema, K>): Snapshot<TSchema, K>;