@abloatai/ablo 0.34.1 → 0.35.0

package/dist/Database.d.ts

@@ -7,9 +7,12 @@
  */
 import { type DatabaseInfo, type WorkspaceMetadata } from './core/DatabaseManager.js';
 import { ModelRegistry } from './ModelRegistry.js';
-import { LoadStrategy } from './types/index.js';
+import { LoadStrategy } from './transaction/types/index.js';
 import type { BootstrapFetcher, BootstrapData } from './sync/BootstrapFetcher.js';
 import { InMemoryObjectStore } from './adapters/inMemoryStorage.js';
+import type { SyncDeltaAction } from './transaction/wire/delta.js';
+import type { OnStaleMode } from './transaction/coordination/schema.js';
+import type { BootstrapType } from './transaction/types/index.js';
 /** Generic record type for model data */
 type ModelData = Record<string, unknown>;
 /** Persisted mutation in a transaction */
@@ -20,7 +23,7 @@ interface PersistedMutation {
     timestamp: string;
     writeOptions?: {
         readAt?: number | null;
-        onStale?: 'reject' | 'overwrite' | 'notify' | null;
+        onStale?: OnStaleMode | null;
     };
 }
 /** Persisted transaction for offline/retry support.
@@ -45,20 +48,7 @@ interface PersistedTransaction {
     };
     [key: string]: unknown;
 }
-/**
- * How a session establishes its baseline state at startup.
- *
- * 'full' — Fetch a complete snapshot from the server, clear the local store,
- *   load the snapshot, and adopt its `lastSyncId`.
- *
- * 'partial' — Fetch only the deltas since the stored `lastSyncId` and apply
- *   them on top of the existing local data.
- *
- * 'local' — Skip the server entirely: hydrate the {@link InstanceCache} from the
- *   local store, connect the WebSocket with the stored `lastSyncId`, and
- *   receive deltas from there onward. Used when offline with valid local data.
- */
-export type BootstrapType = 'full' | 'partial' | 'local';
+export type { BootstrapType };
 export interface BootstrapRequirements {
     type: BootstrapType;
     modelsToLoad: string[];
@@ -191,7 +181,7 @@ export declare class Database {
      *
      * Update deltas carry only the changed fields, so they are merged onto the
      * existing record rather than replacing it. That preserves fields the delta
-     * omits (such as deckId or title), and an explicit null is kept as a value,
+     * omits (such as reportId or title), and an explicit null is kept as a value,
      * clearing that field.
      */
     processDelta(delta: {
@@ -202,7 +192,7 @@ export declare class Database {
          * but the switch returns a no-op verify if one slips through (e.g.
          * replayed from the bootstrap queue) rather than crashing the engine.
          */
-        actionType: 'I' | 'U' | 'D' | 'A' | 'V' | 'C' | 'G' | 'S' | 'M';
+        actionType: SyncDeltaAction;
         modelName: string;
         modelId: string;
         data: ModelData | null;
@@ -235,7 +225,7 @@ export declare class Database {
          * shouldn't reach batch processing, but the switch inside returns
          * no-op verify for them if one slips through.
          */
-        actionType: 'I' | 'U' | 'D' | 'A' | 'V' | 'C' | 'G' | 'S' | 'M';
+        actionType: SyncDeltaAction;
         modelName: string;
         modelId: string;
         data: ModelData | null;
@@ -319,10 +309,6 @@ export declare class Database {
         database: DatabaseInfo | null;
         stores: {
             totalStores: number;
-            storeTypes: {
-                full: number;
-                partial: number;
-            };
             readiness: {
                 ready: number;
                 notReady: number;
@@ -347,4 +333,3 @@ export declare class Database {
         includeWriteJournal?: boolean;
     }): Promise<void>;
 }
-export {};

package/dist/Database.js

@@ -8,11 +8,11 @@
 import { DatabaseManager } from './core/DatabaseManager.js';
 import { StoreManager } from './core/StoreManager.js';
 import { ModelRegistry } from './ModelRegistry.js';
-import { LoadStrategy } from './types/index.js';
+import { LoadStrategy } from './transaction/types/index.js';
 import { getContext } from './context.js';
-import { AbloConnectionError, AbloValidationError } from './errors.js';
+import { AbloConnectionError, AbloValidationError } from './transaction/errors.js';
 import { InMemoryObjectStore } from './adapters/inMemoryStorage.js';
-import { syncPositionSchema } from './sync/syncPosition.js';
+import { logPositionSchema } from './transaction/logPosition.js';
 import { highestPersistedPrefixSyncId } from './sync/persistedPrefix.js';
 /**
  * Request identity excludes local timing metadata for re-entrant seals: a
@@ -208,8 +208,8 @@ export class Database {
         // Register database
         await this.databaseManager.registerDatabase(this.currentDbInfo);
         // Open workspace database
-        this.workspaceDb = await this.databaseManager.openWorkspaceDatabase(this.currentDbInfo, async (db, tx) => {
-            await this.storeManager.createStores(db, tx);
+        this.workspaceDb = await this.databaseManager.openWorkspaceDatabase(this.currentDbInfo, async (db) => {
+            await this.storeManager.createStores(db);
         });
         // Initialize stores
         await this.storeManager.initializeStores(this.workspaceDb);
@@ -328,7 +328,7 @@ export class Database {
         // (a corrupted negative/float cursor would previously pass `|| 0`,
         // which only catches falsy, and get sent to the server as the resume
         // point). Invalid → 0 → full bootstrap, the safe degradation.
-        const metadataLastSyncId = syncPositionSchema.shape.persisted.safeParse(metadata?.lastSyncId).data ?? 0;
+        const metadataLastSyncId = logPositionSchema.shape.persisted.safeParse(metadata?.lastSyncId).data ?? 0;
         const dataAge = metadata?.updatedAt ? Date.now() - metadata.updatedAt.getTime() : Infinity;
         // ── Cache-validity check ─────────────────────────────────────
         //
@@ -444,13 +444,18 @@ export class Database {
                 let deltasApplied = 0;
                 let deltaResults;
                 if (deltas.length > 0) {
-                    // Convert server delta format to processDelta format
+                    // Narrow the wire delta to what processDelta reads. The field names
+                    // are the wire's own — the only change is `id` becoming `syncId`.
+                    // A group-change frame carries its payload as a JSON string, decoded
+                    // here exactly as the live delta path does in BaseSyncedStore.
                     const formattedDeltas = deltas.map((delta) => ({
                         syncId: delta.id,
-                        actionType: delta.operation,
+                        actionType: delta.actionType,
                         modelName: delta.modelName,
-                        modelId: delta.entityId,
-                        data: delta.data,
+                        modelId: delta.modelId,
+                        data: typeof delta.data === 'string'
+                            ? JSON.parse(delta.data)
+                            : delta.data,
                     }));
                     // Use batch processing for better performance
                     const batch = await this.processDeltaBatch(formattedDeltas);
@@ -520,6 +525,13 @@ export class Database {
                         });
                     }
                 }
+                // The model is marked persisted below whether or not every item landed,
+                // because a partial store is still what the next sync reconciles
+                // against. Counted and surfaced here so a partial does not read as a
+                // clean bootstrap.
+                if (writeErrors > 0) {
+                    getContext().observability.breadcrumb(`Stored ${modelName} with ${writeErrors} of ${modelData.length} items dropped`, 'sync.database', 'warning');
+                }
                 // Mark model as persisted after successful write
                 try {
                     await this.setModelPersisted(modelName, true);
@@ -569,7 +581,7 @@ export class Database {
      *
      * Update deltas carry only the changed fields, so they are merged onto the
      * existing record rather than replacing it. That preserves fields the delta
-     * omits (such as deckId or title), and an explicit null is kept as a value,
+     * omits (such as reportId or title), and an explicit null is kept as a value,
      * clearing that field.
      */
     async processDelta(delta) {
@@ -636,7 +648,7 @@ export class Database {
                 const existing = await store.get(modelId);
                 // Skip the update when there's no existing record to merge with:
                 // building a record from partial update data would corrupt it
-                // (missing deckId, and so on).
+                // (missing reportId, and so on).
                 if (!existing) {
                     getContext().observability.breadcrumb('Skipping UPDATE delta - no existing record to merge with', 'sync.database', 'warning', {
                         modelName,
@@ -712,10 +724,14 @@ export class Database {
             case 'S':
                 getContext().observability.breadcrumb(`Group membership delta (${actionType}) reached processDelta — should be handled upstream`, 'sync.database', 'warning', { modelName, modelId: modelId.slice(0, 12), actionType });
                 return { action: 'verify', modelName, modelId, data: null };
-            default:
-                throw new AbloValidationError(`Unknown action type: ${actionType}`, {
-                    code: 'db_unknown_action_type',
-                });
+            default: {
+                // The switch above is exhaustive over the declared action types, so
+                // this branch is only reachable when a value escapes the type — hence
+                // stringifying whatever actually arrived rather than the `never`.
+                const _exhaustive = actionType;
+                void _exhaustive;
+                throw new AbloValidationError(`Unknown action type: ${JSON.stringify(actionType)}`, { code: 'db_unknown_action_type' });
+            }
         }
     }
     /**
@@ -826,8 +842,7 @@ export class Database {
             // entity has an equal or higher sync id.
             if (delta.actionType === 'U' ||
                 delta.actionType === 'I' ||
-                delta.actionType === 'C' ||
-                delta.actionType === 'M') {
+                delta.actionType === 'C') {
                 const key = `${delta.modelName}:${delta.modelId}`;
                 const deleteSyncId = deleteSyncIds.get(key);
                 if (deleteSyncId !== undefined) {
@@ -892,7 +907,7 @@ export class Database {
                             }
                         }
                     }
-                    catch (error) {
+                    catch {
                         getContext().observability.breadcrumb(`Batch read failed for ${modelName}, falling back to individual reads`, 'sync.database', 'warning');
                         // Fallback: mark all as missing for self-healing
                         for (const id of updateIds) {
@@ -991,7 +1006,7 @@ export class Database {
                             }
                             // Skip the update when there's no existing record to merge with:
                             // building a record from partial update data would corrupt it
-                            // (missing deckId, and so on).
+                            // (missing reportId, and so on).
                             if (!existing) {
                                 getContext().observability.breadcrumb('Batch: Skipping UPDATE delta - no existing record', 'sync.database', 'warning', {
                                     modelName,
@@ -1063,7 +1078,7 @@ export class Database {
                 }
             }
             catch (err) {
-                // Surface the IDB error directly — `captureTransactionFailure`
+                // Surface the IDB error directly — `captureMutationFailure`
                 // routes to Sentry, but during interactive debugging the console
                 // needs to show the specific failure (e.g. `ConstraintError`,
                 // `DataError`, `AbortError`) so we can find what's wrong with
@@ -1082,7 +1097,7 @@ export class Database {
                             : typeof delta.data,
                     })),
                 });
-                getContext().observability.captureTransactionFailure({
+                getContext().observability.captureMutationFailure({
                     context: 'batch-indexeddb-operation',
                     modelName,
                     error: idbErr,

package/dist/InstanceCache.d.ts

@@ -8,7 +8,7 @@
  */
 import { Model } from './Model.js';
 import { ModelRegistry } from './ModelRegistry.js';
-import { ModelScope } from './types/index.js';
+import { ModelScope } from './transaction/types/index.js';
 import { ViewRegistry } from './core/ViewRegistry.js';
 import { QueryView, type QueryViewOptions } from './core/QueryView.js';
 /** Constructor type for Model subclasses - uses abstract to handle variance */
@@ -50,6 +50,27 @@ export declare class InstanceCache {
     constructor(config?: PoolConfig, modelRegistry?: ModelRegistry);
     private resolveModel;
     get<T extends Model = Model>(id: string): T | undefined;
+    /**
+     * Look a row up **within one model**.
+     *
+     * The pool is a single id space: `get(id)` returns whatever row carries that
+     * id, whatever model it belongs to. That is the correct storage shape — ids
+     * are globally unique, the same premise as Relay's Global Object
+     * Identification — but it means an *untyped* lookup cannot stand in for a
+     * typed one. Apollo and EmberData avoid the question by keying their identity
+     * maps on `Type:id`; with unique ids the equivalent guarantee comes from
+     * stating the expected model at the lookup instead.
+     *
+     * Returns `undefined` for a row belonging to another model: from the asking
+     * model's perspective that id is simply absent. Callers that must tell "not
+     * here" apart from "here, but another model's" should compare against
+     * {@link get}.
+     *
+     * Prefer this over `get()` anywhere the caller knows which model it wants —
+     * `get()` returning another model's row has caused three product bugs, most
+     * recently a resize gesture that reverted after every commit.
+     */
+    getOfType<T extends Model = Model>(id: string, modelName: string): T | undefined;
     /**
      * Add model with deduplication support
      */
@@ -97,7 +118,7 @@ export declare class InstanceCache {
      * data. Cleaner than `createFromData({ __typename, ...data })` — the
      * typename lives in the arg list, not hidden inside the data object.
      *
-     * Used for optimistic local writes: `pool.create('Slide', { id, deckId, ... })`.
+     * Used for optimistic local writes: `pool.create('Section', { id, reportId, ... })`.
      * For hydration from server deltas (where `__typename` already rides on
      * the payload), use `createFromData(data)` directly — that path is kept
      * because the wire format attaches the discriminator to the data itself.
@@ -178,8 +199,8 @@ export declare class InstanceCache {
      * Register a foreign key field for indexing on a model type.
      * Call once during app initialization (e.g., after model registration).
      *
-     * Example: registerForeignKey('SlideLayer', 'slideId')
-     * This enables getByForeignKey('SlideLayer', 'slideId', someSlideId) → O(1) lookup
+     * Example: registerForeignKey('Block', 'sectionId')
+     * This enables getByForeignKey('Block', 'sectionId', someSectionId) → O(1) lookup
      */
     registerForeignKey(modelName: string, fieldName: string): void;
     /**

package/dist/InstanceCache.js

@@ -10,8 +10,8 @@ import { makeObservable, observable, action, computed, runInAction } from 'mobx'
 import { Model } from './Model.js';
 import { ModelRegistry } from './ModelRegistry.js';
 import { getContext } from './context.js';
-import { AbloValidationError } from './errors.js';
-import { ModelScope } from './types/index.js';
+import { AbloValidationError } from './transaction/errors.js';
+import { ModelScope } from './transaction/types/index.js';
 import { ViewRegistry } from './core/ViewRegistry.js';
 import { QueryView } from './core/QueryView.js';
 // Re-exported so `import { ModelScope } from './InstanceCache.js'` resolves
@@ -36,7 +36,7 @@ export class InstanceCache {
     // reactivity source; there are no computed getters with conditional cache
     // invalidation to get wrong.
     // Foreign key indexes: Map<"ModelType:fieldName", Map<fieldValue, ObservableSet<modelId>>>
-    // Enables O(1) lookups like "all SlideLayer models where slideId = X"
+    // Enables O(1) lookups like "all Block models where sectionId = X"
     // instead of scanning all models of a type and filtering.
     foreignKeyIndexes = new Map();
     // Registry of which fields to index: Map<modelName, fieldName[]>
@@ -187,6 +187,39 @@ export class InstanceCache {
         this.metrics.hits++;
         return model ?? undefined;
     }
+    /**
+     * Look a row up **within one model**.
+     *
+     * The pool is a single id space: `get(id)` returns whatever row carries that
+     * id, whatever model it belongs to. That is the correct storage shape — ids
+     * are globally unique, the same premise as Relay's Global Object
+     * Identification — but it means an *untyped* lookup cannot stand in for a
+     * typed one. Apollo and EmberData avoid the question by keying their identity
+     * maps on `Type:id`; with unique ids the equivalent guarantee comes from
+     * stating the expected model at the lookup instead.
+     *
+     * Returns `undefined` for a row belonging to another model: from the asking
+     * model's perspective that id is simply absent. Callers that must tell "not
+     * here" apart from "here, but another model's" should compare against
+     * {@link get}.
+     *
+     * Prefer this over `get()` anywhere the caller knows which model it wants —
+     * `get()` returning another model's row has caused three product bugs, most
+     * recently a resize gesture that reverted after every commit.
+     */
+    // `T` appears only in the return position, which is normally a caller-chosen
+    // cast in disguise. It is sound here precisely because `modelName` is checked
+    // at runtime below before the row is handed back, so the caller's expected
+    // type and the row's registered identity cannot disagree.
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+    getOfType(id, modelName) {
+        const model = this.get(id);
+        if (!model)
+            return undefined;
+        // Checked, so the assertion below is sound: `typeIndex` and
+        // `getModelName()` are the same registered-name identity.
+        return model.getModelName() === modelName ? model : undefined;
+    }
     /**
      * Add model with deduplication support
      */
@@ -341,13 +374,13 @@ export class InstanceCache {
             this.addToTypeIndex(id, modelType);
             // Populate the foreign-key indexes. The single-item `add()` path
             // does this; `addBatch()` used to skip it, which meant every
-            // layer / sheet cell / message that came in through a bulk
-            // loader (`ensureDeckLayers`, `prefetchSlideLayers`, bootstrap
+            // block / ledger cell / message that came in through a bulk
+            // loader (`ensureReportBlocks`, `prefetchSectionBlocks`, bootstrap
             // hydration) was in the pool but invisible to `hasMany` lookups
-            // — `slide.layers` returned `[]` until the user clicked a layer
+            // — `section.blocks` returned `[]` until the user clicked a block
             // and something else ran a non-batch `add` that happened to
             // populate the FK index as a side effect. The UX symptom was
-            // "slides show empty until you click on one." Adding this one
+            // "sections show empty until you click on one." Adding this one
             // line closes the gap.
             this.addToForeignKeyIndex(id, model, modelType);
             this.metrics.additions++;
@@ -461,7 +494,7 @@ export class InstanceCache {
         // FK cleanup silently no-ops — leaving ghost ids in the FK index.
         // That causes `getByForeignKey(..., parentId)` to report
         // `matched > returned` (dropped-no-entry) and, on the UI, keeps the
-        // stale layer visible until the next reload rebuilds the index
+        // stale block visible until the next reload rebuilds the index
         // from fresh data. Do the FK/type cleanup first, then delete the
         // entry.
         runInAction(() => {
@@ -598,7 +631,7 @@ export class InstanceCache {
      * data. Cleaner than `createFromData({ __typename, ...data })` — the
      * typename lives in the arg list, not hidden inside the data object.
      *
-     * Used for optimistic local writes: `pool.create('Slide', { id, deckId, ... })`.
+     * Used for optimistic local writes: `pool.create('Section', { id, reportId, ... })`.
      * For hydration from server deltas (where `__typename` already rides on
      * the payload), use `createFromData(data)` directly — that path is kept
      * because the wire format attaches the discriminator to the data itself.
@@ -643,7 +676,7 @@ export class InstanceCache {
                 existing.updateFromData(data);
                 return existing;
             }
-            // Different type with same ID - this is a shared PK scenario (e.g., Project/Dataroom)
+            // Different type with same ID - this is a shared PK scenario (e.g., two models sharing one row id)
             // Don't return existing, create new model (will use composite key for storage)
         }
         // Log model creation attempt
@@ -658,7 +691,7 @@ export class InstanceCache {
             // Internal construction failure — captured via observability below and
             // re-fetched on resync; the stack is forensic → debug.
             getContext().logger.debug(`[InstanceCache.createFromData] FAILED ${modelName}`, { errorMessage, stack: error instanceof Error ? error.stack : undefined });
-            getContext().observability.captureTransactionFailure({
+            getContext().observability.captureMutationFailure({
                 context: 'createFromData',
                 modelName,
                 modelId: data.id,
@@ -849,7 +882,7 @@ export class InstanceCache {
                 // caused silent data loss — any model actively being rendered
                 // through a schema-driven dynamic class (i.e., most of them)
                 // would be demoted, collected, and the next render's
-                // `weakRef.deref()` returned undefined, so layers / cells /
+                // `weakRef.deref()` returned undefined, so blocks / cells /
                 // messages "disappeared" after ~10 min of idle.
                 //
                 // The `hasObservedCollections()` guard used by the eviction
@@ -934,8 +967,8 @@ export class InstanceCache {
      * Register a foreign key field for indexing on a model type.
      * Call once during app initialization (e.g., after model registration).
      *
-     * Example: registerForeignKey('SlideLayer', 'slideId')
-     * This enables getByForeignKey('SlideLayer', 'slideId', someSlideId) → O(1) lookup
+     * Example: registerForeignKey('Block', 'sectionId')
+     * This enables getByForeignKey('Block', 'sectionId', someSectionId) → O(1) lookup
      */
     registerForeignKey(modelName, fieldName) {
         const fields = this.foreignKeyConfig.get(modelName) ?? [];
@@ -977,7 +1010,7 @@ export class InstanceCache {
         // entry for this specific parent id (entity genuinely has no
         // children). These used to `console.warn` diagnostic dumps on every
         // call, which turned into hundreds of log lines per second during
-        // cursor hover / rapid re-renders on the deck page. If a caller
+        // cursor hover / rapid re-renders on a busy page. If a caller
         // needs visibility into "why is this empty," wire an opt-in
         // `logger.debug` at the specific call site rather than re-adding
         // a blanket warn here.

package/dist/LazyReferenceCollection.d.ts

@@ -86,9 +86,9 @@ export declare class LazyReferenceCollection<T extends Model> {
      * so any pool.remove invalidates the computed and re-renders the
      * consumer with the deleted item gone.
      *
-     * Without this, deleting a slide layer would pool.remove() cleanly
-     * but the canvas — which reads `slide.layers.value` — would keep
-     * showing the deleted layer until a full reload rebuilt the
+     * Without this, deleting a block would pool.remove() cleanly
+     * but the view — which reads `section.blocks.value` — would keep
+     * showing the deleted block until a full reload rebuilt the
      * collection.
      */
     get value(): T[];

package/dist/LazyReferenceCollection.js

@@ -7,7 +7,7 @@ import { makeObservable, observable, action, computed, onBecomeObserved, onBecom
 import { Database } from './Database.js';
 import { InstanceCache } from './InstanceCache.js';
 import { getActiveRegistry } from './ModelRegistry.js';
-import { AbloValidationError } from './errors.js';
+import { AbloValidationError } from './transaction/errors.js';
 /**
  * A lazy-loaded one-to-many relationship between a parent {@link Model} and
  * its children. It reads from the local store first and falls back to the
@@ -136,9 +136,9 @@ export class LazyReferenceCollection {
      * so any pool.remove invalidates the computed and re-renders the
      * consumer with the deleted item gone.
      *
-     * Without this, deleting a slide layer would pool.remove() cleanly
-     * but the canvas — which reads `slide.layers.value` — would keep
-     * showing the deleted layer until a full reload rebuilt the
+     * Without this, deleting a block would pool.remove() cleanly
+     * but the view — which reads `section.blocks.value` — would keep
+     * showing the deleted block until a full reload rebuilt the
      * collection.
      */
     get value() {

package/dist/Model.d.ts

@@ -120,10 +120,10 @@ export declare abstract class Model {
      * narrow the return to their concrete store type.
      *
      * @example
-     *   // In a Slide model getter
-     *   const store = Slide.getStore();
+     *   // In a Section model getter
+     *   const store = Section.getStore();
      *   if (!store) return [];
-     *   return store.getByForeignKey<SlideLayer>('SlideLayer', 'slideId', this.id);
+     *   return store.getByForeignKey<Block>('Block', 'sectionId', this.id);
      */
     static getStore<T extends SyncStoreRef = SyncStoreRef>(): T | null;
     /**
@@ -159,7 +159,7 @@ export declare abstract class Model {
      *
      * This per-instance baseline is needed because application code can edit a
      * model in two ways that coexist: a direct property write
-     * (`slide.title = 'foo'`) and a recorded mutation. A design in which every
+     * (`section.title = 'foo'`) and a recorded mutation. A design in which every
      * write went through a single recorded path would not need it, since the
      * last acknowledged state would already be the authoritative baseline.
      */
@@ -172,8 +172,8 @@ export declare abstract class Model {
      * Capture a before-image for `keys` — the single source of truth for the
      * "previous value" that undo inverses are built from. Both undo paths call
      * this so they can never drift: the stream path
-     * (`TransactionQueue.extractPreviousData`) and the manual-record path
-     * (`RecordingTransaction.snapshotFields`).
+     * (`MutationQueue.extractPreviousData`) and the manual-record path
+     * (`RecordingMutation.snapshotFields`).
      *
      * Resolution order per key:
      *   1. `modifiedProperties.get(key).old` — first-old-wins pre-session

package/dist/Model.js

@@ -11,7 +11,7 @@ import { v4 as uuid } from 'uuid';
 import { M1 } from './utils/mobxSetup.js';
 import { getActiveRegistry, hasActiveRegistry } from './ModelRegistry.js';
 import { getContext } from './context.js';
-import { AbloValidationError } from './errors.js';
+import { AbloValidationError } from './transaction/errors.js';
 /**
  * Validation error for model validation failures
  */
@@ -78,7 +78,7 @@ export class Model {
         // A record that arrives WITH `createdAt` but WITHOUT `updatedAt` is
         // server/IDB data whose update timestamp didn't survive the wire —
         // falling back to "now" here fabricated an edit time for every such
-        // record on every bootstrap (the decks gallery sorted everything to
+        // record on every bootstrap (the reports gallery sorted everything to
         // "edited just now"). Fall back to createdAt instead; only a genuinely
         // new local model (no dates at all) stamps the current time.
         this.updatedAt = data.updatedAt
@@ -113,10 +113,10 @@ export class Model {
      * narrow the return to their concrete store type.
      *
      * @example
-     *   // In a Slide model getter
-     *   const store = Slide.getStore();
+     *   // In a Section model getter
+     *   const store = Section.getStore();
      *   if (!store) return [];
-     *   return store.getByForeignKey<SlideLayer>('SlideLayer', 'slideId', this.id);
+     *   return store.getByForeignKey<Block>('Block', 'sectionId', this.id);
      */
     static getStore() {
         return Model.store;
@@ -142,9 +142,9 @@ export class Model {
             // Preserve the earliest captured `old` for this field until the entry
             // is cleared (by `clearChanges` on sync-ack or by a mutator consuming
             // it). Consecutive in-place mutations between mutator invocations —
-            // e.g. a drag loop writing `layer.position = ...` on every frame —
+            // e.g. a drag loop writing `block.position = ...` on every frame —
             // would otherwise overwrite `.old` with each frame's predecessor,
-            // destroying the pre-session baseline that `RecordingTransaction`
+            // destroying the pre-session baseline that `RecordingMutation`
             // relies on to record a correct undo inverse. `.new` always reflects
             // the latest value so the transaction queue's `getChanges()` keeps
             // sending the right payload to the server.
@@ -194,7 +194,7 @@ export class Model {
      *
      * This per-instance baseline is needed because application code can edit a
      * model in two ways that coexist: a direct property write
-     * (`slide.title = 'foo'`) and a recorded mutation. A design in which every
+     * (`section.title = 'foo'`) and a recorded mutation. A design in which every
      * write went through a single recorded path would not need it, since the
      * last acknowledged state would already be the authoritative baseline.
      */
@@ -214,8 +214,8 @@ export class Model {
      * Capture a before-image for `keys` — the single source of truth for the
      * "previous value" that undo inverses are built from. Both undo paths call
      * this so they can never drift: the stream path
-     * (`TransactionQueue.extractPreviousData`) and the manual-record path
-     * (`RecordingTransaction.snapshotFields`).
+     * (`MutationQueue.extractPreviousData`) and the manual-record path
+     * (`RecordingMutation.snapshotFields`).
      *
      * Resolution order per key:
      *   1. `modifiedProperties.get(key).old` — first-old-wins pre-session

package/dist/ModelRegistry.d.ts

@@ -7,7 +7,7 @@
  * classes. References resolve lazily, so a model may declare a reference to
  * another model that is registered later.
  */
-import { type ModelMetadata, type PropertyMetadata, type ReferenceMetadata, LoadStrategy } from './types/index.js';
+import { type ModelMetadata, type PropertyMetadata, type ReferenceMetadata, LoadStrategy } from './transaction/types/index.js';
 import type { Model } from './Model.js';
 import type { ConcreteModelConstructor } from './BaseSyncedStore.js';
 /**
@@ -51,9 +51,9 @@ export interface SerializedReferenceMetadata extends Omit<ExtendedReferenceMetad
  * child's pending transactions can be cancelled.
  */
 export interface BackReferenceMetadata {
-    /** The parent model name (e.g., 'SlideDeck') */
+    /** The parent model name (e.g., 'Report') */
     parentModel: string;
-    /** The foreign key property on this model (e.g., 'deckId') */
+    /** The foreign key property on this model (e.g., 'reportId') */
     foreignKey: string;
     /** Whether to cascade-cancel transactions when parent is deleted */
     cascadeDelete: boolean;
@@ -107,7 +107,7 @@ export declare class ModelRegistry {
      * transactions for every child model that declares a back-reference to that
      * parent.
      *
-     * @param childModelName - The model that holds a foreign key to the parent (e.g., 'Slide')
+     * @param childModelName - The model that holds a foreign key to the parent (e.g., 'Section')
      * @param metadata - The back-reference configuration
      */
     registerBackReference(childModelName: string, metadata: BackReferenceMetadata): void;

package/dist/ModelRegistry.js

@@ -8,9 +8,9 @@
  * another model that is registered later.
  */
 // Removed Node.js crypto import for browser compatibility
-import { PropertyType, LoadStrategy, } from './types/index.js';
+import { PropertyType, LoadStrategy, } from './transaction/types/index.js';
 import { getContext } from './context.js';
-import { AbloValidationError } from './errors.js';
+import { AbloValidationError } from './transaction/errors.js';
 /**
  * Module-level active registry. Set by createSyncEngine so that Model instances
  * (which don't receive DI) can look up metadata without static maps.
@@ -248,7 +248,7 @@ export class ModelRegistry {
      * transactions for every child model that declares a back-reference to that
      * parent.
      *
-     * @param childModelName - The model that holds a foreign key to the parent (e.g., 'Slide')
+     * @param childModelName - The model that holds a foreign key to the parent (e.g., 'Section')
      * @param metadata - The back-reference configuration
      */
     registerBackReference(childModelName, metadata) {