@abloatai/humans 0.51.0 → 0.53.0

package/src/client.ts

@@ -131,10 +131,10 @@ export type AbloClient<S extends SchemaRecord> = {
    * server verifies it. The browser must never see the `sk_` key, only the
    * per-user session token.
    *
-   * Pass `{ user: { id }, can: { tasks: ['read', 'update'] } }` for an end-user
+   * Pass `{ user: { id }, can: { items: ['read', 'update'] } }` for an end-user
    * session. It mints an `ek_` and attributes writes to a user (recorded as
    * `actor_kind` on the delta row). Pass `{ agent: { id }, can: {
-   * tasks: ['update'] } }` for a scoped agent session, which mints an `rk_`.
+   * items: ['update'] } }` for a scoped agent session, which mints an `rk_`.
    * Both kinds require `can`, typed against your schema's model names. This
    * always authenticates with the original `sk_`, never the client's exchanged
    * sync credential.
@@ -150,10 +150,10 @@ export type AbloClient<S extends SchemaRecord> = {
    * ```ts
    * const agent = await ablo.agents.create({
    *   name: 'researcher',                  // readable label (optional)
-   *   can: { documents: ['read', 'update'] },
+   *   can: { records: ['read', 'update'] },
    *   // id omitted → a fresh uuid: a distinct, independent participant
    * });
-   * await agent.documents.update({ id, data, claim });
+   * await agent.records.update({ id, data, claim });
    * await agent.dispose(); // when the agent is done
    * ```
    *

package/src/local/BaseSyncedStore.ts

@@ -84,7 +84,7 @@ import type { CommitLatencySample } from './transactions/mutations/commitLatency
 export type ModelConstructor<T extends Model> = abstract new (...args: never[]) => T;
 
 /** Concrete constructor type for instantiation */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any -- Constructor args vary per model (PrismaTask, Record<string, unknown>, etc.)
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- Constructor args vary per model (PrismaItem, Record<string, unknown>, etc.)
 export type ConcreteModelConstructor<T extends Model> = new (data?: any) => T;
 
 // ModelData is defined in a separate module to break the type cycle between

package/src/local/Database.ts

@@ -23,123 +23,32 @@ import type { BootstrapFetcher, BootstrapData } from './sync/BootstrapFetcher.js
 import { InMemoryObjectStore } from './adapters/inMemoryStorage.js';
 import { logPositionSchema } from './logPosition.js';
 import type { SyncDeltaAction } from '@abloatai/transaction/wire/delta';
-import type { OnStaleMode } from '@abloatai/transaction/coordination/schema';
 import type { BootstrapType } from '@abloatai/transaction/types';
 import { highestPersistedPrefixSyncId } from './sync/persistedPrefix.js';
+import {
+  isAcceptedOutboxPromotion,
+  isSameOutboxRecord,
+  type PersistedTransaction,
+} from './transactions/persistedTransaction.js';
 
 /** Generic record type for model data */
 type ModelData = Record<string, unknown>;
 
-/** Persisted mutation in a transaction */
-interface PersistedMutation {
-  type: 'create' | 'update' | 'delete' | 'archive';
-  modelData: ModelData;
-  modelName: string;
-  timestamp: string;
-  writeOptions?: {
-    readAt?: number | null;
-    onStale?: OnStaleMode | null;
-  };
-}
-
-/** Persisted transaction for offline/retry support.
- *
- *  Index signature is part of the contract: this interface targets
- *  the generic record-shaped storage layer (`InMemoryObjectStore.put`
- *  + the IDB ObjectStore equivalent), both of which take
- *  `Record<string, unknown>`. Every declared field below already
- *  satisfies `unknown`; the index signature just makes the
- *  interface assignable to the storage parameter without a cast. */
-interface PersistedTransaction {
-  id: string;
-  type?: string;
-  timestamp?: number;
-  createdAt?: number;
-  mutations?: PersistedMutation[];
-  // Persist awaiting-delta transactions so they survive a tab close. On the
-  // next session, WebSocket reconnect plus delta catch-up confirms them.
-  awaitingDelta?: {
-    syncIdNeeded: number;
-    modelName: string;
-    modelId: string;
-    operationType: string;
-  };
-  [key: string]: unknown;
-}
-
 /**
- * Request identity excludes local timing metadata for re-entrant seals: a
- * retry rebuilds its envelope with a fresh `sequence`/seal clock, so comparing
- * those volatile fields would reject every legitimate same-request re-seal as
- * an idempotency conflict. Only the fields that define the wire request count.
+ * Carry each input delta's log position onto the change that answers it.
+ * `processDeltaBatch` builds its results index-aligned with its input, so the
+ * position is stamped once here rather than at every construction site.
  */
-function isSameOutboxRecord(
-  existing: PersistedTransaction,
-  candidate: PersistedTransaction,
-): boolean {
-  if (
-    existing.type === 'http_commit_envelope' &&
-    candidate.type === 'http_commit_envelope'
-  ) {
-    const identity = (record: PersistedTransaction): unknown => ({
-      id: record.id,
-      type: record.type,
-      storageVersion: record.storageVersion,
-      idempotencyKey: record.idempotencyKey,
-      // HTTP outbox rows written before protocol versioning are v1. Normalize
-      // them so a same-request re-seal remains idempotent after an upgrade.
-      protocolVersion: record.protocolVersion ?? 1,
-      request: record.request,
-      scopeNamespace: record.scopeNamespace,
-    });
-    if (
-      existing.correlationId !== undefined &&
-      candidate.correlationId !== undefined &&
-      existing.correlationId !== candidate.correlationId
-    ) {
-      return false;
-    }
-    return JSON.stringify(identity(existing)) === JSON.stringify(identity(candidate));
-  }
-  if (
-    existing.type === 'commit_envelope' &&
-    candidate.type === 'commit_envelope'
-  ) {
-    const identity = (record: PersistedTransaction): unknown => ({
-      id: record.id,
-      type: record.type,
-      storageVersion: record.storageVersion,
-      origin: record.origin,
-      idempotencyKey: record.idempotencyKey,
-      operations: record.operations,
-      sourceMutationIds: record.sourceMutationIds,
-      commitOptions: record.commitOptions,
-      scope: record.scope,
-    });
-    if (
-      existing.correlationId !== undefined &&
-      candidate.correlationId !== undefined &&
-      existing.correlationId !== candidate.correlationId
-    ) {
-      return false;
-    }
-    return JSON.stringify(identity(existing)) === JSON.stringify(identity(candidate));
+function stampSyncIds(
+  results: AppliedChange[],
+  deltas: readonly { syncId?: number }[],
+): AppliedChange[] {
+  for (let index = 0; index < results.length; index++) {
+    const change = results[index];
+    const syncId = deltas[index]?.syncId;
+    if (change && typeof syncId === 'number') change.syncId = syncId;
   }
-  return JSON.stringify(existing) === JSON.stringify(candidate);
-}
-
-function isAcceptedOutboxPromotion(
-  existing: PersistedTransaction | undefined,
-  candidate: PersistedTransaction,
-): boolean {
-  return (
-    existing !== undefined &&
-    (existing.type === 'commit_envelope' ||
-      existing.type === 'http_commit_envelope') &&
-    existing.type === candidate.type &&
-    existing.acceptedAt === undefined &&
-    candidate.acceptedAt !== undefined
-  );
+  return results;
 }
 
 // Re-exported, not redeclared. `@abloatai/transaction`'s `types` module owns this
@@ -1227,7 +1136,10 @@ export class Database {
           updatedAt: new Date(),
         };
       }
-      return { results: inMemResults, persistedSyncId: inMemPersistedSyncId };
+      return {
+        results: stampSyncIds(inMemResults, deltas),
+        persistedSyncId: inMemPersistedSyncId,
+      };
     }
 
     // Prepare results aligned with input order
@@ -1648,7 +1560,7 @@ export class Database {
       });
     }
 
-    return { results, persistedSyncId: highestPersistedSyncId };
+    return { results: stampSyncIds(results, deltas), persistedSyncId: highestPersistedSyncId };
   }
 
   /** Get raw data for hydration */

package/src/local/InstanceCache.ts

@@ -16,6 +16,7 @@ import { AbloValidationError } from '@abloatai/transaction/errors';
 import { ModelScope, PropertyType } from '@abloatai/transaction/types';
 import { ViewRegistry } from './views/ViewRegistry.js';
 import { QueryView, type QueryViewOptions } from './views/QueryView.js';
+import { RowWatermarks } from './rowWatermarks.js';
 
 /** Constructor type for Model subclasses - uses abstract to handle variance */
 type ModelConstructor<T extends Model> = abstract new (...args: never[]) => T;
@@ -124,6 +125,15 @@ export class InstanceCache {
   // ViewRegistry — tracks active QueryViews for incremental view maintenance
   readonly viewRegistry: ViewRegistry = new ViewRegistry();
 
+  /**
+   * The log position each pooled row is known to reflect. Every door a row
+   * enters through (delta, own ack, bootstrap, server read) advances it, and
+   * every snapshot that would overwrite a resident row is judged against it —
+   * see {@link RowWatermarks}. Keyed by instance so it lives and dies with the
+   * pooled model.
+   */
+  readonly watermarks = new RowWatermarks();
+
   // Subscription registry
   private subscriptions = new Map<string, Set<(model: Model) => void>>();
 

package/src/local/Model.ts

@@ -1108,26 +1108,6 @@ export abstract class Model {
     // Try to get model class by identifier
     let ModelClass = getActiveRegistry().getModelByName(modelIdentifier);
 
-    // If not found by registered name, try mapping to the class name
-    if (!ModelClass) {
-      const classNameMap: Record<string, string> = {
-        Task: 'TaskModel',
-        Project: 'Project',
-        Comment: 'CommentModel',
-        User: 'UserModel',
-        Organization: 'OrganizationModel',
-        StatusGroup: 'StatusGroupModel',
-        Team: 'TeamModel',
-        Member: 'MemberModel',
-        Role: 'RoleModel',
-      };
-
-      const className = classNameMap[modelIdentifier];
-      if (className) {
-        ModelClass = getActiveRegistry().getModelByName(className);
-      }
-    }
-
     if (!ModelClass) {
       throw new AbloValidationError(
         `Model class not found for: ${modelIdentifier}`,

package/src/local/SyncClient.ts

@@ -34,7 +34,9 @@ import {
   type UnconfirmedWritesMetrics,
 } from './transactions/mutations/UnconfirmedWrites.js';
 import type { DurableWriteStore } from './transactions/mutations/durableWriteStore.js';
+import type { CommitTransaction } from './transactions/mutations/commitLane.js';
 import type { Database } from './Database.js';
+import type { BootstrapData } from './sync/BootstrapFetcher.js';
 import type { MutationPersistencePort } from './mutationPersistence.js';
 import type { WriteOptions } from './interfaces/index.js';
 import { LogPosition } from './logPosition.js';
@@ -73,30 +75,29 @@ export interface RehydrationStats {
 type EventHandler = () => void;
 
 /**
- * Reports whether an incoming snapshot record is strictly newer than the
- * model already in the pool. The comparison uses the server-stamped
- * `updatedAt` timestamp, since rows carry no numeric version and the delta
- * pipeline resolves order by arrival (last write wins). An undefined incoming
- * timestamp counts as not newer, so a known row is never clobbered; an
- * undefined existing timestamp means the pooled row is unversioned, so the
- * incoming record wins. The scoped hydrate-on-enter path uses this to drop
- * snapshot rows that a live delta has already advanced past.
+ * 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.
  */
-function rawRecordIsNewer(data: Record<string, unknown>, existing: Model): boolean {
-  const raw = data.updatedAt;
-  const inMs =
-    raw instanceof Date
-      ? raw.getTime()
-      : typeof raw === 'string'
-        ? (Number.isNaN(Date.parse(raw)) ? undefined : Date.parse(raw))
-        : typeof raw === 'number'
-          ? raw
-          : undefined;
-  const exMs = existing.updatedAt instanceof Date ? existing.updatedAt.getTime() : undefined;
-  if (inMs === undefined) return false;
-  if (exMs === undefined) return true;
-  return inMs > exMs;
-}
+export type BootstrapSnapshot = Pick<BootstrapData, 'models' | 'failedModels'> &
+  Partial<Pick<BootstrapData, 'lastSyncId'>>;
+
+/**
+ * What `transaction:completed` carries: a model mutation (one row, confirmed
+ * at `syncIdNeededForCompletion`) or an explicit commit (one row per operation,
+ * confirmed at `lastSyncId`). Each arm projects its own queue record.
+ */
+type CompletedTransaction =
+  | (Pick<QueuedMutation, 'id' | 'modelId' | 'syncIdNeededForCompletion'> & {
+      lastSyncId?: undefined;
+      operations?: undefined;
+    })
+  | (Pick<CommitTransaction, 'id' | 'lastSyncId' | 'operations'> & {
+      modelId?: undefined;
+      syncIdNeededForCompletion?: undefined;
+    });
 
 /**
  * Converts an untyped server `updatedAt` value — an ISO string, epoch number,
@@ -464,12 +465,18 @@ export class SyncClient extends EventEmitter {
       }
     );
 
-    // Clean up persisted awaiting transactions when they're finally confirmed
+    // Clean up persisted awaiting transactions when they're finally confirmed,
+    // and record the confirmed position on every row the transaction wrote.
+    // The acknowledgement is the earliest proof of where this client's own
+    // write landed in the log — earlier than its delta echo, which the pool
+    // suppresses on apply — so a snapshot read before the write cannot regress
+    // the row in the window between the two.
     this.mutationQueue.on(
       'transaction:completed',
-      (tx: { id: string; modelName: string; modelId: string }) => {
+      (tx: CompletedTransaction) => {
         // void is safe: the handler's body is fully try/catch'd.
         void this.removeAwaitingTransaction(tx.id);
+        this.noteOwnWritePositions(tx);
       }
     );
 
@@ -495,6 +502,23 @@ export class SyncClient extends EventEmitter {
     );
   }
 
+  /**
+   * Advance the pooled rows a completed transaction wrote to the log position
+   * its acknowledgement named. A model mutation names one row; an explicit
+   * commit names one per operation. Rows no longer pooled have nothing to
+   * advance — a fresh instance starts without evidence.
+   */
+  private noteOwnWritePositions(tx: CompletedTransaction): void {
+    const position = tx.lastSyncId ?? tx.syncIdNeededForCompletion;
+    if (position === undefined) return;
+    const rowIds =
+      tx.operations !== undefined ? tx.operations.map((op) => op.id) : [tx.modelId];
+    for (const rowId of rowIds) {
+      const row = this.objectPool.peek(rowId);
+      if (row) this.objectPool.watermarks.advance(row, position);
+    }
+  }
+
   /** Persist an unconfirmed transaction to IndexedDB (never rejects — failures are captured). */
   private async persistAwaitingTransaction(event: {
     txId: string;
@@ -1302,8 +1326,7 @@ export class SyncClient extends EventEmitter {
     const shouldForceAcceptServer =
       (serverData.deletedAt !== undefined && serverData.deletedAt !== null) ||
       (serverData.archivedAt !== undefined && serverData.archivedAt !== null) ||
-      serverData.isActive === false ||
-      (serverData.unassignedAt !== undefined && serverData.unassignedAt !== null);
+      serverData.isActive === false;
 
     if (shouldForceAcceptServer) {
       this.runtime.logger.debug('Accepting server update - critical state change detected', {
@@ -1378,14 +1401,10 @@ export class SyncClient extends EventEmitter {
       critical.archivedAt = serverData.archivedAt;
     }
 
-    // Deactivation states - critical for assignments and similar entities
+    // Deactivation states are always critical.
     if (serverData.isActive !== undefined && serverData.isActive === false) {
       critical.isActive = false;
     }
-    if (serverData.unassignedAt !== undefined) {
-      critical.unassignedAt = serverData.unassignedAt;
-    }
-
     return critical;
   }
 
@@ -1824,27 +1843,6 @@ export class SyncClient extends EventEmitter {
     };
   }
 
-  // --- Best-practice assignment ops ---
-  async unassignEntity(entityType: string, entityId: string): Promise<void> {
-    // Call server-side unassign to avoid per-id races
-    await this.mutationExecutor.executeDelete('Assignment', entityId);
-  }
-
-  async reassignEntity(
-    entityType: string,
-    entityId: string,
-    assigneeType: string,
-    assigneeId: string,
-    id?: string
-  ): Promise<void> {
-    await this.mutationExecutor.executeCreate('Assignment', id || '', {
-      entityType,
-      entityId,
-      assigneeType,
-      assigneeId,
-    });
-  }
-
   // ── Delta + Bootstrap application (owns InstanceCache writes) ──────────────
 
   /**
@@ -1978,7 +1976,13 @@ export class SyncClient extends EventEmitter {
     }
 
     for (const result of dbResults) {
-      const { modelName, modelId, action, transactionId } = result;
+      const { modelName, modelId, action, transactionId, syncId } = result;
+
+      // Every delta names the log position the row now reflects — recorded
+      // before echo detection, because an own echo is exactly a position the
+      // pooled row has reached even though its fields are not re-applied.
+      const resident = this.objectPool.peek(modelId);
+      if (resident) this.objectPool.watermarks.advance(resident, syncId);
 
       // Echo detection: if this delta carries a transaction id that matches
       // one already applied optimistically, the pool already reflects the
@@ -2016,7 +2020,10 @@ export class SyncClient extends EventEmitter {
             const model = this.objectPool.createFromData(data, undefined, {
               deferObservability: true,
             });
-            if (model) modelsToAdd.push(model);
+            if (model) {
+              this.objectPool.watermarks.advance(model, syncId);
+              modelsToAdd.push(model);
+            }
           }
           break;
         }
@@ -2084,17 +2091,18 @@ export class SyncClient extends EventEmitter {
    * Owns: model creation, batch upsert, ghost detection + removal.
    */
   applyBootstrapDataToPool(
-    bootstrapData: { models?: Record<string, unknown[]>; failedModels?: string[] },
+    bootstrapData: BootstrapSnapshot,
     protectedIds?: ReadonlySet<string>,
     options?: {
       /**
        * Scoped backfill for the hydrate-on-enter path: the snapshot covers only
        * the groups just entered, not the whole model type. Two behaviors change
-       * so the subset cannot corrupt the pool. First, the upsert is
-       * version-guarded ({@link InstanceCache.upsertIfNewer}) so a concurrent live
-       * delta is not clobbered back to the snapshot version. Second, ghost
-       * removal is skipped, because a subset snapshot must never evict rows of
-       * the same type that belong to other, unhydrated groups.
+       * so the subset cannot corrupt the pool. First, a row the pool already
+       * knows to reflect a position beyond the snapshot's `lastSyncId` is
+       * skipped, so a concurrent live delta is not clobbered back to the
+       * snapshot version. Second, ghost removal is skipped, because a subset
+       * snapshot must never evict rows of the same type that belong to other,
+       * unhydrated groups.
        */
       scoped?: boolean;
     },
@@ -2102,6 +2110,7 @@ export class SyncClient extends EventEmitter {
     if (!bootstrapData.models) {
       return { added: 0, updated: 0, removed: 0, skipped: 0, healed: 0 };
     }
+    const snapshotPosition = bootstrapData.lastSyncId;
 
     const allModels: Model[] = [];
     const serverIdsByType = new Map<string, Set<string>>();
@@ -2136,16 +2145,22 @@ export class SyncClient extends EventEmitter {
         // taken at a server watermark. If a concurrent live delta already
         // advanced this row past the snapshot, skip it. `createFromData`
         // mutates the pooled model in place to keep instances alive, so this
-        // version guard has to run before it; a guard at the upsert layer would
-        // be too late, because the row would already be clobbered.
+        // guard has to run before it; a guard at the upsert layer would be too
+        // late, because the row would already be clobbered.
         if (options?.scoped && recordId) {
-          const existing = this.objectPool.get(recordId);
-          if (existing && !rawRecordIsNewer(data, existing)) { skippedCount++; continue; }
+          const existing = this.objectPool.peek(recordId);
+          if (existing && this.objectPool.watermarks.isAheadOf(existing, snapshotPosition)) {
+            skippedCount++;
+            continue;
+          }
         }
 
         try {
           const model = this.objectPool.createFromData(data);
-          if (model) allModels.push(model);
+          if (model) {
+            this.objectPool.watermarks.advance(model, snapshotPosition);
+            allModels.push(model);
+          }
         } catch {
           skippedCount++;
         }

package/src/local/client/createInternalComponents.ts

@@ -121,6 +121,10 @@ export function createInternalComponents<S extends SchemaRecord>(
     baseUrl: bootstrapBaseUrl,
     getAuthToken: auth?.getAuthToken,
     runtime,
+    // The one canonical log position; the loader reads its floor when a query
+    // leaves so a late answer cannot overwrite a row the pool already knows to
+    // be further along.
+    position: syncClient.position,
   });
 
   // Drop the lazy-lane hydration ledger on reconnect. While connected, the

package/src/local/client/createModelProxy.ts

@@ -38,6 +38,7 @@ import {
   startClaimHeartbeatLoop,
 } from '@abloatai/transaction/coordination/claimHeartbeatLoop';
 import { assertWriteOptions } from '@abloatai/transaction/resources/writeOptionsSchema';
+import { modelList, type ModelList } from '@abloatai/transaction/resources/httpResources';
 import { subTarget } from '@abloatai/transaction/coordination';
 // A named claim-meta crossing (see `claim-meta-crossings-are-enumerated` in
 // .dependency-cruiser.cjs): the reactive proxy's self-claim targets are
@@ -159,7 +160,7 @@ type EntityHalf = Pick<ModelTarget, 'model' | 'id'>;
 // Model-agnostic by construction: every member below names a target by
 // `{ model, id }` and answers in claim/snapshot terms, so the row type never
 // appears. It carried a `<T>` that nothing in the body read, which made
-// `ModelCollaboration<Task>` and `ModelCollaboration<Invoice>` the same type
+// `ModelCollaboration<Item>` and `ModelCollaboration<Invoice>` the same type
 // while reading as though they differed.
 export interface ModelCollaboration {
   /** Exact point evidence from the HTTP read boundary (stamp captured before data). */
@@ -458,7 +459,7 @@ export function createModelProxy<T, C>(
   }
 
   // The coordination plane must speak the same wire dialect as the commit
-  // plane: the lowercased typename (`task`), not the schema key (`tasks`). The
+  // plane: the lowercased typename (`item`), not the schema key (`items`). The
   // server's commit-time claim guard probes the lease store with the commit
   // operation's model name, so a lease recorded under the schema key never
   // matches — which would silently disarm the guard for every model whose
@@ -504,6 +505,18 @@ export function createModelProxy<T, C>(
   };
 
   const load = async (options?: ServerReadOptions<T>): Promise<T[]> => {
+    if (options?.cursor !== undefined) {
+      // The live client hydrates a working set into the local graph rather than
+      // handing back pages, so there is no cursor for this read to resume from.
+      // Accepting the option and ignoring it would return page one every time
+      // while the caller believed it was advancing.
+      throw new AbloValidationError(
+        '`cursor` resumes a page of the stateless read. This client keeps a ' +
+          'local graph and loads a working set instead of pages: narrow the ' +
+          '`where`, or construct the client with `transport: \'http\'` to page.',
+        { code: 'invalid_options', param: 'cursor' },
+      );
+    }
     const rows = await hydration.fetch<T>(schemaKey, options);
     return rows.map((row) => modelAsRow<T>(row));
   };
@@ -1146,10 +1159,18 @@ export function createModelProxy<T, C>(
 
   const list = guard(async (
     options?: ServerReadOptions<T>,
-  ): Promise<CapturedRow<T>[]> => {
+  ): Promise<ModelList<CapturedRow<T>>> => {
     const registry = readSetContext?.getStore();
     const rows = await load(options);
-    if (!registry) return rows as CapturedRow<T>[];
+    // This transport loads a working set rather than pages, so there is no
+    // cursor to hand back. `limit` can still cut the set short, and a full
+    // count is exactly the case where the caller cannot tell: report it rather
+    // than claim completeness this read cannot vouch for.
+    const page = modelList<CapturedRow<T>>(rows as CapturedRow<T>[], {
+      hasMore: options?.limit !== undefined && rows.length >= options.limit,
+      nextCursor: null,
+    });
+    if (!registry) return page;
     for (const row of rows) {
       const stamp = hydration.getReadEvidence?.(row as object);
       if (stamp === undefined) {
@@ -1174,7 +1195,7 @@ export function createModelProxy<T, C>(
         stamp,
       );
     }
-    return rows as CapturedRow<T>[];
+    return page;
   });
 
   const operations: ModelOperations<T, C> = {

package/src/local/interfaces/index.ts

@@ -396,14 +396,14 @@ export interface RuntimeConfig {
    * Fields to preserve when merging a partial update into the local store. A
    * change usually carries only the fields that changed; listing a model's
    * essential fields here keeps them from being dropped during that merge.
-   * For example: `{ Task: ['title', 'projectId'], Section: ['reportId', 'order'] }`.
+   * For example: `{ Item: ['title', 'projectId'], Section: ['reportId', 'order'] }`.
    */
   essentialFields: Readonly<Record<string, readonly string[]>>;
 
   /**
    * A fallback map from class name to model name, used to resolve a model's name
    * when the usual lookup fails — for instance, when a bundler has minified the
-   * class names. For example: `{ TaskModel: 'Task', ProjectModel: 'Project' }`.
+   * class names. For example: `{ ItemModel: 'Item', ProjectModel: 'Project' }`.
    */
   classNameFallbackMap: Readonly<Record<string, string>>;
 
@@ -430,7 +430,7 @@ export interface RuntimeConfig {
 
   /**
    * Per-model content hashes of the schema this client was built against,
-   * keyed by schema key (`tasks` → hash of that model's serialized JSON). The
+   * keyed by schema key (`items` → hash of that model's serialized JSON). The
    * semantic layer of the drift check: on a whole-schema mismatch the client
    * compares only the models IT declares against the server's per-model
    * surface, so a purely additive server-side change (new models this build