@abloatai/ablo 0.25.0 → 0.26.0

package/dist/Database.d.ts

@@ -77,12 +77,12 @@ export interface BootstrapResult {
      * was disconnected — without this, DELETE deltas persist to IDB but
      * ghost entities linger in the pool until a full reload.
      */
-    deltaResults?: Array<{
+    deltaResults?: {
         action: 'add' | 'update' | 'remove' | 'archive' | 'verify';
         modelName: string;
         modelId: string;
         data?: ModelData | null;
-    }>;
+    }[];
 }
 export declare class Database {
     private databaseManager;
@@ -236,7 +236,7 @@ export declare class Database {
      * - Skips stale updates for entities that will be/were deleted
      * - Prevents 404 errors from fetching already-deleted entities
      */
-    processDeltaBatch(deltas: Array<{
+    processDeltaBatch(deltas: {
         syncId?: number;
         /**
          * Includes 'G' and 'S' defensively — they're routed upstream and
@@ -257,14 +257,14 @@ export declare class Database {
          * have a client transaction.
          */
         transactionId?: string;
-    }>): Promise<{
-        results: Array<{
+    }[]): Promise<{
+        results: {
             action: 'add' | 'update' | 'remove' | 'archive' | 'verify';
             modelName: string;
             modelId: string;
             data?: ModelData | null;
             transactionId?: string;
-        }>;
+        }[];
         /**
          * Highest syncId whose IDB store transaction actually committed in this
          * batch. The runtime delta cursor (WS `lastSyncId`, server-side
@@ -292,7 +292,6 @@ export declare class Database {
     /** Read workspace metadata from IDB (returns null if db not open). */
     getWorkspaceMetadata(): Promise<WorkspaceMetadata | null>;
     getLastSyncId(): Promise<number>;
-    getVersionVector(): Promise<Record<string, number> | null>;
     updateWorkspaceMetadata(metadata: Partial<WorkspaceMetadata>): Promise<void>;
     /** Transaction persistence for offline/retry support.
      *  Returns either the IDB-backed ObjectStore or its in-memory twin
@@ -332,13 +331,13 @@ export declare class Database {
                 notReady: number;
             };
             totalRecords: number;
-            storeDetails: Array<{
+            storeDetails: {
                 modelName: string;
                 storeName: string;
                 strategy: LoadStrategy;
                 ready: boolean;
                 count: number;
-            }>;
+            }[];
         };
         metadata: WorkspaceMetadata | null;
     }>;

package/dist/Database.js

@@ -4,6 +4,7 @@
  */
 import { DatabaseManager } from './core/DatabaseManager.js';
 import { StoreManager } from './core/StoreManager.js';
+import { ModelRegistry } from './ModelRegistry.js';
 import { LoadStrategy } from './types/index.js';
 import { getContext } from './context.js';
 import { AbloConnectionError, AbloValidationError } from './errors.js';
@@ -105,7 +106,7 @@ export class Database {
     logPreservedFields(modelName, modelId, existing, delta) {
         if (modelName === 'Activity')
             return;
-        const requiredFields = this.essentialFields[modelName] || [];
+        const requiredFields = this.essentialFields[modelName] ?? [];
         const preserved = requiredFields.filter((field) => existing[field] !== undefined && delta[field] === undefined);
         if (preserved.length > 0) {
             getContext().logger.debug('[Database] UPDATE merged - preserved fields', {
@@ -324,7 +325,7 @@ export class Database {
             type,
             modelsToLoad,
             lastSyncId,
-            syncGroups: metadata?.syncGroups || [],
+            syncGroups: metadata?.syncGroups ?? [],
         };
     }
     /**
@@ -360,7 +361,7 @@ export class Database {
                 lastSyncId: bootstrapData.lastSyncId,
                 hasModels: !!bootstrapData.models,
                 hasDeltas: !!bootstrapData.deltas,
-                deltaCount: bootstrapData.deltaCount || 0,
+                deltaCount: bootstrapData.deltaCount ?? 0,
             });
             // ✅ Only clear AFTER successful fetch (transactional safety)
             // IMPORTANT: Clear if the SERVER says it's a full snapshot, regardless of what we asked.
@@ -369,7 +370,7 @@ export class Database {
             }
             // Handle partial bootstrap (delta batch)
             if (bootstrapData.type === 'partial') {
-                const deltas = bootstrapData.deltas || [];
+                const deltas = bootstrapData.deltas ?? [];
                 getContext().logger.info('Processing partial bootstrap with delta batch', {
                     deltaCount: deltas.length,
                     fromSyncId: requirements.lastSyncId,
@@ -783,7 +784,7 @@ export class Database {
                 const deleteSyncId = deleteSyncIds.get(key);
                 if (deleteSyncId !== undefined) {
                     // DELETE exists for this entity
-                    const deltaSyncId = delta.syncId || 0;
+                    const deltaSyncId = delta.syncId ?? 0;
                     if (deleteSyncId >= deltaSyncId) {
                         // DELETE has equal or higher syncId - skip this UPDATE/INSERT
                         getContext().logger.debug('[Database.processDeltaBatch] Skipping stale delta (DELETE wins)', {
@@ -989,8 +990,8 @@ export class Database {
                 }
                 // Wait for transaction to complete
                 await new Promise((resolve, reject) => {
-                    tx.oncomplete = () => resolve();
-                    tx.onerror = () => reject(tx.error);
+                    tx.oncomplete = () => { resolve(); };
+                    tx.onerror = () => { reject(tx.error); };
                 });
                 // Only commit staged results to the global results if the transaction succeeded.
                 // Also advance `highestPersistedSyncId` ONLY for deltas in this successful tx
@@ -1122,13 +1123,7 @@ export class Database {
             return 0;
         }
         const metadata = await this.databaseManager.getWorkspaceMetadata(this.workspaceDb);
-        return metadata?.lastSyncId || 0;
-    }
-    async getVersionVector() {
-        if (!this.workspaceDb)
-            return null;
-        const metadata = await this.databaseManager.getWorkspaceMetadata(this.workspaceDb);
-        return (metadata?.versions || null);
+        return metadata?.lastSyncId ?? 0;
     }
     async updateWorkspaceMetadata(metadata) {
         // In-memory mode: store in local variable

package/dist/LazyReferenceCollection.js

@@ -5,6 +5,8 @@
  * data on-demand with intelligent caching and batching.
  */
 import { makeObservable, observable, action, computed, onBecomeObserved, onBecomeUnobserved, } from 'mobx';
+import { Database } from './Database.js';
+import { ObjectPool } from './ObjectPool.js';
 import { getActiveRegistry } from './ModelRegistry.js';
 import { AbloValidationError } from './errors.js';
 /**
@@ -289,6 +291,9 @@ export class LazyReferenceCollection {
                     this.objectPool.add(model);
                 }
                 if (model) {
+                    // The by-name registry lookup types instances as the base
+                    // `Model`; this collection's `modelName` IS `T`'s registered
+                    // name (fixed at construction), so the instance is a `T`.
                     models.push(model);
                 }
             }

package/dist/Model.js

@@ -70,7 +70,7 @@ export class Model {
     _observedCollections = new Set();
     constructor(data = {}) {
         // Always generate permanent UUID on client
-        this.id = data.id || Model.generateId();
+        this.id = data.id ?? Model.generateId();
         this.clientId = this.id; // No more temp IDs!
         // Ensure dates are Date objects, not strings
         this.createdAt = data.createdAt
@@ -91,7 +91,7 @@ export class Model {
             : data.createdAt
                 ? new Date(this.createdAt)
                 : new Date();
-        this.syncStatus = data.syncStatus || 'pending';
+        this.syncStatus = data.syncStatus ?? 'pending';
     }
     /**
      * Generate unique ID
@@ -340,9 +340,7 @@ export class Model {
      * Add validation rule
      */
     addValidationRule(propName, rule) {
-        if (!this.validationRules[propName]) {
-            this.validationRules[propName] = [];
-        }
+        this.validationRules[propName] ??= [];
         this.validationRules[propName].push(rule);
     }
     /**
@@ -575,7 +573,7 @@ export class Model {
             syncStatus: this.syncStatus,
         };
         if (this.archivedAt !== undefined) {
-            result.archivedAt = this.archivedAt?.toISOString() || null;
+            result.archivedAt = this.archivedAt?.toISOString() ?? null;
         }
         if (properties) {
             const self = this;
@@ -616,7 +614,7 @@ export class Model {
         const className = this.constructor.name;
         // Use consumer-provided fallback map from config (replaces hardcoded Prisma name map)
         const fallbackMap = getContext().config.classNameFallbackMap;
-        return fallbackMap[className] || className.replace(/Model$/, '');
+        return fallbackMap[className] ?? className.replace(/Model$/, '');
     }
     /**
      * Read a field value by name. Runtime-safe dynamic field access —
@@ -809,7 +807,7 @@ export class Model {
      */
     static fromJSON(data) {
         // Support both __class and __typename, and handle both old and new naming
-        const modelIdentifier = data.__typename || data.__class || data.modelName;
+        const modelIdentifier = data.__typename ?? data.__class ?? data.modelName;
         if (!modelIdentifier) {
             throw new AbloValidationError('Model identifier (__typename, __class, or modelName) not found in data', { code: 'model_identifier_missing' });
         }

package/dist/ModelRegistry.d.ts

@@ -9,7 +9,26 @@
  * - Comprehensive error reporting
  * - Best practices from Linear Sync Engine
  */
-import { ModelMetadata, PropertyMetadata, ReferenceMetadata, LoadStrategy } from './types/index.js';
+import { type ModelMetadata, type PropertyMetadata, type ReferenceMetadata, LoadStrategy } from './types/index.js';
+import type { Model } from './Model.js';
+import type { ConcreteModelConstructor } from './BaseSyncedStore.js';
+/**
+ * What callers may hand to {@link ModelRegistry.registerModel}: any concrete
+ * `Model` subclass constructor. `never[]` params make every subclass
+ * constructor assignable (construct-signature params are contravariant).
+ */
+export type ModelClassInput = new (...args: never[]) => Model;
+/**
+ * What the registry hands BACK: a registered model class — concretely
+ * constructible with an optional data row (`ConcreteModelConstructor`, the
+ * SDK's existing Model-vs-row construction seam) and carrying `Model`'s
+ * statics (`fromJSON`, …). `Omit<typeof Model, never>` keeps the statics
+ * while stripping the ABSTRACT construct signature (mapped types drop
+ * construct signatures), so `new registry.getModelByName(n)!(...)` is legal.
+ * The one cast from {@link ModelClassInput} lives at the validated
+ * registration boundary below.
+ */
+export type RegisteredModelClass = Omit<typeof Model, never> & ConcreteModelConstructor<Model>;
 /**
  * Extended ReferenceMetadata with additional Linear-style options
  */
@@ -73,7 +92,7 @@ export declare class ModelRegistry {
     /**
      * Register a model with validation
      */
-    registerModel(name: string, constructor: any, metadata?: ModelMetadata): void;
+    registerModel(name: string, constructor: ModelClassInput, metadata?: ModelMetadata): void;
     /**
      * Register property with validation
      */
@@ -95,7 +114,7 @@ export declare class ModelRegistry {
     /** Get all models with specific load strategy. */
     getModelsByLoadStrategy(strategy: LoadStrategy): string[];
     /** Get model name from constructor (production-safe). */
-    getModelNameFromConstructor(constructor: any): string | undefined;
+    getModelNameFromConstructor(constructor: unknown): string | undefined;
     /** Get properties for a model. */
     getPropertiesForModel(modelName: string): Map<string, PropertyMetadata>;
     /**
@@ -103,7 +122,7 @@ export declare class ModelRegistry {
      */
     getRegisteredModelNames(): string[];
     /** Get model constructor by name */
-    getModelByName(name: string): any;
+    getModelByName(name: string): RegisteredModelClass | undefined;
     /** Check if model is registered */
     hasModel(name: string): boolean;
     /** Get model metadata by name */
@@ -117,10 +136,10 @@ export declare class ModelRegistry {
     /** Get back-references for a child model */
     getBackReferences(childModelName: string): BackReferenceMetadata[];
     /** Get child models for a parent */
-    getChildModels(parentModelName: string): Array<{
+    getChildModels(parentModelName: string): {
         childModel: string;
         foreignKey: string;
-    }>;
+    }[];
     /**
      * Calculate schema hash using crypto
      */

package/dist/ModelRegistry.js

@@ -43,7 +43,9 @@ export class ModelRegistry {
     properties = new Map();
     references = new Map();
     pendingReferences = new Map();
-    // 🔧 PROPER FIX: Static mapping from constructor to model name
+    // 🔧 PROPER FIX: Static mapping from constructor to model name.
+    // Keyed `unknown` on purpose: lookups arrive as `this.constructor`
+    // (Function) and as typed model classes — both accepted without casts.
     constructorToModelName = new Map();
     // LINEAR PATTERN: BackReferences for cascade-aware transaction handling.
     // Maps childModelName → BackReferenceMetadata[] (which parent models
@@ -65,13 +67,14 @@ export class ModelRegistry {
         if (typeof constructor !== 'function') {
             throw new AbloValidationError(`Model ${name} constructor must be a function`, { code: 'registry_invalid_constructor' });
         }
-        if (!constructor.prototype) {
+        const prototype = constructor.prototype;
+        if (!prototype || typeof prototype !== 'object') {
             throw new AbloValidationError(`Model ${name} constructor must have a prototype`, { code: 'registry_invalid_constructor' });
         }
         // Check for required methods
         const required = ['updateFromData', 'toJSON', 'getModelName'];
         for (const method of required) {
-            if (typeof constructor.prototype[method] !== 'function') {
+            if (typeof prototype[method] !== 'function') {
                 getContext().logger.debug('Model missing required method', name, { method });
             }
         }
@@ -159,8 +162,12 @@ export class ModelRegistry {
             return;
         }
         getContext().logger.debug('Registering model', name);
-        // Register
-        this.models.set(name, constructor);
+        // Register. The one cast in this file: input is any Model-subclass
+        // constructor (validated above); registered classes are concrete
+        // subclasses constructible with `data?` and carrying Model's statics —
+        // the shape `RegisteredModelClass` names for every read site.
+        const modelClass = constructor;
+        this.models.set(name, modelClass);
         this.modelMetadata.set(name, metadata);
         // 🔧 PROPER FIX: Create reverse mapping from constructor to model name
         this.constructorToModelName.set(constructor, name);
@@ -291,7 +298,6 @@ export class ModelRegistry {
         return Array.from(this.models.keys());
     }
     /** Get model constructor by name */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     getModelByName(name) {
         return this.models.get(name);
     }

package/dist/NetworkMonitor.js

@@ -18,7 +18,7 @@ export class NetworkMonitor extends EventEmitter {
         super();
         this.setupListeners();
     }
-    handleOnline = async () => {
+    handleOnline = () => {
         const wasOffline = !this.isOnline;
         this.isOnline = true;
         this.lastOnlineCheck = new Date();

package/dist/ObjectPool.js

@@ -4,7 +4,9 @@
  * Pure memory management without database or registry dependencies.
  * Uses static ModelRegistry for model class lookup only.
  */
-import { makeObservable, observable, action, computed, runInAction } from 'mobx';
+import { makeObservable, observable, action, computed, runInAction, set } 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';
@@ -203,7 +205,7 @@ export class ObjectPool {
         }
         // Check if model already exists to prevent duplicates
         const existingEntry = this.entries.get(id);
-        if (existingEntry && existingEntry.model && !existingEntry.model.disposed) {
+        if (existingEntry?.model && !existingEntry.model.disposed) {
             // Model already exists and is valid, update its scope if needed
             if (existingEntry.scope !== scope) {
                 runInAction(() => {
@@ -320,7 +322,7 @@ export class ObjectPool {
             }
             // Skip if model already exists and is valid
             const existingEntry = this.entries.get(id);
-            if (existingEntry && existingEntry.model && !existingEntry.model.disposed) {
+            if (existingEntry?.model && !existingEntry.model.disposed) {
                 if (existingEntry.scope !== scope) {
                     this.entries.set(id, { ...existingEntry, scope });
                     this.accessTimes.set(id, now);
@@ -881,6 +883,10 @@ export class ObjectPool {
         if (this.gcTimer)
             return;
         this.gcTimer = setInterval(() => this.gc(), this.config.gcInterval);
+        // Don't hold a headless Node process open just for pool GC — without
+        // this, an agent that never calls disconnect() can never exit. No-op in
+        // browsers (where setInterval returns a number without `unref`).
+        this.gcTimer.unref?.();
     }
     stopGC() {
         if (this.gcTimer) {

package/dist/SyncClient.d.ts

@@ -117,6 +117,10 @@ export declare class SyncClient extends EventEmitter {
      * will deliver the missing deltas and naturally confirm the transaction.
      */
     private setupAwaitingTransactionPersistence;
+    /** Persist an unconfirmed transaction to IDB (never rejects — failures are captured). */
+    private persistAwaitingTransaction;
+    /** Drop the persisted awaiting-row once confirmed (never rejects). */
+    private removeAwaitingTransaction;
     /**
      * Initialize sync client with authentication
      */
@@ -254,7 +258,12 @@ export declare class SyncClient extends EventEmitter {
      */
     private persistMutationQueue;
     /**
-     * Restore mutation queue from IndexedDB
+     * Restore mutation queue from IndexedDB.
+     *
+     * The persisted record was written by a PREVIOUS session (possibly an older
+     * SDK build), so each entry is validated at this replay boundary (T1.8):
+     * corrupt entries are dropped + logged at debug, and a failure never
+     * vanishes into an empty catch — offline write survival must be observable.
      */
     private restoreMutationQueue;
     /**
@@ -278,10 +287,11 @@ export declare class SyncClient extends EventEmitter {
      * CRITICAL: Always respects certain server states (deletes, deactivations)
      * even when there are local changes, to maintain data consistency.
      */
-    resolveConflicts(localModel: Model, serverData: any): Model;
+    resolveConflicts(localModel: Model, serverData: Record<string, unknown>): Model;
     /**
      * Extract critical state fields from server data
-     * These are states that must always be respected, even with local changes
+     * These are states that must always be respected, even with local changes.
+     * The conflict brain reads exactly these known fields — nothing else.
      */
     private extractCriticalState;
     /**
@@ -482,7 +492,7 @@ export declare class SyncClient extends EventEmitter {
      * consumers — `Ablo` itself is the public surface.
      */
     getTransactionQueue(): TransactionQueue;
-    applyDeltaBatchToPool(dbResults: Array<{
+    applyDeltaBatchToPool(dbResults: {
         action: string;
         modelName: string;
         modelId: string;
@@ -495,7 +505,7 @@ export declare class SyncClient extends EventEmitter {
          * schema-derived deltas, etc.) don't have a client transaction.
          */
         transactionId?: string;
-    }>, enrichRelations: (modelName: string, data: Record<string, unknown>) => Record<string, unknown>): void;
+    }[], enrichRelations: (modelName: string, data: Record<string, unknown>) => Record<string, unknown>): void;
     /**
      * Apply bootstrap data to the ObjectPool with ghost removal.
      * Owns: model creation, batch upsert, ghost detection + removal.