@abloatai/ablo 0.35.0 → 0.36.0

package/dist/react/AbloProvider.js

@@ -302,7 +302,9 @@ export function useJoin(opts) {
         let cancelled = false;
         const claimId = createParticipantClaimId();
         ws.sendClaim(claimId, scopedSyncGroups, {
-            ttlSeconds: parseParticipantTtlSeconds(opts.ttlSeconds),
+            // Reading the retired spelling IS the compatibility path; it goes at 0.37.0.
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
+            ttlSeconds: parseParticipantTtlSeconds(opts.ttl ?? opts.ttlSeconds),
         })
             .then(() => {
             if (!cancelled)
@@ -320,7 +322,8 @@ export function useJoin(opts) {
             ws.sendRelease(claimId);
             void store.unpinScope?.(scope);
         };
-    }, [engine, paused, scopeKey, syncStatus.name, opts.ttlSeconds, opts.claim]);
+        // eslint-disable-next-line @typescript-eslint/no-deprecated -- same compatibility read as above.
+    }, [engine, paused, scopeKey, syncStatus.name, opts.ttl, opts.ttlSeconds, opts.claim]);
     // Bridge the engine's presence + claims streams into React state.
     // Plain useState + useEffect is sufficient — mid-frame tearing on a
     // peer list is harmless (users won't notice one frame of stale

package/dist/react/context.d.ts

@@ -1,7 +1,7 @@
 import { type ReactNode } from 'react';
 import type { Schema } from '../transaction/schema/schema.js';
-import type { SyncStoreContract } from '../core/storeContract.js';
-export type { SyncStoreContract, LocalMutation } from '../core/storeContract.js';
+import type { SyncStoreContract } from '../storeContract.js';
+export type { SyncStoreContract, LocalMutation } from '../storeContract.js';
 export interface SyncReactContext {
     store: SyncStoreContract;
     /** The organization id used as the default scope for reads and writes. */

package/dist/react/createAbloReact.d.ts

@@ -0,0 +1,56 @@
+/**
+ * The typed react binding — the schema generic is captured ONCE, at a factory
+ * call in app code, and every hook the factory returns is born typed. This is
+ * the shape the reference libraries converged on independently (tRPC's
+ * `createTRPCReact`, XState's `createActorContext`, react-redux's
+ * `withTypes`): no module augmentation, no generic parameters at call sites,
+ * and — once the legacy generic erasure retires — no casts anywhere on the
+ * path from context to component.
+ *
+ * The app's one binding file, by convention:
+ *
+ * ```ts
+ * // lib/ablo.ts
+ * import { createAbloReact } from '@abloatai/ablo/react';
+ * import { schema } from './schema';
+ *
+ * export const { AbloProvider, useAblo } = createAbloReact(schema);
+ * ```
+ *
+ * Components then import `useAblo` from `lib/ablo` and never spell a type
+ * argument; `useAblo()` is `Ablo<S> | null`, and a selector's `ablo`
+ * parameter is the reactive-read view of the same `S`.
+ */
+import { type ReactElement } from 'react';
+import { type AbloProviderProps } from './AbloProvider.js';
+import { type AbloSelector, type ModelClientSelector, type UseAbloHydratedModelResult, type UseAbloModelOptions, type UseAbloModelResult } from './useAblo.js';
+import type { Ablo } from '../client/Ablo.js';
+import type { ModelOperations } from '../client/createModelProxy.js';
+import type { Schema, SchemaRecord } from '../transaction/schema/schema.js';
+/** What a binding returns: the provider and the hook, with `S` fixed. */
+export interface AbloReactBinding<S extends SchemaRecord> {
+    /** `AbloProvider` with its `client` prop typed `Ablo<S>` — same component,
+     *  no per-app generics. */
+    AbloProvider: (props: AbloProviderProps<S>) => ReactElement;
+    /** `useAblo` with the schema bound — the same overloads as the global
+     *  hook, minus the type arguments. */
+    useAblo: {
+        (): Ablo<S> | null;
+        <T>(select: AbloSelector<S, T>): T | undefined;
+        <T, C>(modelClient: ModelOperations<T, C>, id: string, options: UseAbloModelOptions<T> & {
+            readonly initial: T;
+        }): UseAbloHydratedModelResult<T>;
+        <T, C>(select: ModelClientSelector<S, T, C>, id: string, options: UseAbloModelOptions<T> & {
+            readonly initial: T;
+        }): UseAbloHydratedModelResult<T>;
+        <T, C>(modelClient: ModelOperations<T, C>, id: string, options?: UseAbloModelOptions<T>): UseAbloModelResult<T>;
+        <T, C>(select: ModelClientSelector<S, T, C>, id: string, options?: UseAbloModelOptions<T>): UseAbloModelResult<T>;
+    };
+}
+/**
+ * Bind the react surface to one schema. The schema value is taken for
+ * inference — write `createAbloReact(schema)`, never a hand-spelled type
+ * argument — and it is the seam where the binding's own typed context arrives
+ * when the legacy erasure retires (docs/plans/typed-react-binding.md, step 3).
+ */
+export declare function createAbloReact<S extends SchemaRecord>(schema: Schema<S>): AbloReactBinding<S>;

package/dist/react/createAbloReact.js

@@ -0,0 +1,51 @@
+'use client';
+/**
+ * The typed react binding — the schema generic is captured ONCE, at a factory
+ * call in app code, and every hook the factory returns is born typed. This is
+ * the shape the reference libraries converged on independently (tRPC's
+ * `createTRPCReact`, XState's `createActorContext`, react-redux's
+ * `withTypes`): no module augmentation, no generic parameters at call sites,
+ * and — once the legacy generic erasure retires — no casts anywhere on the
+ * path from context to component.
+ *
+ * The app's one binding file, by convention:
+ *
+ * ```ts
+ * // lib/ablo.ts
+ * import { createAbloReact } from '@abloatai/ablo/react';
+ * import { schema } from './schema';
+ *
+ * export const { AbloProvider, useAblo } = createAbloReact(schema);
+ * ```
+ *
+ * Components then import `useAblo` from `lib/ablo` and never spell a type
+ * argument; `useAblo()` is `Ablo<S> | null`, and a selector's `ablo`
+ * parameter is the reactive-read view of the same `S`.
+ */
+import { createContext, createElement, useContext } from 'react';
+import { AbloProvider } from './AbloProvider.js';
+import { useAbloImpl, } from './useAblo.js';
+/**
+ * Bind the react surface to one schema. The schema value is taken for
+ * inference — write `createAbloReact(schema)`, never a hand-spelled type
+ * argument — and it is the seam where the binding's own typed context arrives
+ * when the legacy erasure retires (docs/plans/typed-react-binding.md, step 3).
+ */
+export function createAbloReact(schema) {
+    void schema;
+    // The binding's own context — created here, AFTER the schema generic is
+    // known, so it is typed `Ablo<S>` from birth (the XState
+    // `createActorContext` shape). A hook that reads it never rebinds and
+    // never casts; a binding hook mounted under a legacy provider (no bound
+    // provider in the tree) reads `null` here and falls through to the shared
+    // implementation's internal-context fallback.
+    const BoundClientContext = createContext(null);
+    function BoundAbloProvider(props) {
+        return createElement(BoundClientContext.Provider, { value: props.client }, createElement((AbloProvider), props));
+    }
+    function useBoundAblo(modelOrSelect, id, options) {
+        const bound = useContext(BoundClientContext);
+        return useAbloImpl(bound, modelOrSelect, id, options);
+    }
+    return { AbloProvider: BoundAbloProvider, useAblo: useBoundAblo };
+}

package/dist/react/index.d.ts

@@ -52,6 +52,7 @@ export { useSyncStatus, type SyncStatusSnapshot, } from './useSyncStatus.js';
 export { useErrorListener } from './useErrorListener.js';
 export { useMutationFailureListener, type MutationFailurePayload, } from './useMutationFailureListener.js';
 export { useCurrentUserId } from './useCurrentUserId.js';
+export { createAbloReact, type AbloReactBinding } from './createAbloReact.js';
 export { useReactive } from './useReactive.js';
 export type { MutateActions } from '../mutators/mutateActions.js';
 export type { ReaderActions, ReaderFindOptions } from '../mutators/readerActions.js';

package/dist/react/index.js

@@ -52,6 +52,9 @@ export { useSyncStatus, } from './useSyncStatus.js';
 export { useErrorListener } from './useErrorListener.js';
 export { useMutationFailureListener, } from './useMutationFailureListener.js';
 export { useCurrentUserId } from './useCurrentUserId.js';
+// The typed binding — capture the schema generic once, in the app's one
+// binding file, and import born-typed hooks everywhere (the tRPC shape).
+export { createAbloReact } from './createAbloReact.js';
 // ── Primitive for building custom reactive hooks ──────────────────
 //
 // Consumers building bespoke hooks on top of the SDK should call

package/dist/react/useAblo.d.ts

@@ -11,8 +11,8 @@ import type { ResolveSchema } from '../transaction/types/global.js';
 type DefaultModels = ResolveSchema extends {
     models: infer M;
 } ? M extends SchemaRecord ? M : SchemaRecord : SchemaRecord;
-type ModelClientSelector<R extends SchemaRecord, T, C> = (ablo: AbloReads<R>) => ModelOperations<T, C>;
-type AbloSelector<R extends SchemaRecord, T> = (ablo: AbloReads<R>) => T;
+export type ModelClientSelector<R extends SchemaRecord, T, C> = (ablo: AbloReads<R>) => ModelOperations<T, C>;
+export type AbloSelector<R extends SchemaRecord, T> = (ablo: AbloReads<R>) => T;
 export interface UseAbloModelOptions<T> {
     /**
      * An initial row, usually from a server component or a route loader. The hook
@@ -42,6 +42,13 @@ export type UseAbloHydratedModelResult<T> = Omit<UseAbloModelResult<T>, 'data'>
  * Schema: typeof schema } }`); the default type then resolves through your
  * schema's models, so call sites stay clean:
  *
+ * **Prefer the binding.** `createAbloReact(schema)` captures the schema once
+ * in your app's binding file and returns a `useAblo` that needs none of the
+ * typing arrangements below — no type argument, no `Register` declaration
+ * (see `react.md`). Passing an explicit schema type argument to THIS hook is
+ * deprecated in favor of that binding; it keeps working for shared packages
+ * that cannot bind a concrete schema.
+ *
  * ```ts
  * // With the Register augmentation (recommended):
  * const ablo = useAblo();

package/dist/react/useAblo.js

@@ -15,13 +15,13 @@ function rebindEngine(engine) {
     return engine;
 }
 /**
- * The same rebind viewed through the reactive-read surface — the identical
- * runtime object, with model reads typed as snapshot rows, because everything
- * a selector returns is converted through `snapshotValue` before the hook
- * hands it back.
+ * The reactive-read view of a client — the identical runtime object, with
+ * model reads typed as snapshot rows, because everything a selector returns
+ * is converted through `snapshotValue` before the hook hands it back. Same
+ * generic in and out, so this compiles with no schema rebinding.
  */
 function reactiveReads(engine) {
-    return rebindEngine(engine);
+    return engine;
 }
 function readModelResult(engine, modelClient, id, initial) {
     if (!modelClient || id === undefined) {
@@ -55,8 +55,26 @@ function snapshotValue(value) {
     return value;
 }
 export function useAblo(modelOrSelect, id, options) {
+    return useAbloImpl(null, modelOrSelect, id, options);
+}
+/**
+ * @internal The one implementation behind `useAblo` and the bound hooks a
+ * `createAbloReact` binding returns — written once so the reactive read path
+ * cannot fork between the global hook and a factory's.
+ *
+ * `boundClient` is a binding's own context value — typed `Ablo<S>` at the
+ * factory, so that path never rebinds and never casts. `null` means "no
+ * binding provider in this tree": the global hook always passes it, and a
+ * binding hook mounted under a legacy provider falls through to the erased
+ * internal context, which is what keeps both mounts working while the last
+ * legacy mount migrates.
+ */
+export function useAbloImpl(boundClient, modelOrSelect, id, options) {
     const ctx = useContext(AbloInternalContext);
-    const engine = ctx?.engine ?? null;
+    // The bound client wins — it is already `Ablo<R>`, no rebinding. The
+    // fallback is the ONE remaining schema rebind in the SDK; it retires with
+    // the last legacy provider mount (docs/plans/typed-react-binding.md).
+    const engine = boundClient ?? (ctx?.engine ? rebindEngine(ctx.engine) : null);
     const initial = options?.initial;
     const isSelectorOnly = typeof modelOrSelect === 'function' && id === undefined;
     const modelClient = typeof modelOrSelect === 'function' && id !== undefined
@@ -98,5 +116,5 @@ export function useAblo(modelOrSelect, id, options) {
         return selected;
     if (modelOrSelect)
         return modelResult;
-    return engine === null ? null : rebindEngine(engine);
+    return engine;
 }

package/dist/schema/coordination.js

@@ -65,7 +65,11 @@ class CoordinationAxis {
     }
     /** Apply one more rule, later winning on a repeated kind. */
     and(rule) {
-        return new CoordinationAxis({ ...this, ...rule });
+        // Assigned rather than spread, and for the reason the merge form below
+        // assigns too: what carries forward is the dispositions, which are own
+        // enumerable properties. The chaining methods live on the prototype and the
+        // constructor puts them back, so a chain accumulates nothing but data.
+        return new CoordinationAxis(Object.assign({}, this, rule));
     }
     humansOverwrite() {
         return this.and(humansOverwrite());

package/dist/schema/index.d.ts

@@ -22,6 +22,7 @@
  */
 export { z } from 'zod';
 export { field, indexed, getFieldMeta, type FieldBuilder, type FieldMeta } from '../transaction/schema/field.js';
+export { isFieldRef, type FieldRef } from '../transaction/schema/fieldRef.js';
 export { relation, type RelationDef, type RelationType } from '../transaction/schema/relation.js';
 export { tenancySchema, scopedViaRefSchema, policyInputSchema, resolvePolicy, resolveTenancy, tenancyColumn, DEFAULT_ORG_COLUMN, type Tenancy, type ScopedViaRef, type PolicyInput, } from '../transaction/schema/tenancy.js';
 export { residencySchema, DEFAULT_RESIDENCY, type ModelResidency, } from '../transaction/schema/residency.js';

package/dist/schema/index.js

@@ -24,6 +24,10 @@
 export { z } from 'zod';
 // Field helpers (optional convenience wrappers around Zod)
 export { field, indexed, getFieldMeta } from '../transaction/schema/field.js';
+// A field as a value rather than a quoted name — `schema.fields.tasks.status`.
+// Surfaces that name a field (claims today) take one of these so a name that
+// does not exist stops compiling.
+export { isFieldRef } from '../transaction/schema/fieldRef.js';
 // Relation builders
 export { relation } from '../transaction/schema/relation.js';
 // Tenancy — the single source of truth for how a model's rows are tenant-scoped.

package/dist/schema/select.js

@@ -21,6 +21,7 @@
  * scope-inheritance throws instead, because silently losing it would mis-route
  * a record's fan-out — the selected set must be closed under `parent` edges.
  */
+import { buildFieldRefs } from '../transaction/schema/schema.js';
 import { AbloValidationError } from '../transaction/errors.js';
 import { schemaHash } from './serialize.js';
 export function selectModels(schema, keys) {
@@ -50,6 +51,8 @@ export function selectModels(schema, keys) {
     }
     return {
         models: models,
+        // References for exactly the models this projection kept.
+        fields: buildFieldRefs(models),
         validators: validators,
         identityRoles: schema.identityRoles,
         sessionSettings: schema.sessionSettings,

package/dist/schema/serialize.js

@@ -28,6 +28,7 @@
  */
 import { z } from 'zod';
 import { AbloValidationError } from '../transaction/errors.js';
+import { buildFieldRefs } from '../transaction/schema/schema.js';
 import { baseFieldsSchema, } from '../transaction/schema/schema.js';
 /** Current schema-JSON envelope version. Bump this on a breaking change to the
  * JSON shape itself — not to a user's schema. */
@@ -205,6 +206,8 @@ export function fromSchemaJSON(json) {
     }
     return {
         models: models,
+        // A schema rebuilt from JSON carries references too — the shapes are here.
+        fields: buildFieldRefs(models),
         validators: validators,
         identityRoles: json.identityRoles,
         sessionSettings: json.sessionSettings ?? {},

package/dist/source/adapter.d.ts

@@ -8,16 +8,18 @@
  * write your own.
  *
  * An endpoint adapter reads and writes your database, and it owns the transactional
- * outbox and idempotency bookkeeping as well, so you never write those by hand:
+ * outbox and idempotency bookkeeping as well, so you never write those by hand.
+ * Hand it to the handler in one slot:
  *
  *   export const POST = dataSource({
  *     schema, apiKey: process.env.ABLO_API_KEY!,
- *     ...sourceHandlersFromAdapter(prismaDataSource(prisma, schema), schema),
+ *     adapter: prismaDataSource(prisma, schema),
  *   });
  *
- * `sourceHandlersFromAdapter` is the bridge: it turns a single adapter into the
- * handler's `commit`, `events`, and per-model `load` and `list` operations, so no
- * code above the adapter needs to know which mapper you chose.
+ * That is the path to teach. {@link sourceHandlersFromAdapter} is the lower-level
+ * bridge behind it — it expands one adapter into the handler's `commit`, `events`,
+ * and per-model `load` and `list` operations, and is worth reaching for only when
+ * you want to override one of those while the adapter serves the rest.
  */
 import type { SourceListQuery, SourceRequestContext } from './types.js';
 import type { AdapterCapabilities, ChangeSet, EventsPage, Migration } from './contract.js';

package/dist/source/adapter.js

@@ -8,15 +8,17 @@
  * write your own.
  *
  * An endpoint adapter reads and writes your database, and it owns the transactional
- * outbox and idempotency bookkeeping as well, so you never write those by hand:
+ * outbox and idempotency bookkeeping as well, so you never write those by hand.
+ * Hand it to the handler in one slot:
  *
  *   export const POST = dataSource({
  *     schema, apiKey: process.env.ABLO_API_KEY!,
- *     ...sourceHandlersFromAdapter(prismaDataSource(prisma, schema), schema),
+ *     adapter: prismaDataSource(prisma, schema),
  *   });
  *
- * `sourceHandlersFromAdapter` is the bridge: it turns a single adapter into the
- * handler's `commit`, `events`, and per-model `load` and `list` operations, so no
- * code above the adapter needs to know which mapper you chose.
+ * That is the path to teach. {@link sourceHandlersFromAdapter} is the lower-level
+ * bridge behind it — it expands one adapter into the handler's `commit`, `events`,
+ * and per-model `load` and `list` operations, and is worth reaching for only when
+ * you want to override one of those while the adapter serves the rest.
  */
 export {};

package/dist/source/index.d.ts

@@ -20,4 +20,4 @@ export { prismaDataSource, type PrismaLike, type PrismaDataSourceOptions } from
 export { adapterTableMigrations, endpointOutboxMigrations, idempotencyLedgerMigrations, } from './migrations.js';
 export { createKyselyMutationAdapter, createKyselyMutationCore, kyselyDataSource, kyselyDirectMutation, kyselyOperationRowId, type KyselyCompiledQuery, type KyselyDeleteBuilder, type KyselyInsertBuilder, type KyselyInsertValuesBuilder, type KyselyLike, type KyselyMutationCore, type KyselyReturningExecutable, type KyselySelectBuilder, type KyselyTransactionBuilder, type KyselyUpdateBuilder, type KyselyUpdateSetBuilder, } from './adapters/kysely.js';
 export { sourceOperationsIntentHash, sourceChangeIntentHash, assertSourceIdempotencyIntent, assertSourceIdempotencyRetention, sourceEchoTransactionIdSchema, encodeSourceEchoTransactionId, decodeSourceEchoTransactionId, type SourceEchoTransactionId, } from './idempotency.js';
-export { ABLO_FOOTPRINT, ABLO_PUBLICATION, ABLO_REPLICATION_SLOT, ABLO_REPLICATION_ROLE, ABLO_WRITE_ROLE, ABLO_IDEMPOTENCY_TABLE, ABLO_OUTBOX_TABLE, REPLICATION_SLOT_NAME, isValidReplicationSlotName, footprintNamesFor, type FootprintArtifact, type FootprintKind, type FootprintNames, type FootprintPlane, } from './footprint.js';
+export { ABLO_FOOTPRINT, ABLO_PUBLICATION, ABLO_REPLICATION_SLOT, ABLO_REPLICATION_ROLE, ABLO_WRITE_ROLE, ABLO_IDEMPOTENCY_TABLE, ABLO_OUTBOX_TABLE, REPLICATION_SLOT_NAME, isValidReplicationSlotName, footprintNamesFor, type FootprintArtifact, type FootprintKind, type FootprintNames, type FootprintPlane, } from '../transaction/footprint.js';

package/dist/source/index.js

@@ -27,4 +27,4 @@ export { createKyselyMutationAdapter, createKyselyMutationCore, kyselyDataSource
 export { sourceOperationsIntentHash, sourceChangeIntentHash, assertSourceIdempotencyIntent, assertSourceIdempotencyRetention, sourceEchoTransactionIdSchema, encodeSourceEchoTransactionId, decodeSourceEchoTransactionId, } from './idempotency.js';
 // What Ablo leaves inside a customer's database, declared once — read by the
 // setup SQL, the replication runtime, and the audit that reports it back.
-export { ABLO_FOOTPRINT, ABLO_PUBLICATION, ABLO_REPLICATION_SLOT, ABLO_REPLICATION_ROLE, ABLO_WRITE_ROLE, ABLO_IDEMPOTENCY_TABLE, ABLO_OUTBOX_TABLE, REPLICATION_SLOT_NAME, isValidReplicationSlotName, footprintNamesFor, } from './footprint.js';
+export { ABLO_FOOTPRINT, ABLO_PUBLICATION, ABLO_REPLICATION_SLOT, ABLO_REPLICATION_ROLE, ABLO_WRITE_ROLE, ABLO_IDEMPOTENCY_TABLE, ABLO_OUTBOX_TABLE, REPLICATION_SLOT_NAME, isValidReplicationSlotName, footprintNamesFor, } from '../transaction/footprint.js';

package/dist/{core/storeContract.d.ts → storeContract.d.ts}

@@ -9,11 +9,11 @@
  * This module is type-only: it has no runtime imports and contributes nothing to
  * the runtime bundle beyond the erased interface declarations.
  */
-import type { Model } from '../Model.js';
-import type { ModelScope } from '../transaction/types/index.js';
-import type { QueryView, QueryViewOptions } from './QueryView.js';
-import type { ViewRegistry } from './ViewRegistry.js';
-import type { ParticipantScope } from '../sync/participants.js';
+import type { Model } from './Model.js';
+import type { ModelScope } from './transaction/types/index.js';
+import type { QueryView, QueryViewOptions } from './views/QueryView.js';
+import type { ViewRegistry } from './views/ViewRegistry.js';
+import type { ParticipantScope } from './sync/participants.js';
 /**
  * A snapshot of the client's synchronization state, shaped for binding to UI.
  * {@link SyncStoreContract.syncStatus} exposes a reactive instance of this, and

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

@@ -5,6 +5,7 @@
  * then gets its own data database, named `ablo_<hash>`, that holds the synced
  * rows. {@link DatabaseManager} creates, versions, and deletes both tiers.
  */
+import type { RuntimeContext } from '../RuntimeContext.js';
 export interface DatabaseInfo {
     name: string;
     userId: string;
@@ -34,9 +35,10 @@ export interface WorkspaceMetadata {
  * - Provides database info and metadata management
  */
 export declare class DatabaseManager {
+    private readonly runtime;
     private metaDb;
     private readonly metaDbName;
-    constructor();
+    constructor(runtime?: RuntimeContext);
     /**
      * Initialize the meta database (ablo_databases)
      */

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

@@ -5,7 +5,7 @@
  * then gets its own data database, named `ablo_<hash>`, that holds the synced
  * rows. {@link DatabaseManager} creates, versions, and deletes both tiers.
  */
-import { getContext } from '../context.js';
+import { globalRuntime } from '../context.js';
 import { openIDBWithTimeout, deleteIDBWithTimeout, IDBOpenTimeoutError, } from './openIDBWithTimeout.js';
 import { AbloConnectionError } from '../transaction/errors.js';
 import { getActiveRegistry, hasActiveRegistry } from '../ModelRegistry.js';
@@ -19,10 +19,11 @@ import { getActiveRegistry, hasActiveRegistry } from '../ModelRegistry.js';
  * - Provides database info and metadata management
  */
 export class DatabaseManager {
+    runtime;
     metaDb = null;
     metaDbName = 'ablo_databases';
-    constructor() {
-        // Singleton-like behavior
+    constructor(runtime = globalRuntime) {
+        this.runtime = runtime;
     }
     /**
      * Initialize the meta database (ablo_databases)
@@ -53,8 +54,8 @@ export class DatabaseManager {
             // safe to delete and re-create. Try exactly once: delete, then re-open.
             if (!(error instanceof IDBOpenTimeoutError))
                 throw error;
-            getContext().logger.debug('[sync-engine] meta DB open timed out — attempting self-heal (delete + retry)', { db: this.metaDbName, reason: error.reason });
-            getContext().observability.captureBootstrapFailure(error, {
+            this.runtime.logger.debug('[sync-engine] meta DB open timed out — attempting self-heal (delete + retry)', { db: this.metaDbName, reason: error.reason });
+            this.runtime.observability.captureBootstrapFailure(error, {
                 type: 'meta-db-open-timeout',
             });
             const deleted = await deleteIDBWithTimeout(this.metaDbName);
@@ -66,7 +67,7 @@ export class DatabaseManager {
             }
             // Fresh store — this open creates `ablo_databases` from scratch.
             this.metaDb = await open();
-            getContext().logger.info('[sync-engine] meta DB self-heal succeeded');
+            this.runtime.logger.info('[sync-engine] meta DB self-heal succeeded');
         }
     }
     /**
@@ -92,7 +93,7 @@ export class DatabaseManager {
         const allUserDatabases = await this.getDatabasesForUser(userId);
         const allIndexedDBs = (await indexedDB.databases?.()) || [];
         const abloDatabases = allIndexedDBs.filter((db) => db.name?.startsWith('ablo_'));
-        getContext().observability.breadcrumb('Database info calculated', 'sync.database', 'info', {
+        this.runtime.observability.breadcrumb('Database info calculated', 'sync.database', 'info', {
             dbName,
             schemaVersion,
             existingDbCount: allUserDatabases.length,
@@ -192,13 +193,13 @@ export class DatabaseManager {
                     if (createStoresFn && tx) {
                         try {
                             void createStoresFn(db, tx).catch((err) => {
-                                getContext().observability.captureBootstrapFailure(err, {
+                                this.runtime.observability.captureBootstrapFailure(err, {
                                     type: 'store-creation',
                                 });
                             });
                         }
                         catch (err) {
-                            getContext().observability.captureBootstrapFailure(err, {
+                            this.runtime.observability.captureBootstrapFailure(err, {
                                 type: 'store-creation',
                             });
                         }
@@ -207,7 +208,7 @@ export class DatabaseManager {
             });
         }
         catch (error) {
-            getContext().observability.captureBootstrapFailure(error, {
+            this.runtime.observability.captureBootstrapFailure(error, {
                 type: 'database-open',
             });
             throw error;
@@ -329,11 +330,11 @@ export class DatabaseManager {
                 resolve();
             };
             deleteRequest.onerror = () => {
-                getContext().observability.breadcrumb(`Failed to delete workspace database: ${dbInfo.name}`, 'sync.database', 'error');
+                this.runtime.observability.breadcrumb(`Failed to delete workspace database: ${dbInfo.name}`, 'sync.database', 'error');
                 reject(deleteRequest.error);
             };
             deleteRequest.onblocked = () => {
-                getContext().observability.breadcrumb(`Database deletion blocked: ${dbInfo.name}`, 'sync.database', 'warning');
+                this.runtime.observability.breadcrumb(`Database deletion blocked: ${dbInfo.name}`, 'sync.database', 'warning');
                 // Could implement retry logic or user notification
             };
         });

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

@@ -7,8 +7,8 @@
  * when its data is loaded.
  */
 import { ModelRegistry } from '../ModelRegistry.js';
-import { ObjectStore } from '../stores/ObjectStore.js';
-import { SyncActionStore } from '../stores/SyncActionStore.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 '../transaction/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
      */
@@ -110,3 +111,4 @@ export declare class StoreManager {
         }[];
     }>;
 }
+import type { RuntimeContext } from '../RuntimeContext.js';