@abloatai/ablo 0.34.1 → 0.36.0

package/dist/source/adapters/kysely.d.ts

@@ -16,7 +16,7 @@
  * If the owner rolls back, the waiter acquires the reservation and performs the
  * mutation. This gives same-key concurrency one database arbiter and one effect.
  */
-import type { Schema, SchemaRecord } from '../../schema/schema.js';
+import type { Schema, SchemaRecord } from '../../transaction/schema/schema.js';
 import type { DataSourceAdapter, MutationAdapter } from '../adapter.js';
 import { type KyselyLike, type KyselyMutationCore } from './kyselyMutationCore.js';
 export { createKyselyMutationCore, kyselyOperationRowId, type KyselyCompiledQuery, type KyselyDeleteBuilder, type KyselyInsertBuilder, type KyselyInsertValuesBuilder, type KyselyLike, type KyselyMutationCore, type KyselyReturningExecutable, type KyselySelectBuilder, type KyselyTransactionBuilder, type KyselyUpdateBuilder, type KyselyUpdateSetBuilder, } from './kyselyMutationCore.js';

package/dist/source/adapters/kysely.js

@@ -16,7 +16,7 @@
  * If the owner rolls back, the waiter acquires the reservation and performs the
  * mutation. This gives same-key concurrency one database arbiter and one effect.
  */
-import { AbloValidationError } from '../../errors.js';
+import { AbloValidationError } from '../../transaction/errors.js';
 import { changeSetSchema, outboxEventSchema, sourceCommitEchoMarkerSchema, } from '../contract.js';
 import { assertSourceIdempotencyIntent, assertSourceIdempotencyRetention, sourceChangeIntentHash, SOURCE_IDEMPOTENCY_RETENTION, } from '../idempotency.js';
 import { adapterTableMigrations, idempotencyLedgerMigrations, } from '../migrations.js';

package/dist/source/adapters/kyselyMutationCore.d.ts

@@ -7,7 +7,7 @@
  * the same `applyOperation` implementation, so direct and endpoint DML cannot
  * drift into separate hand-written mappers.
  */
-import type { Schema, SchemaRecord } from '../../schema/schema.js';
+import type { Schema, SchemaRecord } from '../../transaction/schema/schema.js';
 import type { AdapterReadRequest, Row } from '../adapter.js';
 import type { Operation } from '../contract.js';
 /** The subset of a Kysely instance, or transaction handle, used by the core. */

package/dist/source/adapters/kyselyMutationCore.js

@@ -7,10 +7,10 @@
  * the same `applyOperation` implementation, so direct and endpoint DML cannot
  * drift into separate hand-written mappers.
  */
-import { AbloValidationError } from '../../errors.js';
+import { AbloValidationError } from '../../transaction/errors.js';
 import { toSchemaJSON } from '../../schema/serialize.js';
 import { camelToSnake, snakeToCamel } from '../../schema/ddl.js';
-import { tenancyColumn } from '../../schema/tenancy.js';
+import { tenancyColumn } from '../../transaction/schema/tenancy.js';
 function buildColumnMaps(schema) {
     const json = toSchemaJSON(schema);
     const out = new Map();

package/dist/source/adapters/memory.js

@@ -9,7 +9,7 @@
  * idempotency ledger keyed by scoped correlation, and an append-only outbox with a
  * monotonic cursor.
  */
-import { AbloValidationError } from '../../errors.js';
+import { AbloValidationError } from '../../transaction/errors.js';
 import { assertSourceIdempotencyIntent, sourceChangeIntentHash, } from '../idempotency.js';
 function rowId(op) {
     const id = op.id ?? op.input?.id;

package/dist/source/adapters/prisma.d.ts

@@ -14,7 +14,7 @@
  * call site.
  */
 import type { DataSourceAdapter, Row } from '../adapter.js';
-import type { SchemaRecord, Schema } from '../../schema/schema.js';
+import type { SchemaRecord, Schema } from '../../transaction/schema/schema.js';
 /** A Prisma model delegate — the subset of its methods the adapter calls. */
 export interface PrismaDelegate {
     findUnique(args: {
@@ -47,9 +47,14 @@ export interface PrismaRaw {
     $executeRawUnsafe(query: string, ...values: unknown[]): Promise<number>;
     $queryRawUnsafe<T = unknown>(query: string, ...values: unknown[]): Promise<T>;
 }
-/** A Prisma client, or its interactive-transaction client, as a structural shape that needs no `@prisma/client` import. */
+/**
+ * A Prisma client as a structural shape that needs no `@prisma/client` import.
+ * The interactive-transaction callback receives only {@link PrismaRaw}: Prisma's
+ * own tx client strips `$transaction` (no nesting), so requiring it there made
+ * a real `PrismaClient` unassignable to this shape.
+ */
 export interface PrismaLike extends PrismaRaw {
-    $transaction<T>(fn: (tx: PrismaLike & PrismaRaw) => Promise<T>): Promise<T>;
+    $transaction<T>(fn: (tx: PrismaRaw) => Promise<T>): Promise<T>;
 }
 export interface PrismaDataSourceOptions {
     /** Map a schema model name → its Prisma delegate name. Default: lower-first-letter. */

package/dist/source/adapters/prisma.js

@@ -13,7 +13,7 @@
  * be tested with a fake, while a real `PrismaClient` satisfies the shape at the
  * call site.
  */
-import { AbloValidationError } from '../../errors.js';
+import { AbloValidationError } from '../../transaction/errors.js';
 import { outboxEventSchema } from '../contract.js';
 import { adapterTableMigrations } from '../migrations.js';
 import { assertSourceIdempotencyIntent, assertSourceIdempotencyRetention, SOURCE_IDEMPOTENCY_RETENTION, sourceChangeIntentHash, } from '../idempotency.js';

package/dist/source/connector.js

@@ -24,7 +24,7 @@
  * the trust model does not.
  */
 import { SOURCE_CONNECTOR_PROTOCOL_VERSION, SOURCE_CONNECTOR_WS_PATH, sourceConnectorSubprotocols, encodeFrame, decodeFrame, ConnectorProtocolError, } from './connectorProtocol.js';
-import { ABLO_HOSTED_HTTP_BASE_URL } from '../client/hostedEndpoints.js';
+import { ABLO_HOSTED_HTTP_BASE_URL } from '../transaction/auth/hostedEndpoints.js';
 /**
  * The default Ablo base URL the connector dials, to which it appends
  * `SOURCE_CONNECTOR_WS_PATH`.

package/dist/source/connectorProtocol.d.ts

@@ -64,10 +64,7 @@ export declare const readyFrameSchema: z.ZodObject<{
     protocolVersion: z.ZodNumber;
     sourceId: z.ZodOptional<z.ZodString>;
     organizationId: z.ZodOptional<z.ZodString>;
-    environment: z.ZodOptional<z.ZodEnum<{
-        production: "production";
-        sandbox: "sandbox";
-    }>>;
+    environment: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type ReadyFrame = z.infer<typeof readyFrameSchema>;
 /**
@@ -120,10 +117,7 @@ export declare const connectorFrameSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
     protocolVersion: z.ZodNumber;
     sourceId: z.ZodOptional<z.ZodString>;
     organizationId: z.ZodOptional<z.ZodString>;
-    environment: z.ZodOptional<z.ZodEnum<{
-        production: "production";
-        sandbox: "sandbox";
-    }>>;
+    environment: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"request">;
     id: z.ZodString;

package/dist/source/connectorProtocol.js

@@ -20,7 +20,8 @@
  * sides infer every wire type from one schema so they cannot silently drift.
  */
 import { z } from 'zod';
-import { WS_BEARER_SUBPROTOCOL_PREFIX } from '../auth/credentialSource.js';
+import { environmentSchema } from '../transaction/environment.js';
+import { WS_BEARER_SUBPROTOCOL_PREFIX } from '../transaction/auth/credentialSource.js';
 /**
  * The wire-protocol version. It increases on any breaking change to a frame's
  * shape, so a connector and server on mismatched versions fail fast during
@@ -71,7 +72,7 @@ export const readyFrameSchema = z.object({
     protocolVersion: z.number().int(),
     sourceId: z.string().optional(),
     organizationId: z.string().optional(),
-    environment: z.enum(['production', 'sandbox']).optional(),
+    environment: environmentSchema.optional(),
 });
 /**
  * A single load, list, or commit request the server forwards to the connector.

package/dist/source/contract.d.ts

@@ -6,14 +6,20 @@
  * one schema that validates it.
  *
  * These schemas describe the adapter's own contract: the change set it commits,
- * the outbox row it stores, and the table migrations it ships. They do not
- * redefine the shared `SourceOperation` and `SourceEvent` wire types, which live
- * in `types.ts`; instead `operationSchema` is kept structurally compatible with
- * `SourceOperation`, a compatibility the assertion at the end of this file proves
- * at compile time so the schema and the interface cannot drift apart.
+ * the outbox row it stores, and the table migrations it ships. The operation
+ * vocabulary is not restated here — `operationSchema` is projected from the
+ * core's `commitOperationSchema`, so an action or field added to the commit
+ * contract reaches a data source by construction. The assertion at the end of
+ * this file then pins the published `SourceOperation` interface to that
+ * projection, which is what keeps the interface tied to the core rather than
+ * merely tied to a second local copy of it.
  */
 import { z } from 'zod';
-/** Mirrors `SourceOperation['type']`. */
+/**
+ * Served, not mirrored. The commit vocabulary is declared once in the core; a
+ * data source speaks the same five actions, so it re-exports them rather than
+ * listing them again under a second name.
+ */
 export declare const operationTypeSchema: z.ZodEnum<{
     CREATE: "CREATE";
     UPDATE: "UPDATE";
@@ -23,9 +29,15 @@ export declare const operationTypeSchema: z.ZodEnum<{
 }>;
 export type OperationType = z.infer<typeof operationTypeSchema>;
 /**
- * A single operation within a change set, and the runtime validator for it. It is
- * structurally compatible with the shared `SourceOperation` type, as the assertion
- * at the end of this file confirms.
+ * A single operation within a change set, and the runtime validator for it.
+ *
+ * The field set is projected from `commitOperationSchema` — an operation
+ * reaching a data source is a commit operation minus the two fields the core
+ * settles internally (`bypass`, `fenceToken`). The two `min(1)` overrides are
+ * deliberate and local: this is a customer-implemented boundary, so an empty
+ * model name or row id is rejected here rather than forwarded. Stating them as
+ * an extension keeps the tightening visible as a choice instead of hiding it
+ * inside a second copy of the shape.
  */
 export declare const operationSchema: z.ZodObject<{
     type: z.ZodEnum<{
@@ -35,16 +47,16 @@ export declare const operationSchema: z.ZodObject<{
         ARCHIVE: "ARCHIVE";
         UNARCHIVE: "UNARCHIVE";
     }>;
-    model: z.ZodString;
-    id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    input: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-    transactionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     readAt: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
     onStale: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
         reject: "reject";
         overwrite: "overwrite";
         notify: "notify";
     }>>>;
+    transactionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    model: z.ZodString;
+    id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    input: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
 }, z.core.$strip>;
 export type Operation = z.infer<typeof operationSchema>;
 /** The supported customer-transaction echo mechanism. */
@@ -92,16 +104,16 @@ export declare const changeSetSchema: z.ZodObject<{
             ARCHIVE: "ARCHIVE";
             UNARCHIVE: "UNARCHIVE";
         }>;
-        model: z.ZodString;
-        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        input: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-        transactionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         readAt: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
         onStale: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
             reject: "reject";
             overwrite: "overwrite";
             notify: "notify";
         }>>>;
+        transactionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        model: z.ZodString;
+        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        input: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
     }, z.core.$strip>>;
     correlationId: z.ZodString;
     intentHash: z.ZodOptional<z.ZodString>;

package/dist/source/contract.js

@@ -6,37 +6,42 @@
  * one schema that validates it.
  *
  * These schemas describe the adapter's own contract: the change set it commits,
- * the outbox row it stores, and the table migrations it ships. They do not
- * redefine the shared `SourceOperation` and `SourceEvent` wire types, which live
- * in `types.ts`; instead `operationSchema` is kept structurally compatible with
- * `SourceOperation`, a compatibility the assertion at the end of this file proves
- * at compile time so the schema and the interface cannot drift apart.
+ * the outbox row it stores, and the table migrations it ships. The operation
+ * vocabulary is not restated here — `operationSchema` is projected from the
+ * core's `commitOperationSchema`, so an action or field added to the commit
+ * contract reaches a data source by construction. The assertion at the end of
+ * this file then pins the published `SourceOperation` interface to that
+ * projection, which is what keeps the interface tied to the core rather than
+ * merely tied to a second local copy of it.
  */
 import { z } from 'zod';
-import { correlationIdSchema } from '../wire/commit.js';
+import { correlationIdSchema } from '../transaction/wire/commit.js';
+import { commitOperationSchema, commitOperationTypeSchema, } from '../transaction/coordination/schema.js';
 import { ABLO_SOURCE_CLIENT_TX_ID_MAX_LENGTH, ABLO_SOURCE_ECHO_MAX_OPERATIONS, ABLO_SOURCE_ECHO_MAX_PAYLOAD_BYTES, } from './types.js';
 const jsonObject = z.record(z.string(), z.unknown());
-/** Mirrors `SourceOperation['type']`. */
-export const operationTypeSchema = z.enum([
-    'CREATE',
-    'UPDATE',
-    'DELETE',
-    'ARCHIVE',
-    'UNARCHIVE',
-]);
 /**
- * A single operation within a change set, and the runtime validator for it. It is
- * structurally compatible with the shared `SourceOperation` type, as the assertion
- * at the end of this file confirms.
+ * Served, not mirrored. The commit vocabulary is declared once in the core; a
+ * data source speaks the same five actions, so it re-exports them rather than
+ * listing them again under a second name.
  */
-export const operationSchema = z.object({
-    type: operationTypeSchema,
+export const operationTypeSchema = commitOperationTypeSchema;
+/**
+ * A single operation within a change set, and the runtime validator for it.
+ *
+ * The field set is projected from `commitOperationSchema` — an operation
+ * reaching a data source is a commit operation minus the two fields the core
+ * settles internally (`bypass`, `fenceToken`). The two `min(1)` overrides are
+ * deliberate and local: this is a customer-implemented boundary, so an empty
+ * model name or row id is rejected here rather than forwarded. Stating them as
+ * an extension keeps the tightening visible as a choice instead of hiding it
+ * inside a second copy of the shape.
+ */
+export const operationSchema = commitOperationSchema
+    .omit({ bypass: true, fenceToken: true })
+    .extend({
     model: z.string().min(1),
     id: z.string().min(1).nullish(),
     input: jsonObject.nullish(),
-    transactionId: z.string().nullish(),
-    readAt: z.number().nullish(),
-    onStale: z.enum(['reject', 'overwrite', 'notify']).nullish(),
 });
 /** The supported customer-transaction echo mechanism. */
 export const sourceCommitEchoSchema = z.object({

package/dist/source/factory.d.ts

@@ -5,7 +5,7 @@
  * enforces the per-key scopes, and routes the four wire operations (`load`,
  * `list`, `commit`, and `events`) to whichever handlers you configured.
  */
-import type { Schema, SchemaRecord, InferCreate } from '../schema/schema.js';
+import type { Schema, SchemaRecord, InferCreate } from '../transaction/schema/schema.js';
 import type { DataSourceAdapter } from './adapter.js';
 import type { SourceApiKey, SourceAuthorizeContext, SourceCommitHandler, SourceEventsHandler, SourceModelHandlers, SourceRequest, SourceScope } from './types.js';
 type SourceModels<S extends SchemaRecord, TAuth> = Partial<{

package/dist/source/idempotency.js

@@ -11,8 +11,8 @@
  */
 import { createHash } from 'node:crypto';
 import { z } from 'zod';
-import { AbloValidationError } from '../errors.js';
-import { COMMIT_CORRELATION_ID_MAX_LENGTH, correlationIdSchema, } from '../wire/commit.js';
+import { AbloValidationError } from '../transaction/errors.js';
+import { COMMIT_CORRELATION_ID_MAX_LENGTH, correlationIdSchema, } from '../transaction/wire/commit.js';
 const SOURCE_ECHO_TRANSACTION_ID_PREFIX = 'ablo_echo_tx_v1:';
 const sourceOperationTransactionIdSchema = z
     .string()

package/dist/source/index.d.ts

@@ -20,3 +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 '../transaction/footprint.js';

package/dist/source/index.js

@@ -25,3 +25,6 @@ export { prismaDataSource } from './adapters/prisma.js';
 export { adapterTableMigrations, endpointOutboxMigrations, idempotencyLedgerMigrations, } from './migrations.js';
 export { createKyselyMutationAdapter, createKyselyMutationCore, kyselyDataSource, kyselyDirectMutation, kyselyOperationRowId, } from './adapters/kysely.js';
 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 '../transaction/footprint.js';

package/dist/source/next.d.ts

@@ -19,7 +19,7 @@
  * For hand-written handlers, or another framework, call the core `dataSource()`
  * directly and export its result however that framework expects.
  */
-import type { SchemaRecord } from '../schema/schema.js';
+import type { SchemaRecord } from '../transaction/schema/schema.js';
 import { type DataSourceOptions } from './factory.js';
 /**
  * The options for `dataSourceNext`, which are exactly the core

package/dist/source/signing.d.ts

@@ -25,8 +25,15 @@ export interface SourceSignatureOptions {
 }
 /** Inputs to {@link verifyAbloSourceRequest}. */
 export interface SourceSignatureVerificationOptions {
-    /** The incoming request, whose headers carry the signature to check. */
-    readonly request: Request;
+    /**
+     * The incoming request, whose headers carry the signature to check. Any
+     * request-shaped object works: a fetch `Request` (its `Headers` is read with
+     * `.get`), or a plain header record like Node's `req.headers` — matching
+     * what the runtime has always accepted.
+     */
+    readonly request: {
+        readonly headers?: Headers | Record<string, string | string[] | undefined>;
+    };
     /** The request body, which must match what was signed. */
     readonly body: string;
     /** The API key to verify against. */

package/dist/source/signing.js

@@ -43,7 +43,10 @@ function getHeader(request, name) {
         return headers.get(name);
     }
     const record = headers;
-    return record[name] ?? record[name.toLowerCase()] ?? null;
+    const value = record[name] ?? record[name.toLowerCase()] ?? null;
+    // Node folds repeated headers into an array; the signature headers are
+    // single-valued, so the first entry is the one that was signed.
+    return Array.isArray(value) ? (value[0] ?? null) : value;
 }
 /**
  * Parse a `webhook-signature` header per the Standard Webhooks spec.

package/dist/source/types.d.ts

@@ -9,7 +9,9 @@
  * and context types your source implements. {@link sourceEventForOperation}
  * builds a change-event marker from an operation.
  */
-import type { Environment } from '../environment.js';
+import type { Environment } from '../transaction/environment.js';
+import type { CommitOperationType, OnStaleMode } from '../transaction/coordination/schema.js';
+import type { ParticipantKind } from '../transaction/types/participant.js';
 /** A scalar value that can appear in a source filter. */
 export type SourcePrimitive = string | number | boolean | null;
 /**
@@ -58,7 +60,7 @@ export type SourceListResult<Row> = readonly Row[] | SourceListPage<Row>;
  */
 export interface SourceRequestContext {
     readonly participantId?: string;
-    readonly participantKind?: 'user' | 'agent' | 'system';
+    readonly participantKind?: ParticipantKind;
     readonly organizationId?: string;
     /** Trusted project plane selected by the authenticating credential. */
     readonly projectId?: string;
@@ -83,13 +85,13 @@ export interface SourceRequestContext {
  * do when the row changed since it was read at `readAt`.
  */
 export interface SourceOperation {
-    readonly type: 'CREATE' | 'UPDATE' | 'DELETE' | 'ARCHIVE' | 'UNARCHIVE';
+    readonly type: CommitOperationType;
     readonly model: string;
     readonly id?: string | null;
     readonly input?: Record<string, unknown> | null;
     readonly transactionId?: string | null;
     readonly readAt?: number | null;
-    readonly onStale?: 'reject' | 'overwrite' | 'notify' | null;
+    readonly onStale?: OnStaleMode | null;
 }
 /**
  * A computed change to one row, ready to append to the change log. Your

package/dist/source/types.js

@@ -9,7 +9,7 @@
  * and context types your source implements. {@link sourceEventForOperation}
  * builds a change-event marker from an operation.
  */
-import { AbloValidationError } from '../errors.js';
+import { AbloValidationError } from '../transaction/errors.js';
 /**
  * Build the {@link SourceEvent} marker you should record in your outbox table,
  * within the same transaction as the row change it describes.

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 '../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
@@ -42,7 +42,7 @@ export interface SyncStatus {
  */
 export interface LocalMutation {
     type: 'create' | 'update' | 'delete' | 'archive' | 'unarchive';
-    /** The registered name of the mutated model, for example `'SlideLayer'`. */
+    /** The registered name of the mutated model, for example `'Block'`. */
     modelName: string;
     modelId: string;
     /** The new field values, for a create or an update. */

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,9 +5,9 @@
  * 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 '../errors.js';
+import { AbloConnectionError } from '../transaction/errors.js';
 import { getActiveRegistry, hasActiveRegistry } from '../ModelRegistry.js';
 /**
  * DatabaseManager - Manages Ablo's two-tier database architecture
@@ -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/stores/ObjectStore.d.ts

@@ -2,7 +2,7 @@
  * The IndexedDB-backed object store: durable, per-model record storage for
  * the browser. See {@link ObjectStore}.
  */
-import type { ModelMetadata } from '../types/index.js';
+import type { ModelMetadata } from '../transaction/types/index.js';
 import type { ObjectStoreContract } from './ObjectStoreContract.js';
 /**
  * IDB transaction options type (TypeScript's lib.dom.d.ts may be outdated)