@abloatai/ablo 0.34.1 → 0.36.0

package/dist/{core → stores}/StoreManager.d.ts

@@ -3,13 +3,13 @@
  * browser — one per registered model — alongside the single
  * {@link SyncActionStore} for pending changes. It creates each store from the
  * model's metadata, tracks readiness, and provisions the underlying IndexedDB
- * object stores. A model's load strategy (instant, lazy, or partial) decides
- * how and when its data is loaded.
+ * object stores. A model's load strategy — instant or lazy — decides how and
+ * when its data is loaded.
  */
 import { ModelRegistry } from '../ModelRegistry.js';
-import { ObjectStore } from '../stores/ObjectStore.js';
-import { SyncActionStore } from '../stores/SyncActionStore.js';
-import { LoadStrategy } from '../types/index.js';
+import { ObjectStore } from './ObjectStore.js';
+import { SyncActionStore } from './SyncActionStore.js';
+import { LoadStrategy } from '../transaction/types/index.js';
 /**
  * StoreManager - Central manager for all ObjectStore instances
  *
@@ -20,6 +20,7 @@ import { LoadStrategy } from '../types/index.js';
  * - Handles store-specific optimizations based on load strategies
  */
 export declare class StoreManager {
+    private readonly runtime;
     private stores;
     /** Strict-durability wrapper for the client write journal and commit outbox. */
     private transactionStore;
@@ -27,7 +28,7 @@ export declare class StoreManager {
     private db;
     private isInitialized;
     private modelRegistry;
-    constructor(modelRegistry: ModelRegistry);
+    constructor(modelRegistry: ModelRegistry, runtime?: RuntimeContext);
     /**
      * Initialize all stores for registered models
      */
@@ -39,7 +40,7 @@ export declare class StoreManager {
     /**
      * Create stores (tables) in IndexedDB
      */
-    createStores(db: IDBDatabase, transaction: IDBTransaction): Promise<void>;
+    createStores(db: IDBDatabase): Promise<void>;
     /**
      * Create special tables (sync_action_table, model_table, model_table_partial, __meta, __transactions)
      */
@@ -74,25 +75,10 @@ export declare class StoreManager {
      * than scanning them all, and returns true as soon as one has records.
      */
     hasAnyData(): Promise<boolean>;
-    /**
-     * Get store type distribution for debugging
-     */
-    getStoreTypeDistribution(): {
-        full: number;
-        partial: number;
-    };
     /**
      * Get stores by load strategy
      */
     getStoresByStrategy(strategy: LoadStrategy): ObjectStore[];
-    /**
-     * Get models to load for bootstrapping
-     */
-    getModelsToLoad(): {
-        instant: string[];
-        lazy: string[];
-        partial: string[];
-    };
     /**
      * Perform maintenance on all stores
      */
@@ -111,10 +97,6 @@ export declare class StoreManager {
      */
     getComprehensiveStats(): Promise<{
         totalStores: number;
-        storeTypes: {
-            full: number;
-            partial: number;
-        };
         readiness: {
             ready: number;
             notReady: number;
@@ -129,3 +111,4 @@ export declare class StoreManager {
         }[];
     }>;
 }
+import type { RuntimeContext } from '../RuntimeContext.js';

package/dist/{core → stores}/StoreManager.js

@@ -3,14 +3,14 @@
  * browser — one per registered model — alongside the single
  * {@link SyncActionStore} for pending changes. It creates each store from the
  * model's metadata, tracks readiness, and provisions the underlying IndexedDB
- * object stores. A model's load strategy (instant, lazy, or partial) decides
- * how and when its data is loaded.
+ * object stores. A model's load strategy — instant or lazy — decides how and
+ * when its data is loaded.
  */
 import { ModelRegistry } from '../ModelRegistry.js';
-import { ObjectStore } from '../stores/ObjectStore.js';
-import { SyncActionStore } from '../stores/SyncActionStore.js';
-import { LoadStrategy } from '../types/index.js';
-import { AbloValidationError } from '../errors.js';
+import { ObjectStore } from './ObjectStore.js';
+import { SyncActionStore } from './SyncActionStore.js';
+import { LoadStrategy } from '../transaction/types/index.js';
+import { AbloValidationError } from '../transaction/errors.js';
 /**
  * StoreManager - Central manager for all ObjectStore instances
  *
@@ -21,6 +21,7 @@ import { AbloValidationError } from '../errors.js';
  * - Handles store-specific optimizations based on load strategies
  */
 export class StoreManager {
+    runtime;
     stores = new Map();
     /** Strict-durability wrapper for the client write journal and commit outbox. */
     transactionStore = null;
@@ -28,7 +29,8 @@ export class StoreManager {
     db = null;
     isInitialized = false;
     modelRegistry;
-    constructor(modelRegistry) {
+    constructor(modelRegistry, runtime = globalRuntime) {
+        this.runtime = runtime;
         this.modelRegistry = modelRegistry;
     }
     /**
@@ -38,10 +40,10 @@ export class StoreManager {
         this.db = db;
         if (this.isInitialized) {
             // Idempotent re-entry — harmless, nothing for the consumer to act on → debug.
-            getContext().logger.debug('StoreManager already initialized');
+            this.runtime.logger.debug('StoreManager already initialized');
             return;
         }
-        getContext().logger.info('Initializing ObjectStore instances for all models');
+        this.runtime.logger.info('Initializing ObjectStore instances for all models');
         const startTime = performance.now();
         // Get all registered models
         const allModels = this.modelRegistry.getRegisteredModelNames();
@@ -55,17 +57,14 @@ export class StoreManager {
         // mode.
         this.transactionStore = new ObjectStore(this.db, '__transactions', '__transactions', { loadStrategy: LoadStrategy.instant }, 'strict');
         // Initialize SyncactionStore
-        this.syncactionStore = new SyncActionStore(this.db);
+        this.syncactionStore = new SyncActionStore(this.db, this.runtime);
         await this.syncactionStore.initialize();
         this.isInitialized = true;
         const duration = performance.now() - startTime;
-        getContext().logger.info('Initialized ObjectStores and SyncactionStore', {
+        this.runtime.logger.info('Initialized ObjectStores and SyncactionStore', {
             count: this.stores.size,
             ms: duration.toFixed(2),
         });
-        // Log store distribution
-        const storeTypes = this.getStoreTypeDistribution();
-        getContext().logger.debug('Store distribution', storeTypes);
     }
     /**
      * Create ObjectStore for a specific model
@@ -86,16 +85,15 @@ export class StoreManager {
     /**
      * Create stores (tables) in IndexedDB
      */
-    async createStores(db, transaction) {
-        getContext().logger.info('Creating tables for all registered models');
+    async createStores(db) {
+        this.runtime.logger.info('Creating tables for all registered models');
         for (const modelName of this.modelRegistry.getRegisteredModelNames()) {
             const storeName = modelName;
-            const metadata = this.modelRegistry.getMetadata(modelName);
             // Skip if store already exists
             if (db.objectStoreNames.contains(storeName)) {
                 continue;
             }
-            getContext().logger.debug('Creating table', { storeName, modelName });
+            this.runtime.logger.debug('Creating table', { storeName, modelName });
             // Create object store with id as keyPath
             const store = db.createObjectStore(storeName, { keyPath: 'id' });
             // Create indexes for indexed properties
@@ -103,18 +101,14 @@ export class StoreManager {
             for (const propName of indexedProperties) {
                 try {
                     store.createIndex(propName, propName, { unique: false });
-                    getContext().logger.debug('Created index', { store: storeName, prop: propName });
+                    this.runtime.logger.debug('Created index', { store: storeName, prop: propName });
                 }
                 catch (error) {
                     // Internal IndexedDB index setup — a miss only affects local query
                     // speed and isn't consumer-actionable → debug.
-                    getContext().logger.debug('Failed to create index', { store: storeName, prop: propName, error });
+                    this.runtime.logger.debug('Failed to create index', { store: storeName, prop: propName, error });
                 }
             }
-            // For partial load strategy models, we'll create additional partial index database later
-            if (metadata?.loadStrategy === LoadStrategy.partial) {
-                getContext().logger.debug('Model will have additional partial index database', { modelName });
-            }
         }
         // Create special tables
         this.createSpecialTables(db);
@@ -127,12 +121,12 @@ export class StoreManager {
         if (!db.objectStoreNames.contains('sync_action_table')) {
             const syncActionStore = db.createObjectStore('sync_action_table', { keyPath: 'id' });
             syncActionStore.createIndex('syncId', 'id');
-            getContext().logger.debug('Created sync_action_table');
+            this.runtime.logger.debug('Created sync_action_table');
         }
         // Create __meta table for model persistence state and database metadata
         if (!db.objectStoreNames.contains('__meta')) {
             db.createObjectStore('__meta');
-            getContext().logger.debug('Created __meta table');
+            this.runtime.logger.debug('Created __meta table');
         }
         // Create __transactions table for unsent transactions
         if (!db.objectStoreNames.contains('__transactions')) {
@@ -143,7 +137,7 @@ export class StoreManager {
             // Create indexes for transaction queries
             transactionStore.createIndex('timestamp', 'timestamp');
             transactionStore.createIndex('status', 'status');
-            getContext().logger.debug('Created __transactions table');
+            this.runtime.logger.debug('Created __transactions table');
         }
     }
     /**
@@ -183,7 +177,7 @@ export class StoreManager {
             }
         }
         const allReady = notReadyStores.length === 0;
-        getContext().logger.debug('Store readiness', {
+        this.runtime.logger.debug('Store readiness', {
             ready: readyStores.length,
             total: this.stores.size,
             notReady: notReadyStores,
@@ -223,23 +217,6 @@ export class StoreManager {
         }
         return false;
     }
-    /**
-     * Get store type distribution for debugging
-     */
-    getStoreTypeDistribution() {
-        let full = 0;
-        let partial = 0;
-        for (const [modelName] of Array.from(this.stores)) {
-            const metadata = this.modelRegistry.getMetadata(modelName);
-            if (metadata?.loadStrategy === LoadStrategy.partial) {
-                partial++;
-            }
-            else {
-                full++;
-            }
-        }
-        return { full, partial };
-    }
     /**
      * Get stores by load strategy
      */
@@ -253,38 +230,14 @@ export class StoreManager {
         }
         return stores;
     }
-    /**
-     * Get models to load for bootstrapping
-     */
-    getModelsToLoad() {
-        const instant = [];
-        const lazy = [];
-        const partial = [];
-        for (const [modelName] of Array.from(this.stores)) {
-            const metadata = this.modelRegistry.getMetadata(modelName);
-            switch (metadata?.loadStrategy) {
-                case LoadStrategy.instant:
-                    instant.push(modelName);
-                    break;
-                case LoadStrategy.lazy:
-                    lazy.push(modelName);
-                    break;
-                case LoadStrategy.partial:
-                    partial.push(modelName);
-                    break;
-                // Skip explicitlyRequested and local
-            }
-        }
-        return { instant, lazy, partial };
-    }
     /**
      * Perform maintenance on all stores
      */
     async performMaintenance() {
-        getContext().logger.info('Performing maintenance on all stores');
+        this.runtime.logger.info('Performing maintenance on all stores');
         const promises = Array.from(this.stores.values()).map((store) => store.performMaintenance());
         await Promise.all(promises);
-        getContext().logger.info('Store maintenance completed');
+        this.runtime.logger.info('Store maintenance completed');
     }
     /**
      * Clear all stores
@@ -292,17 +245,17 @@ export class StoreManager {
     async clearAllStores() {
         // Lifecycle chatter (logout / identity switch / reset), not a warning.
         // Logged at `debug` so it stays silent under the default `warn` threshold.
-        getContext().logger.debug('Clearing all stores');
+        this.runtime.logger.debug('Clearing all stores');
         const promises = Array.from(this.stores.values()).map((store) => store.clear());
         await Promise.all(promises);
-        getContext().logger.info('All stores cleared');
+        this.runtime.logger.info('All stores cleared');
     }
     /**
      * Mark all stores as closing to prevent new operations
      * Called before database connection is closed
      */
     markAllStoresAsClosing() {
-        getContext().logger.debug('Marking all stores as closing');
+        this.runtime.logger.debug('Marking all stores as closing');
         for (const store of this.stores.values()) {
             store.markAsClosing();
         }
@@ -312,7 +265,7 @@ export class StoreManager {
         // If closing-state coordination is ever needed for sync actions, add it
         // explicitly to SyncActionStore rather than casting to reach a method that
         // may not exist.
-        getContext().logger.debug('All stores marked as closing');
+        this.runtime.logger.debug('All stores marked as closing');
     }
     /**
      * Get comprehensive statistics
@@ -339,7 +292,6 @@ export class StoreManager {
         }
         return {
             totalStores: this.stores.size,
-            storeTypes: this.getStoreTypeDistribution(),
             readiness: {
                 ready: readyCount,
                 notReady: this.stores.size - readyCount,
@@ -349,4 +301,4 @@ export class StoreManager {
         };
     }
 }
-import { getContext } from '../context.js';
+import { globalRuntime } from '../context.js';

package/dist/stores/SyncActionStore.d.ts

@@ -2,7 +2,8 @@
  * A local, IndexedDB-backed store for the sync actions (change deltas) the
  * server sends. See {@link SyncActionStore}.
  */
-import type { SyncAction } from '../types/index.js';
+import type { RuntimeContext } from '../RuntimeContext.js';
+import { type SyncAction } from './syncAction.js';
 /**
  * Stores the sync actions (the change deltas) the server sends, keyed by
  * their sync id, and tracks which ones have been applied. It keeps a
@@ -11,11 +12,12 @@ import type { SyncAction } from '../types/index.js';
  * replayed while resolving a conflict.
  */
 export declare class SyncActionStore {
+    private readonly runtime;
     private db;
     private storeName;
     private lastAppliedSyncId;
     private pendingActions;
-    constructor(db: IDBDatabase);
+    constructor(db: IDBDatabase, runtime?: RuntimeContext);
     /**
      * Initialize store (create if needed)
      */

package/dist/stores/SyncActionStore.js

@@ -3,8 +3,8 @@
  * server sends. See {@link SyncActionStore}.
  */
 // Uses native IndexedDB for maximum performance
-import { z } from 'zod';
-import { getContext } from '../context.js';
+import { globalRuntime } from '../context.js';
+import { syncActionSchema } from './syncAction.js';
 /**
  * The validation boundary for rows read back from the store. A row may have
  * been written by an earlier session, so this build cannot assume its shape.
@@ -13,19 +13,11 @@ import { getContext } from '../context.js';
  * {@link SyncAction}. A row that fails to parse is dropped and logged rather
  * than replayed as a malformed delta.
  */
-const storedSyncActionSchema = z.object({
-    id: z.number(),
-    modelName: z.string(),
-    modelId: z.string(),
-    action: z.enum(['I', 'U', 'A', 'D', 'C', 'G', 'S', 'V']),
-    data: z.unknown(),
-    __class: z.literal('SyncAction').default('SyncAction'),
-});
 /** Parse one stored row into a SyncAction, or `null` (dropped + logged). */
-function toSyncAction(row) {
-    const parsed = storedSyncActionSchema.safeParse(row);
+function toSyncAction(row, runtime) {
+    const parsed = syncActionSchema.safeParse(row);
     if (!parsed.success) {
-        getContext().logger.debug('[SyncActionStore] Dropping malformed stored sync action', {
+        runtime.logger.debug('[SyncActionStore] Dropping malformed stored sync action', {
             issues: parsed.error.issues.map((i) => i.path.join('.')).join(', '),
         });
         return null;
@@ -40,11 +32,13 @@ function toSyncAction(row) {
  * replayed while resolving a conflict.
  */
 export class SyncActionStore {
+    runtime;
     db;
     storeName = 'sync_action_table';
     lastAppliedSyncId = 0;
     pendingActions = new Map();
-    constructor(db) {
+    constructor(db, runtime = globalRuntime) {
+        this.runtime = runtime;
         this.db = db;
     }
     /**
@@ -129,7 +123,7 @@ export class SyncActionStore {
                     resolve(undefined);
                     return;
                 }
-                resolve(toSyncAction(data) ?? undefined);
+                resolve(toSyncAction(data, this.runtime) ?? undefined);
             };
             request.onerror = () => { reject(request.error); };
         });
@@ -147,7 +141,7 @@ export class SyncActionStore {
             request.onsuccess = () => {
                 const allData = request.result;
                 const actions = allData
-                    .map(toSyncAction)
+                    .map((row) => toSyncAction(row, this.runtime))
                     .filter((action) => action !== null);
                 resolve(actions);
             };
@@ -496,7 +490,7 @@ export class SyncActionStore {
                     try {
                         await this.updateLastSyncId(this.lastAppliedSyncId);
                         const result = actionsToRewind
-                            .map(toSyncAction)
+                            .map((row) => toSyncAction(row, this.runtime))
                             .filter((action) => action !== null);
                         resolve(result);
                     }

package/dist/stores/syncAction.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The persisted local action record consumed by `SyncActionStore`. It is a
+ * client materialization artifact, not a transaction-layer wire shape: the
+ * authoritative broadcast vocabulary is the settlement core's delta wire
+ * schema, while this one adds the local `__class` discriminator IndexedDB uses.
+ */
+import { z } from 'zod';
+export declare const syncActionSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    modelName: z.ZodString;
+    modelId: z.ZodString;
+    action: z.ZodEnum<{
+        I: "I";
+        U: "U";
+        D: "D";
+        A: "A";
+        V: "V";
+        C: "C";
+        G: "G";
+        S: "S";
+    }>;
+    data: z.ZodUnknown;
+    __class: z.ZodDefault<z.ZodLiteral<"SyncAction">>;
+}, z.core.$strip>;
+export type SyncAction = z.infer<typeof syncActionSchema>;
+export type SyncActionType = SyncAction['action'];

package/dist/stores/syncAction.js

@@ -0,0 +1,16 @@
+/**
+ * The persisted local action record consumed by `SyncActionStore`. It is a
+ * client materialization artifact, not a transaction-layer wire shape: the
+ * authoritative broadcast vocabulary is the settlement core's delta wire
+ * schema, while this one adds the local `__class` discriminator IndexedDB uses.
+ */
+import { z } from 'zod';
+import { syncDeltaActionSchema } from '../transaction/wire/delta.js';
+export const syncActionSchema = z.object({
+    id: z.number(),
+    modelName: z.string(),
+    modelId: z.string(),
+    action: syncDeltaActionSchema,
+    data: z.unknown(),
+    __class: z.literal('SyncAction').default('SyncAction'),
+});

package/dist/surface.d.ts

@@ -19,9 +19,9 @@
  * tuple, so it is the one list of model-verb names a generated summary can
  * describe.
  */
-export declare const PUBLIC_MODEL_VERBS: readonly ["retrieve", "list", "get", "getAll", "getCount", "create", "update", "delete", "claim", "track", "join", "onChange"];
+export declare const PUBLIC_MODEL_VERBS: readonly ["retrieve", "list", "local", "create", "update", "delete", "claim", "track", "join", "onChange"];
 /**
- * The option keys accepted by `list`, `getAll`, and `onChange`, matching the
+ * The option keys accepted by `local.list` and `onChange`, matching the
  * keys of {@link LocalReadOptions}. Note that the lifecycle filter is named
  * `state`, not `scope`.
  */
@@ -30,7 +30,7 @@ export declare const PUBLIC_LIST_OPTION_KEYS: readonly ["where", "filter", "orde
  * The keys of the client constructor options, {@link AbloOptions}. Only
  * `schema` is required; every other key is optional.
  */
-export declare const PUBLIC_ABLO_OPTION_KEYS: readonly ["schema", "apiKey", "authEndpoint", "persistence", "durableWrites", "commitOutbox", "commitOutboxScope", "transport", "debug", "logLevel", "authToken", "baseURL", "fetch", "defaultHeaders", "defaultQuery", "dangerouslyAllowBrowser"];
+export declare const PUBLIC_ABLO_OPTION_KEYS: readonly ["schema", "apiKey", "authEndpoint", "persistence", "durableWrites", "commitOutbox", "commitOutboxScope", "transport", "debug", "logLevel", "logger", "authToken", "baseURL", "fetch", "defaultHeaders", "defaultQuery", "dangerouslyAllowBrowser", "collaborationEvents", "plugins", "wait"];
 export type ModelVerb = (typeof PUBLIC_MODEL_VERBS)[number];
 export type ListOptionKey = (typeof PUBLIC_LIST_OPTION_KEYS)[number];
 export type AbloOptionKey = (typeof PUBLIC_ABLO_OPTION_KEYS)[number];

package/dist/surface.js

@@ -23,9 +23,7 @@
 export const PUBLIC_MODEL_VERBS = [
     'retrieve',
     'list',
-    'get',
-    'getAll',
-    'getCount',
+    'local',
     'create',
     'update',
     'delete',
@@ -36,7 +34,7 @@ export const PUBLIC_MODEL_VERBS = [
 ];
 // ── the read/list query option surface ─────────────────────────────────────
 /**
- * The option keys accepted by `list`, `getAll`, and `onChange`, matching the
+ * The option keys accepted by `local.list` and `onChange`, matching the
  * keys of {@link LocalReadOptions}. Note that the lifecycle filter is named
  * `state`, not `scope`.
  */
@@ -64,10 +62,14 @@ export const PUBLIC_ABLO_OPTION_KEYS = [
     'transport',
     'debug',
     'logLevel',
+    'logger',
     'authToken',
     'baseURL',
     'fetch',
     'defaultHeaders',
     'defaultQuery',
     'dangerouslyAllowBrowser',
+    'collaborationEvents',
+    'plugins',
+    'wait',
 ];