@abloatai/humans 0.56.0 → 0.58.0

package/dist/Ablo.d.ts

@@ -65,7 +65,6 @@ export declare function Ablo<const S extends SchemaRecord, const P extends reado
 export declare function Ablo<const S extends SchemaRecord>(options: AbloOptions<S>): Ablo<S>;
 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';
@@ -108,7 +107,6 @@ export declare namespace Ablo {
     type ClaimLost = _Streams.ClaimLost;
     type ClaimHeartbeat = _Streams.ClaimHeartbeat;
     type ClaimHeartbeatOptions = _Streams.ClaimHeartbeatOptions;
-    type Snapshot<TSchema extends _SchemaTypes.Schema = _SchemaTypes.Schema, K extends keyof TSchema['models'] = keyof TSchema['models']> = _Streams.Snapshot<TSchema, K>;
     namespace Auth {
         type Actor = _Streams.ParticipantRef;
     }
@@ -150,14 +148,6 @@ export declare namespace Ablo {
         type InferRow<S extends _SchemaTypes.Schema, K extends keyof S['models']> = _SchemaTypes.InferRow<S, K>;
         type InferModelNames<S extends _SchemaTypes.Schema> = _SchemaTypes.InferModelNames<S>;
     }
-    type Conflict = _Policy.Conflict;
-    namespace Conflict {
-        type Kind = _Policy.ConflictKind;
-        type Operation = _Policy.ConflictOperation;
-        type Decision = _Policy.ConflictDecision;
-        type Policy = _Policy.ConflictPolicy;
-        type Axis = _Policy.ConflictAxis;
-    }
     namespace Commit {
         type Wait = import('./local/client/resourceTypes.js').CommitWait;
         type OperationAction = import('./local/client/resourceTypes.js').ModelOperationAction;
@@ -171,19 +161,19 @@ export declare namespace Ablo {
         type Held<T = Record<string, unknown>> = import('@abloatai/transaction/types/streams').HeldClaim<T>;
         type CreateOptions = import('./local/client/resourceTypes.js').ClaimCreateOptions;
         type WaitOptions = import('./local/client/resourceTypes.js').ClaimWaitOptions;
-        type ContentionOptions = import('@abloatai/transaction/resources/modelOperations').ClaimContentionOptions;
-        type AttemptEvent = import('@abloatai/transaction/resources/modelOperations').ClaimAttemptEvent;
-        type QueueView = import('@abloatai/transaction/resources/modelOperations').ClaimQueueView;
+        type ContentionOptions = import('@abloatai/transaction/client/resources/modelOperations').ClaimContentionOptions;
+        type AttemptEvent = import('@abloatai/transaction/client/resources/modelOperations').ClaimAttemptEvent;
+        type QueueView = import('@abloatai/transaction/client/resources/modelOperations').ClaimQueueView;
         type Client = import('./local/client/resourceTypes.js').ClaimResource;
     }
     namespace Model {
         type Target = import('./local/client/resourceTypes.js').ModelTarget;
         type Claim = import('./local/client/resourceTypes.js').ModelClaim;
-        type Operations<T, CreateInput = T> = import('./local/client/createModelProxy.js').ModelOperations<T, CreateInput>;
-        type ClaimOptions<T = Record<string, unknown>> = import('./local/client/createModelProxy.js').ClaimOptions<T>;
-        type ClaimParams<T = Record<string, unknown>> = import('./local/client/createModelProxy.js').ClaimParams<T>;
-        type ClaimLookupParams<T = Record<string, unknown>> = import('./local/client/createModelProxy.js').ClaimLookupParams<T>;
-        type ClaimReorderParams<T = Record<string, unknown>> = import('./local/client/createModelProxy.js').ClaimReorderParams<T>;
+        type Operations<T, CreateInput = T> = import('./local/client/createModelOperations.js').ModelOperations<T, CreateInput>;
+        type ClaimOptions<T = Record<string, unknown>> = import('./local/client/createModelOperations.js').ClaimOptions<T>;
+        type ClaimParams<T = Record<string, unknown>> = import('./local/client/createModelOperations.js').ClaimParams<T>;
+        type ClaimLookupParams<T = Record<string, unknown>> = import('./local/client/createModelOperations.js').ClaimLookupParams<T>;
+        type ClaimReorderParams<T = Record<string, unknown>> = import('./local/client/createModelOperations.js').ClaimReorderParams<T>;
         type MutationOptions = import('./local/client/resourceTypes.js').ModelMutationOptions;
     }
     namespace Source {

package/dist/client.d.ts

@@ -11,14 +11,16 @@
  * the factory back and creating a cycle.
  */
 import type { Schema, SchemaRecord, Model, 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 { ClaimResource, CommitResource, CreateAgentClientParams, SessionResource } from '@abloatai/transaction/resources/httpResources';
+import type { ModelOperations } from './local/client/createModelOperations.js';
+import type { ClaimResource, CommitResource, CreateAgentClientParams, SessionResource } 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 */
 export type AbloClient<S extends SchemaRecord> = {
@@ -268,22 +270,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
      * losses, connection changes. Durable: the subscription survives the

package/dist/core.d.ts

@@ -30,7 +30,7 @@ export { BootstrapFetcher } from './local/sync/BootstrapFetcher.js';
  *  existing imports working and will be removed in a future major version. */
 export { BootstrapFetcher as BootstrapHelper } from './local/sync/BootstrapFetcher.js';
 export { createClaimStream, type AttachableClaimStream, type ClaimStreamConfig, } from './local/sync/createClaimStream.js';
-export { awaitClaimGrant, type GrantTransport, } from '@abloatai/transaction/coordination/awaitClaimGrant';
+export { awaitClaimGrant, type GrantTransport, } from '@abloatai/transaction/claims';
 export { LoadStrategy } from '@abloatai/transaction/types';
 export type { InternalAbloOptions } from './local/client/options.js';
 export { drainProfileSnapshot, resetDrainProfile, drainProfilingEnabled, drainAcknowledgeStamps, type AcknowledgeStamp, type DrainProfile, type DrainBatchRow, type DrainStage, type DrainStageTotals, } from './local/sync/drainProfile.js';

package/dist/core.js

@@ -42,7 +42,7 @@ export { BootstrapFetcher as BootstrapHelper } from './local/sync/BootstrapFetch
 // grants. These are for extension code and test harnesses; ordinary
 // application code should use `ablo.<model>.claim`.
 export { createClaimStream, } from './local/sync/createClaimStream.js';
-export { awaitClaimGrant, } from '@abloatai/transaction/coordination/awaitClaimGrant';
+export { awaitClaimGrant, } from '@abloatai/transaction/claims';
 // An enum naming the strategies for loading a model's data. Referenced when
 // registering models in extension code.
 export { LoadStrategy } from '@abloatai/transaction/types';

package/dist/local/Database.d.ts

@@ -13,7 +13,7 @@ import type { RuntimeContext } from './RuntimeContext.js';
 import type { AppliedChange } from '../plugin.js';
 import type { BootstrapFetcher, BootstrapData } from './sync/BootstrapFetcher.js';
 import { InMemoryObjectStore } from './adapters/inMemoryStorage.js';
-import type { SyncDeltaAction } from '@abloatai/transaction/wire/delta';
+import type { SyncDeltaAction } from '@abloatai/transaction/observation';
 import type { BootstrapType } from '@abloatai/transaction/types';
 import { type PersistedTransaction } from './transactions/persistedTransaction.js';
 /** Generic record type for model data */

package/dist/local/Model.js

@@ -936,7 +936,7 @@ export class Model {
             throw new AbloValidationError('Model identifier (__typename, __class, or modelName) not found in data', { code: 'model_identifier_missing' });
         }
         // Try to get model class by identifier
-        let ModelClass = getActiveRegistry().getModelByName(modelIdentifier);
+        const ModelClass = getActiveRegistry().getModelByName(modelIdentifier);
         if (!ModelClass) {
             throw new AbloValidationError(`Model class not found for: ${modelIdentifier}`, { code: 'model_class_not_registered' });
         }

package/dist/local/SyncClient.d.ts

@@ -17,41 +17,11 @@ import { type CommitLatencySample } from './transactions/mutations/commitLatency
 import { type UnconfirmedWritesMetrics } from './transactions/mutations/UnconfirmedWrites.js';
 import type { DurableWriteStore } from './transactions/mutations/durableWriteStore.js';
 import type { Database } from './Database.js';
-import type { BootstrapData } from './sync/BootstrapFetcher.js';
 import type { WriteOptions } from './interfaces/index.js';
 import { LogPosition } from './logPosition.js';
-interface SyncObserver {
-    onSync?: (event: SyncEvent) => void;
-}
-interface SyncEvent {
-    type: 'create' | 'update' | 'delete' | 'archive' | 'rollback';
-    modelType: string;
-    model?: Model;
-    modelId?: string;
-    transactionType?: string;
-}
-interface SyncState {
-    connectionState: 'connected' | 'disconnected' | 'connecting';
-    pendingMutations: number;
-    lastSyncAt?: Date;
-    error?: Error;
-}
-export interface RehydrationStats {
-    added: number;
-    updated: number;
-    removed: number;
-    skipped: number;
-    healed: number;
-    elapsedMs: number;
-}
-/**
- * The slice of a bootstrap answer the pool applies: its rows, the models whose
- * server query failed, and the log position the snapshot was taken at — the
- * position every row in it reflects. `lastSyncId` is optional only for callers
- * applying rows with no snapshot position to speak of; the fetcher always
- * names one.
- */
-export type BootstrapSnapshot = Pick<BootstrapData, 'models' | 'failedModels'> & Partial<Pick<BootstrapData, 'lastSyncId'>>;
+import { type RehydrationStats, type SyncObserver, type SyncState } from './syncClientTypes.js';
+import type { BootstrapSnapshot } from './syncClientTypes.js';
+export type { BootstrapSnapshot, RehydrationStats } from './syncClientTypes.js';
 export declare class SyncClient extends EventEmitter {
     private readonly runtime;
     private objectPool;
@@ -533,4 +503,3 @@ export declare class SyncClient extends EventEmitter {
         healed: number;
     };
 }
-export {};

package/dist/local/SyncClient.js

@@ -24,22 +24,7 @@ import { LogPosition } from './logPosition.js';
 import { createLocalMutationPort } from './transactions/localMutation.js';
 import { createReconnectDrain } from './transactions/reconnectDrain.js';
 import { DatabaseCommitOutboxStore } from './transactions/databaseCommitOutbox.js';
-/**
- * Converts an untyped server `updatedAt` value — an ISO string, epoch number,
- * or Date read off an untyped row — into epoch milliseconds for
- * last-write-wins comparison. Falsy or non-date values become 0, matching the
- * conflict resolver's rule that a missing timestamp sorts as the epoch.
- */
-function toEpochMs(value) {
-    if (!value)
-        return 0;
-    if (value instanceof Date)
-        return value.getTime();
-    if (typeof value === 'string' || typeof value === 'number') {
-        return new Date(value).getTime();
-    }
-    return 0;
-}
+import { toEpochMs, } from './syncClientTypes.js';
 export class SyncClient extends EventEmitter {
     runtime;
     objectPool;
@@ -1244,6 +1229,11 @@ export class SyncClient extends EventEmitter {
     dispose() {
         this.isDisposed = true;
         this.disconnect();
+        // The queue owns commit retry, replication-lag, offline-grace, and
+        // per-mutation timers. A disposed client must release those resources too;
+        // otherwise an atomic commit can keep a worker process alive after the
+        // public client has been disposed.
+        this.mutationQueue.dispose();
         this.networkMonitor.dispose();
         this.observers.clear();
         this.pendingStages.clear();

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

@@ -16,7 +16,7 @@ import { BootstrapFetcher } from '../sync/BootstrapFetcher.js';
 import type { AuthCredentialSource } from '@abloatai/transaction/auth/credentialSource';
 import type { Schema, SchemaRecord } from '@abloatai/transaction/schema/schema';
 import { type AbloPersistence } from '../persistence.js';
-import type { DurableWriteStore, DurableWritesConfig } from '@abloatai/transaction/durableWrites';
+import type { DurableWriteStore, DurableWritesConfig } from '@abloatai/transaction/commit';
 import type { RuntimeContext } from '../RuntimeContext.js';
 export interface InternalComponentsInput<S extends SchemaRecord> {
     readonly schema: Schema<S>;

package/dist/local/client/createInternalComponents.js

@@ -17,7 +17,7 @@ import { loadsAtBootstrap } from '@abloatai/transaction/schema/loadStrategy';
 import { resolveBootstrapBaseUrl } from '@abloatai/transaction/auth/apiKey';
 import { shouldUseInMemoryPersistence, } from '../persistence.js';
 import { globalRuntime } from '../context.js';
-import { resolveDurableWrites } from '@abloatai/transaction/durableWrites';
+import { resolveDurableWrites } from '@abloatai/transaction/commit';
 export function createInternalComponents(input) {
     const { schema, url, options, auth } = input;
     const runtime = input.runtime ?? globalRuntime;

package/dist/local/client/{createModelProxy.d.ts → createModelOperations.d.ts}

@@ -3,24 +3,25 @@
  * `ablo.<model>`.
  *
  * Each schema model gets one {@link ModelOperations}: the async server reads
- * `get` and `list`, with the same point lookup restricted to the local graph under
+ * `read` and `list`, with the same point lookup restricted to the local graph under
  * `local`, the writes `create`, `update`, and `delete`, the coordination
  * namespace `claim` (callable as `claim({ id })`, plus `claim.state`,
  * `claim.queue`, `claim.release`, and `claim.reorder`), `join`, and `onChange`.
  * The factory returns a plain object; the client assembles the `ablo.<model>`
  * lookup table from one of these per model.
  */
+import type { CommitCreateOptions, CommitReceipt } from '@abloatai/transaction/client/resources/httpResources';
 import type { ModelTarget } from '@abloatai/transaction/coordination/schema';
 import type { ModelRegistry } from '../ModelRegistry.js';
 import type { InstanceCache } from '../InstanceCache.js';
 import type { SyncClient } from '../SyncClient.js';
 import type { OnDemandLoader } from '../sync/OnDemandLoader.js';
 import type { JoinedParticipant } from '../sync/participants.js';
-import type { Duration, Claim, ClaimHeartbeat, ClaimHeartbeatOptions, HeldClaim, HeldLease, ClaimWaitOptions, Snapshot } from '@abloatai/transaction/types/streams';
-export type { ModelListScope, ModelTrackParams, ModelTrackResult, LocalReadOptions, LocalCountOptions, ServerReadOptions, ServerGetOptions, ServerRetrieveOptions, ClaimTargetOptions, ClaimParams, ClaimContentionOptions, ClaimAttemptEvent, ClaimQueueView, ClaimSkipOptions, ClaimSkipParams, ClaimLookupParams, ClaimReorderParams, ClaimOptions, ClaimReadApi, AwaitedClaimMethod, ClaimApi, ModelRetrieveParams, ModelCreateParams, ModelUpdateParams, ModelDeleteParams, JoinOptions, } from '@abloatai/transaction/resources/modelOperations';
+import type { Duration, Claim, ClaimHeartbeat, ClaimHeartbeatOptions, HeldClaim, HeldLease, ClaimWaitOptions } from '@abloatai/transaction/types/streams';
+export type { ModelListScope, LocalReadOptions, LocalCountOptions, ServerReadOptions, ListAllOptions, ServerPointReadOptions, ClaimTargetOptions, ClaimParams, ClaimContentionOptions, ClaimAttemptEvent, ClaimQueueView, ClaimSkipOptions, ClaimSkipParams, ClaimLookupParams, ClaimReorderParams, ClaimOptions, ClaimReadApi, AwaitedClaimMethod, ClaimApi, ModelReadParams, ModelCreateParams, ModelUpdateParams, ModelDeleteParams, JoinOptions, } from '@abloatai/transaction/client/resources/modelOperations';
 export type { Claim, ClaimHeartbeat, ClaimHeartbeatOptions, HeldClaim, HeldLease };
-import type { ClaimApi, ClaimAttemptEvent, JoinOptions, LocalCountOptions, LocalReadOptions } from '@abloatai/transaction/resources/modelOperations';
-import type { HttpModelClient } from '@abloatai/transaction/transport/httpClient';
+import type { ClaimApi, ClaimAttemptEvent, JoinOptions, LocalCountOptions, LocalReadOptions } from '@abloatai/transaction/client/resources/modelOperations';
+import type { HttpModelClient } from '@abloatai/transaction/transport/http';
 import type { ParticipantKind } from '@abloatai/transaction/types/participant';
 import { type ReadSetContext } from '@abloatai/transaction/internal/read-set';
 export interface ModelClientMeta {
@@ -39,6 +40,17 @@ export interface ModelCollaboration {
         data: unknown;
         stamp: number;
     }>;
+    /**
+     * The batch commit lane, for a create handed a list of rows.
+     *
+     * A reactive client's single writes go through the mutation queue and land
+     * optimistically, because a rejected write rolls one row back. A batch
+     * cannot: it is atomic, so applying the rows one at a time would paint a
+     * half-written state the server may then decline whole. It goes down the
+     * same commit door the stateless client uses and the rows arrive on the
+     * ordinary stream, the way a teammate's would.
+     */
+    commitBatch(options: CommitCreateOptions): Promise<CommitReceipt>;
     createClaim(options: {
         /**
          * The locator, in the spelling the SDK surface and the HTTP routes use.
@@ -65,7 +77,8 @@ export interface ModelCollaboration {
         /** Request-scoped queued / granted / skipped / failed status events. */
         onStatus?: (event: ClaimAttemptEvent) => void;
     }): Promise<Claim>;
-    createSnapshot(modelKey: string, id: string): Snapshot;
+    /** Current applied/acked watermark, captured after a claim's fresh read. */
+    currentReadAt(): number;
     /**
      * Current coordination state on a target — who (if anyone) holds it.
      * Synchronous reactive snapshot read off the presence/claim stream;
@@ -133,7 +146,7 @@ export interface ModelCollaboration {
      * Opens a presence and claim subscription on this model's sync group(s) and
      * returns the live participant handle. Backs `ablo.<model>.join(ids)`.
      * WebSocket only, since presence needs a live socket; it is absent on other
-     * client constructions, where the proxy throws a clear error.
+     * client constructions, where the surface throws a clear error.
      */
     createJoin?(modelKey: string, ids: string | readonly string[], options?: JoinOptions): Promise<JoinedParticipant>;
 }
@@ -142,7 +155,7 @@ export interface ModelCollaboration {
  *
  * Every verb mirrors its asynchronous sibling on the base surface, and the one
  * word in front is the whole difference. It is a narrowing, not a claim about
- * the other side: `get` consults the local graph and then the network,
+ * the other side: `read` consults the local graph and then the network,
  * while `local.get` is restricted to what is already resident — which is
  * also why it can return a value instead of a promise. There is nothing to
  * await.
@@ -241,7 +254,7 @@ interface ReactiveModelSurface<T, Fields = T> {
  * See {@link ReactiveModelSurface}.
  */
 export type ModelOperations<T, CreateInput> = Omit<HttpModelClient<T, CreateInput>, 'claim'> & ReactiveModelSurface<T, CreateInput>;
-export declare function createModelProxy<T, C>(schemaKey: string, registeredModelName: string, objectPool: Pick<InstanceCache, 'get' | 'getByType' | 'getOfType'>, syncClient: Pick<SyncClient, 'add' | 'delete' | 'getMutationQueue' | 'getOrganizationId' | 'syncNow' | 'update' | 'waitForConfirmation'>, registry: Pick<ModelRegistry, 'getModelByName'>, 
+export declare function createModelOperations<T, C>(schemaKey: string, registeredModelName: string, objectPool: Pick<InstanceCache, 'get' | 'getByType' | 'getOfType'>, syncClient: Pick<SyncClient, 'add' | 'delete' | 'getOrganizationId' | 'syncNow' | 'update' | 'waitForConfirmation'>, registry: Pick<ModelRegistry, 'getModelByName'>, 
 /**
  * The one thing this factory asks of the loader: fetch rows for a model.
  *