@abloatai/humans 0.51.0 → 0.52.0

package/dist/client.d.ts

@@ -108,10 +108,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.
@@ -126,10 +126,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/dist/local/Database.d.ts

@@ -14,43 +14,10 @@ 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 { OnStaleMode } from '@abloatai/transaction/coordination/schema';
 import type { BootstrapType } from '@abloatai/transaction/types';
+import { 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[];
-    awaitingDelta?: {
-        syncIdNeeded: number;
-        modelName: string;
-        modelId: string;
-        operationType: string;
-    };
-    [key: string]: unknown;
-}
 export type { BootstrapType };
 export interface BootstrapRequirements {
     type: BootstrapType;

package/dist/local/Database.js

@@ -15,63 +15,7 @@ import { persistenceDatabaseNamesForDeletion, purgeIndexedDbPersistence, } from
 import { InMemoryObjectStore } from './adapters/inMemoryStorage.js';
 import { logPositionSchema } from './logPosition.js';
 import { highestPersistedPrefixSyncId } from './sync/persistedPrefix.js';
-/**
- * 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.
- */
-function isSameOutboxRecord(existing, candidate) {
-    if (existing.type === 'http_commit_envelope' &&
-        candidate.type === 'http_commit_envelope') {
-        const identity = (record) => ({
-            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) => ({
-            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));
-    }
-    return JSON.stringify(existing) === JSON.stringify(candidate);
-}
-function isAcceptedOutboxPromotion(existing, candidate) {
-    return (existing !== undefined &&
-        (existing.type === 'commit_envelope' ||
-            existing.type === 'http_commit_envelope') &&
-        existing.type === candidate.type &&
-        existing.acceptedAt === undefined &&
-        candidate.acceptedAt !== undefined);
-}
+import { isAcceptedOutboxPromotion, isSameOutboxRecord, } from './transactions/persistedTransaction.js';
 export class Database {
     // Core database components
     databaseManager;

package/dist/local/Model.js

@@ -937,24 +937,6 @@ export 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 = {
-                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}`, { code: 'model_class_not_registered' });
         }

package/dist/local/SyncClient.d.ts

@@ -451,8 +451,6 @@ export declare class SyncClient extends EventEmitter {
             }[];
         };
     };
-    unassignEntity(entityType: string, entityId: string): Promise<void>;
-    reassignEntity(entityType: string, entityId: string, assigneeType: string, assigneeId: string, id?: string): Promise<void>;
     /**
      * Apply a batch of delta results from Database to the InstanceCache.
      * Owns: model creation, upsert, remove, archive, conflict resolution.

package/dist/local/SyncClient.js

@@ -1048,8 +1048,7 @@ export class SyncClient extends EventEmitter {
         // only materializes on the rare force-accept branch, for its log line.
         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', {
                 modelId: localModel.id,
@@ -1113,13 +1112,10 @@ export class SyncClient extends EventEmitter {
         if (serverData.archivedAt !== undefined) {
             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;
     }
     /**
@@ -1475,19 +1471,6 @@ export class SyncClient extends EventEmitter {
             mutationQueue: this.mutationQueue.getDebugInfo(),
         };
     }
-    // --- Best-practice assignment ops ---
-    async unassignEntity(entityType, entityId) {
-        // Call server-side unassign to avoid per-id races
-        await this.mutationExecutor.executeDelete('Assignment', entityId);
-    }
-    async reassignEntity(entityType, entityId, assigneeType, assigneeId, id) {
-        await this.mutationExecutor.executeCreate('Assignment', id || '', {
-            entityType,
-            entityId,
-            assigneeType,
-            assigneeId,
-        });
-    }
     // ── Delta + Bootstrap application (owns InstanceCache writes) ──────────────
     /**
      * Apply a batch of delta results from Database to the InstanceCache.

package/dist/local/client/createModelProxy.js

@@ -75,7 +75,7 @@ hydration, collaboration, readSetContext) {
             'but no matching constructor was registered.', { code: 'model_not_registered' });
     }
     // 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

package/dist/local/interfaces/index.d.ts

@@ -253,13 +253,13 @@ 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>>;
     /**
@@ -283,7 +283,7 @@ export interface RuntimeConfig {
     expectedSourceSchemaHash?: string;
     /**
      * 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

package/dist/local/sync/OnDemandLoader.js

@@ -415,7 +415,7 @@ export class OnDemandLoader {
         // that disagrees with the schema's: these rows were returned FOR this
         // model's query, so the schema typename is correct by construction — and
         // without stripping it, the spread would put the row's variant (a server
-        // echoing the schema KEY `tasks` instead of the typename `Task`) back on
+        // echoing the schema KEY `items` instead of the typename `Item`) back on
         // top of the stamp, sending hydration to the strict unknown-model error.
         const { _Typename: _dropMangled, __typename: _dropRowVariant, ...rest } = obj;
         void _dropMangled;

package/dist/local/sync/deltaPipeline.js

@@ -276,7 +276,7 @@ async function drainPendingDeltas(ctx) {
             // A sustained stream can refill the detached queue before every
             // persistence promise settles. Promise-only looping then forms an
             // unbounded microtask chain that starves WebSocket reads, timers and
-            // replication keepalives. Give the host one macrotask turn between
+            // replication keepalives. Give the host one macroitem turn between
             // owned batches; Node has setImmediate, browsers fall back to a timer.
             await yieldToHost();
         }

package/dist/local/sync/initialize.js

@@ -43,7 +43,7 @@ export function* initialize(host, context, signal) {
         // Bootstrap from server if needed.
         //
         // `bootstrapMode: 'none'` participants (headless workers and
-        // task runners) skip baseline replication — they read via
+        // item runners) skip baseline replication — they read via
         // `model.get()` round-trips and rely on covering deltas
         // from filtered subscriptions to populate the pool lazily. The
         // WS is already open by `setupWebSocketSync` above, so live
@@ -55,7 +55,7 @@ export function* initialize(host, context, signal) {
             // initiates the upgrade, but it does NOT await the 'connected'
             // event — it returns synchronously after wiring listeners.
             // For bootstrapMode='none' consumers (headless workers and
-            // task runners), this branch is the entire body of initialize()
+            // item runners), this branch is the entire body of initialize()
             // after the WS is set up, so `ready()` would otherwise resolve
             // while the WS is still in 'connecting' state. The very next
             // `commits.create` then throws "SyncWebSocket not connected".

package/dist/local/transactions/mutations/MutationQueue.d.ts

@@ -167,7 +167,7 @@ export declare class MutationQueue extends EventEmitter {
     /**
      * Relates stale notifications back to write targets without assuming the
      * server's canonical model name uses the same spelling as the public schema
-     * key (`Task` versus `tasks`). Exact `(model,id)` wins; a globally unique id
+     * key (`Item` versus `items`). Exact `(model,id)` wins; a globally unique id
      * is the compatibility fallback. An ambiguous same-id cross-model mismatch
      * is deliberately left unclassified, so it cannot falsely settle a queued
      * write. A notification with no write-target id (or an explicit group) is a

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

@@ -417,7 +417,7 @@ export class MutationQueue extends EventEmitter {
     /**
      * Relates stale notifications back to write targets without assuming the
      * server's canonical model name uses the same spelling as the public schema
-     * key (`Task` versus `tasks`). Exact `(model,id)` wins; a globally unique id
+     * key (`Item` versus `items`). Exact `(model,id)` wins; a globally unique id
      * is the compatibility fallback. An ambiguous same-id cross-model mismatch
      * is deliberately left unclassified, so it cannot falsely settle a queued
      * write. A notification with no write-target id (or an explicit group) is a

package/dist/local/transactions/persistedTransaction.d.ts

@@ -0,0 +1,39 @@
+import type { OnStaleMode } from '@abloatai/transaction/coordination/schema';
+type ModelData = Record<string, unknown>;
+/** One mutation retained in the durable local transaction journal. */
+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.
+ *
+ * The index signature is part of the contract: this targets the generic
+ * record-shaped storage layer (`InMemoryObjectStore.put` and its IndexedDB
+ * equivalent), both of which take `Record<string, unknown>`.
+ */
+export interface PersistedTransaction {
+    id: string;
+    type?: string;
+    timestamp?: number;
+    createdAt?: number;
+    mutations?: PersistedMutation[];
+    awaitingDelta?: {
+        syncIdNeeded: number;
+        modelName: string;
+        modelId: string;
+        operationType: string;
+    };
+    [key: string]: unknown;
+}
+/** Compare the stable request identity while ignoring local seal timing. */
+export declare function isSameOutboxRecord(existing: PersistedTransaction, candidate: PersistedTransaction): boolean;
+/** An accepted envelope may replace the otherwise-identical pending envelope. */
+export declare function isAcceptedOutboxPromotion(existing: PersistedTransaction | undefined, candidate: PersistedTransaction): boolean;
+export {};

package/dist/local/transactions/persistedTransaction.js

@@ -0,0 +1,53 @@
+/** Compare the stable request identity while ignoring local seal timing. */
+export function isSameOutboxRecord(existing, candidate) {
+    if (existing.type === 'http_commit_envelope' &&
+        candidate.type === 'http_commit_envelope') {
+        const identity = (record) => ({
+            id: record.id,
+            type: record.type,
+            storageVersion: record.storageVersion,
+            idempotencyKey: record.idempotencyKey,
+            // Pre-versioning HTTP outbox rows are v1. Normalizing them preserves
+            // idempotency when the same request is resealed 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) => ({
+            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));
+    }
+    return JSON.stringify(existing) === JSON.stringify(candidate);
+}
+/** An accepted envelope may replace the otherwise-identical pending envelope. */
+export function isAcceptedOutboxPromotion(existing, candidate) {
+    return (existing !== undefined &&
+        (existing.type === 'commit_envelope' ||
+            existing.type === 'http_commit_envelope') &&
+        existing.type === candidate.type &&
+        existing.acceptedAt === undefined &&
+        candidate.acceptedAt !== undefined);
+}

package/dist/local/utils/mobxSetup.js

@@ -48,7 +48,7 @@ export function M1(target, propertyMetadata, referenceMetadata) {
         return false;
     };
     // Skip if target has its own observability setup
-    // This allows models like Task to handle their own MobX setup
+    // This allows models like Item to handle their own MobX setup
     if (target.setupObservability || target._hasCustomObservability) {
         getContext().modelDebugLogger?.logDebug(`${target.constructor.name} has custom observability, skipping M1`);
         return;

package/dist/react/AbloProvider.d.ts

@@ -206,10 +206,10 @@ export declare function usePeers(scope?: ParticipantScope): readonly Peer[];
 /**
  * Returns the raw `SyncEngine` proxy. Typically you want the typed
  * hooks (`useQuery`, `useOne`, `useMutate`) — this is for rare cases
- * where you need direct access (e.g., `sync.tasks.onChange(cb)`).
+ * where you need direct access (e.g., `sync.items.onChange(cb)`).
  *
  * The generic parameter narrows the return type to your schema's
- * model record so call sites get typed `sync.tasks.findMany()` /
+ * model record so call sites get typed `sync.items.findMany()` /
  * `sync.sections.create(...)` without a cast at the call site:
  *
  * ```ts

package/dist/react/AbloProvider.js

@@ -400,10 +400,10 @@ export function usePeers(scope) {
 /**
  * Returns the raw `SyncEngine` proxy. Typically you want the typed
  * hooks (`useQuery`, `useOne`, `useMutate`) — this is for rare cases
- * where you need direct access (e.g., `sync.tasks.onChange(cb)`).
+ * where you need direct access (e.g., `sync.items.onChange(cb)`).
  *
  * The generic parameter narrows the return type to your schema's
- * model record so call sites get typed `sync.tasks.findMany()` /
+ * model record so call sites get typed `sync.items.findMany()` /
  * `sync.sections.create(...)` without a cast at the call site:
  *
  * ```ts

package/dist/react/context.d.ts

@@ -8,7 +8,7 @@ export interface SyncReactContext {
     organizationId: string;
     /**
      * An optional schema. When provided, hooks that take a model by name (such as
-     * `useQuery('tasks')`) read that model's metadata from this schema, so
+     * `useQuery('items')`) read that model's metadata from this schema, so
      * callers don't pass a schema at every call site. When omitted, those hooks
      * require the schema as an argument instead.
      *
@@ -38,7 +38,7 @@ export interface SyncProviderProps {
     organizationId: string;
     /**
      * An optional schema. Provide it to enable hooks that take a model by name
-     * (such as `useQuery('tasks')`); the model types also narrow through your
+     * (such as `useQuery('items')`); the model types also narrow through your
      * `Register` augmentation. Omit it to pass the schema to those hooks directly
      * instead.
      */

package/dist/react/useAblo.d.ts

@@ -54,13 +54,13 @@ export type UseAbloHydratedModelResult<T> = Omit<UseAbloModelResult<T>, 'data'>
  * // With the Register augmentation (recommended):
  * const ablo = useAblo();
  * if (!ablo) return <Loading />;
- * const doc = await ablo.documents.get({ id }); // async server read
+ * const doc = await ablo.records.get({ id }); // async server read
  *
  * // Reactive selector (a synchronous local snapshot). The selector's reads
  * // are typed as snapshot rows — data fields + computeds, no relation
  * // accessors — matching what the hook actually returns:
- * const doc = useAblo((ablo) => ablo.documents.local.get(id)) ?? serverDoc;
- * const active = useAblo((ablo) => ablo.documents.claim.state({ id }));
+ * const doc = useAblo((ablo) => ablo.records.local.get(id)) ?? serverDoc;
+ * const active = useAblo((ablo) => ablo.records.claim.state({ id }));
  *
  * // Without the augmentation, pass the schema as a type argument:
  * const ablo = useAblo<(typeof schema)['models']>();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abloatai/humans",
-  "version": "0.51.0",
+  "version": "0.52.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.51.0",
+    "@abloatai/transaction": "^0.52.0",
     "mobx": "^6.13.7",
     "uuid": "^11.1.0",
     "zod": "^4.4.3"

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,125 +23,17 @@ 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.
- */
-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));
-  }
-  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
-  );
-}
-
 // Re-exported, not redeclared. `@abloatai/transaction`'s `types` module owns this
 // vocabulary and documents what each mode does; this package held a byte-identical
 // second copy while its own test fixtures already imported the canonical one.

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

@@ -1302,8 +1302,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 +1377,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 +1819,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) ──────────────
 
   /**

package/src/local/client/createModelProxy.ts

@@ -159,7 +159,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 +458,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

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

package/src/local/sync/OnDemandLoader.ts

@@ -556,7 +556,7 @@ export class OnDemandLoader {
     // that disagrees with the schema's: these rows were returned FOR this
     // model's query, so the schema typename is correct by construction — and
     // without stripping it, the spread would put the row's variant (a server
-    // echoing the schema KEY `tasks` instead of the typename `Task`) back on
+    // echoing the schema KEY `items` instead of the typename `Item`) back on
     // top of the stamp, sending hydration to the strict unknown-model error.
     const { _Typename: _dropMangled, __typename: _dropRowVariant, ...rest } = obj as Record<
       string,

package/src/local/sync/deltaPipeline.ts

@@ -396,7 +396,7 @@ async function drainPendingDeltas(ctx: DeltaPipelineContext): Promise<void> {
       // A sustained stream can refill the detached queue before every
       // persistence promise settles. Promise-only looping then forms an
       // unbounded microtask chain that starves WebSocket reads, timers and
-      // replication keepalives. Give the host one macrotask turn between
+      // replication keepalives. Give the host one macroitem turn between
       // owned batches; Node has setImmediate, browsers fall back to a timer.
       await yieldToHost();
     }

package/src/local/sync/initialize.ts

@@ -92,7 +92,7 @@ export function* initialize<TCollaboration extends EventMap<TCollaboration>>(
       // Bootstrap from server if needed.
       //
       // `bootstrapMode: 'none'` participants (headless workers and
-      // task runners) skip baseline replication — they read via
+      // item runners) skip baseline replication — they read via
       // `model.get()` round-trips and rely on covering deltas
       // from filtered subscriptions to populate the pool lazily. The
       // WS is already open by `setupWebSocketSync` above, so live
@@ -110,7 +110,7 @@ export function* initialize<TCollaboration extends EventMap<TCollaboration>>(
         // initiates the upgrade, but it does NOT await the 'connected'
         // event — it returns synchronously after wiring listeners.
         // For bootstrapMode='none' consumers (headless workers and
-        // task runners), this branch is the entire body of initialize()
+        // item runners), this branch is the entire body of initialize()
         // after the WS is set up, so `ready()` would otherwise resolve
         // while the WS is still in 'connecting' state. The very next
         // `commits.create` then throws "SyncWebSocket not connected".

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

@@ -645,7 +645,7 @@ export class MutationQueue extends EventEmitter {
   /**
    * Relates stale notifications back to write targets without assuming the
    * server's canonical model name uses the same spelling as the public schema
-   * key (`Task` versus `tasks`). Exact `(model,id)` wins; a globally unique id
+   * key (`Item` versus `items`). Exact `(model,id)` wins; a globally unique id
    * is the compatibility fallback. An ambiguous same-id cross-model mismatch
    * is deliberately left unclassified, so it cannot falsely settle a queued
    * write. A notification with no write-target id (or an explicit group) is a

package/src/local/transactions/persistedTransaction.ts

@@ -0,0 +1,112 @@
+import type { OnStaleMode } from '@abloatai/transaction/coordination/schema';
+
+type ModelData = Record<string, unknown>;
+
+/** One mutation retained in the durable local transaction journal. */
+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.
+ *
+ * The index signature is part of the contract: this targets the generic
+ * record-shaped storage layer (`InMemoryObjectStore.put` and its IndexedDB
+ * equivalent), both of which take `Record<string, unknown>`.
+ */
+export interface PersistedTransaction {
+  id: string;
+  type?: string;
+  timestamp?: number;
+  createdAt?: number;
+  mutations?: PersistedMutation[];
+  // Awaiting-delta transactions survive a tab close. Reconnect and delta
+  // catch-up confirm them during the next session.
+  awaitingDelta?: {
+    syncIdNeeded: number;
+    modelName: string;
+    modelId: string;
+    operationType: string;
+  };
+  [key: string]: unknown;
+}
+
+/** Compare the stable request identity while ignoring local seal timing. */
+export 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,
+      // Pre-versioning HTTP outbox rows are v1. Normalizing them preserves
+      // idempotency when the same request is resealed 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));
+  }
+
+  return JSON.stringify(existing) === JSON.stringify(candidate);
+}
+
+/** An accepted envelope may replace the otherwise-identical pending envelope. */
+export 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
+  );
+}

package/src/local/utils/mobxSetup.ts

@@ -77,7 +77,7 @@ export function M1<T extends M1Target>(
   };
 
   // Skip if target has its own observability setup
-  // This allows models like Task to handle their own MobX setup
+  // This allows models like Item to handle their own MobX setup
   if (target.setupObservability || target._hasCustomObservability) {
     getContext().modelDebugLogger?.logDebug(`${target.constructor.name} has custom observability, skipping M1`);
     return;

package/src/react/AbloProvider.tsx

@@ -675,10 +675,10 @@ export function usePeers(scope?: ParticipantScope): readonly Peer[] {
 /**
  * Returns the raw `SyncEngine` proxy. Typically you want the typed
  * hooks (`useQuery`, `useOne`, `useMutate`) — this is for rare cases
- * where you need direct access (e.g., `sync.tasks.onChange(cb)`).
+ * where you need direct access (e.g., `sync.items.onChange(cb)`).
  *
  * The generic parameter narrows the return type to your schema's
- * model record so call sites get typed `sync.tasks.findMany()` /
+ * model record so call sites get typed `sync.items.findMany()` /
  * `sync.sections.create(...)` without a cast at the call site:
  *
  * ```ts

package/src/react/context.ts

@@ -19,7 +19,7 @@ export interface SyncReactContext {
   organizationId: string;
   /**
    * An optional schema. When provided, hooks that take a model by name (such as
-   * `useQuery('tasks')`) read that model's metadata from this schema, so
+   * `useQuery('items')`) read that model's metadata from this schema, so
    * callers don't pass a schema at every call site. When omitted, those hooks
    * require the schema as an argument instead.
    *
@@ -60,7 +60,7 @@ export interface SyncProviderProps {
   organizationId: string;
   /**
    * An optional schema. Provide it to enable hooks that take a model by name
-   * (such as `useQuery('tasks')`); the model types also narrow through your
+   * (such as `useQuery('items')`); the model types also narrow through your
    * `Register` augmentation. Omit it to pass the schema to those hooks directly
    * instead.
    */

package/src/react/useAblo.ts

@@ -138,13 +138,13 @@ function snapshotValue<T>(value: T): T {
  * // With the Register augmentation (recommended):
  * const ablo = useAblo();
  * if (!ablo) return <Loading />;
- * const doc = await ablo.documents.get({ id }); // async server read
+ * const doc = await ablo.records.get({ id }); // async server read
  *
  * // Reactive selector (a synchronous local snapshot). The selector's reads
  * // are typed as snapshot rows — data fields + computeds, no relation
  * // accessors — matching what the hook actually returns:
- * const doc = useAblo((ablo) => ablo.documents.local.get(id)) ?? serverDoc;
- * const active = useAblo((ablo) => ablo.documents.claim.state({ id }));
+ * const doc = useAblo((ablo) => ablo.records.local.get(id)) ?? serverDoc;
+ * const active = useAblo((ablo) => ablo.records.claim.state({ id }));
  *
  * // Without the augmentation, pass the schema as a type argument:
  * const ablo = useAblo<(typeof schema)['models']>();