@abloatai/humans 0.57.0 → 0.59.0

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.

package/src/local/Database.ts

@@ -21,7 +21,7 @@ import {
 import type { BootstrapFetcher, BootstrapData } from './sync/BootstrapFetcher.js';
 import { InMemoryObjectStore } from './adapters/inMemoryStorage.js';
 import { logPositionSnapshotSchema } from './logPosition.js';
-import type { SyncDeltaAction } from '@abloatai/transaction/wire/delta';
+import type { SyncDeltaAction } from '@abloatai/transaction/observation';
 import type { BootstrapType } from '@abloatai/transaction/types';
 import { highestPersistedPrefixSyncId } from './sync/persistedPrefix.js';
 import {

package/src/local/Model.ts

@@ -281,7 +281,18 @@ export abstract class Model {
    * Track property changes
    */
   propertyChanged(propertyName: string, oldValue: unknown, newValue: unknown): void {
-    if (oldValue === newValue) return;
+    // `createdAt` and `updatedAt` are server-managed bookkeeping, not
+    // user-authored model changes. In particular, every real field change
+    // advances `updatedAt` below. When a schema explicitly declares that
+    // timestamp, MobX observes the assignment and calls this method again;
+    // treating that callback as another edit recursively stamps `updatedAt`
+    // until the stack overflows. Ignore both timestamps at this boundary so
+    // they remain observable without entering the mutation payload.
+    if (
+      oldValue === newValue ||
+      propertyName === 'createdAt' ||
+      propertyName === 'updatedAt'
+    ) return;
 
     runInAction(() => {
       // Preserve the earliest captured `old` for this field until the entry

package/src/local/SyncClient.ts

@@ -1489,6 +1489,11 @@ export class SyncClient extends EventEmitter {
   dispose(): void {
     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/src/local/client/createInternalComponents.ts

@@ -25,10 +25,10 @@ import {
 import type {
   DurableWriteStore,
   DurableWritesConfig,
-} from '@abloatai/transaction/durableWrites';
+} from '@abloatai/transaction/commit';
 import type { RuntimeContext } from '../RuntimeContext.js';
 import { globalRuntime } from '../context.js';
-import { resolveDurableWrites } from '@abloatai/transaction/durableWrites';
+import { resolveDurableWrites } from '@abloatai/transaction/commit';
 
 export interface InternalComponentsInput<S extends SchemaRecord> {
   readonly schema: Schema<S>;