@abloatai/ablo 0.36.0 → 0.37.1

package/dist/schema/serialize.js

@@ -1,265 +0,0 @@
-/**
- * Schema ⇄ JSON.
- *
- * A `Schema` is fully serializable apart from its client-only closures — the
- * Zod validators and computed getters. {@link serializeSchema} emits the
- * plain-data JSON form and {@link parseSchema} reconstructs a working `Schema`
- * from it: one `Schema` type with two representations.
- *
- * A hosted, multi-tenant server loads a tenant's schema with `parseSchema(json)`
- * rather than importing it in process. The JSON is what `ablo push` sends and
- * what the server stores per tenant and version.
- *
- * What round-trips:
- *   - all model routing and scoping metadata: typename, tableName, load,
- *     mutable, the `tenancy` descriptor, bootstrap hints, scope, grants,
- *     entityRoles, the `conflict` disposition map, persist, autoFill,
- *     requiredFields, and lazyObservable. The authoring shorthands (`policy`
- *     and `groups`) are normalized into these canonical fields when the model
- *     is built, so only the canonical fields cross here.
- *   - relations, including the resolved `foreignKeyColumn`
- *   - field metadata (names and type tags), from which validators are rebuilt
- *   - identity roles
- *
- * What does not round-trip, because the server never needs it:
- *   - computed getters, which are closures and are dropped
- *   - exact Zod refinements, which are rebuilt as permissive validators from
- *     {@link FieldMeta}; the server does no field-shape validation
- */
-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. */
-const SCHEMA_JSON_VERSION = 3;
-// ── Serialize ────────────────────────────────────────────────────────────────
-function relationToJSON(rel) {
-    const options = rel.options;
-    return {
-        type: rel.type,
-        target: rel.target,
-        foreignKey: rel.foreignKey,
-        foreignKeyColumn: rel.foreignKeyColumn,
-        options: options && Object.keys(options).length > 0 ? { ...options } : undefined,
-        orderBy: rel._orderBy,
-    };
-}
-function modelToJSON(def) {
-    const relations = {};
-    for (const [name, rel] of Object.entries(def.relations)) {
-        relations[name] = relationToJSON(rel);
-    }
-    return {
-        fields: def.fields,
-        relations,
-        load: def.load,
-        // `defineSchema` always resolves `typename` to the schema key when unset,
-        // so it is present on a built ModelDef; fall back defensively anyway.
-        typename: def.typename ?? '',
-        tableName: def.tableName,
-        tenancy: def.tenancy,
-        plane: def.plane,
-        scope: def.scope,
-        grants: def.grants,
-        entityRoles: def.entityRoles,
-        conflict: def.conflict,
-        bootstrapLimit: def.bootstrapLimit,
-        bootstrapOrderBy: def.bootstrapOrderBy,
-        mutable: def.mutable,
-        lazyObservable: def.lazyObservable,
-        persist: def.persist,
-        autoFill: def.autoFill,
-        requiredFields: def.requiredFields,
-    };
-}
-/**
- * Project a `Schema` to its JSON form. Drops the client-only closures
- * (validators, `computed`); keeps everything the server and a faithful
- * rebuild need. The result is plain data — `JSON.stringify`-safe.
- */
-export function toSchemaJSON(schema) {
-    const models = {};
-    for (const [key, def] of Object.entries(schema.models)) {
-        if (def.typename === '' || def.typename === undefined) {
-            // typename '' only happens for a malformed def; surface it loudly
-            // rather than ship a model the server can't route.
-            models[key] = { ...modelToJSON(def), typename: key };
-        }
-        else {
-            models[key] = modelToJSON(def);
-        }
-    }
-    return {
-        v: SCHEMA_JSON_VERSION,
-        models,
-        identityRoles: schema.identityRoles,
-        ...(Object.keys(schema.sessionSettings).length > 0
-            ? { sessionSettings: schema.sessionSettings }
-            : {}),
-    };
-}
-/** Serialize a `Schema` to a JSON string (the `ablo push` payload). */
-export function serializeSchema(schema) {
-    return JSON.stringify(toSchemaJSON(schema));
-}
-// ── Parse ──────────────────────────────────────────────────────────────────
-/** Rebuild a Zod validator for a field from its metadata. Permissive by
- * design — the server does no field-shape validation; this exists so a
- * parsed `Schema` is structurally a real `Schema`. */
-function zodForField(meta) {
-    let base;
-    switch (meta.type) {
-        case 'string':
-            base = z.string();
-            break;
-        case 'number':
-            base = z.number();
-            break;
-        case 'boolean':
-            base = z.boolean();
-            break;
-        case 'date':
-            base = z.date();
-            break;
-        case 'enum':
-            base =
-                meta.enumValues && meta.enumValues.length > 0
-                    ? z.enum(meta.enumValues)
-                    : z.string();
-            break;
-        case 'json':
-        default:
-            base = z.unknown();
-            break;
-    }
-    return meta.isOptional ? base.optional() : base;
-}
-function relationFromJSON(rel) {
-    // The brand symbols on RelationDef are declare-only (no runtime
-    // presence), so a plain object with the runtime members satisfies every
-    // server-side reader. Cast through unknown to attach the nominal type.
-    return {
-        type: rel.type,
-        target: rel.target,
-        foreignKey: rel.foreignKey,
-        foreignKeyColumn: rel.foreignKeyColumn,
-        options: rel.options ?? {},
-        _orderBy: rel.orderBy,
-    };
-}
-function modelFromJSON(json) {
-    // `z.ZodRawShape` is a readonly index signature in Zod v4, so build a
-    // mutable record and cast once when handing it to `z.object`/`ModelDef`.
-    const shapeMut = {};
-    for (const [name, meta] of Object.entries(json.fields)) {
-        shapeMut[name] = zodForField(meta);
-    }
-    const shape = shapeMut;
-    const relations = {};
-    for (const [name, rel] of Object.entries(json.relations)) {
-        relations[name] = relationFromJSON(rel);
-    }
-    return {
-        schema: z.object(shape),
-        shape,
-        fields: json.fields,
-        relations,
-        load: json.load,
-        bootstrapLimit: json.bootstrapLimit,
-        bootstrapOrderBy: json.bootstrapOrderBy,
-        typename: json.typename,
-        persist: json.persist,
-        tableName: json.tableName,
-        tenancy: json.tenancy,
-        // Absent in older artifacts → default `tenant`, matching the model builder
-        // and provisioning defaults so the round-trip stays stable.
-        plane: json.plane ?? 'tenant',
-        scope: json.scope,
-        grants: json.grants,
-        entityRoles: json.entityRoles,
-        // Absent in older artifacts → undefined, so the commit path falls through to
-        // the function registry or the engine default.
-        conflict: json.conflict,
-        mutable: json.mutable,
-        lazyObservable: json.lazyObservable,
-        // computed getters are closures and intentionally not serialized; a
-        // parsed schema (server-side) has none.
-        computed: undefined,
-        autoFill: json.autoFill,
-        requiredFields: json.requiredFields,
-    };
-}
-/**
- * Reconstruct a working `Schema` from its JSON form. Validators are rebuilt
- * permissively from field metadata (the server never validates field shapes);
- * `computed` getters are absent. Everything the server reads — routing,
- * scoping, relations, identity roles — is restored exactly.
- */
-export function fromSchemaJSON(json) {
-    const models = {};
-    const validators = {};
-    for (const [key, modelJson] of Object.entries(json.models)) {
-        const def = modelFromJSON(modelJson);
-        models[key] = def;
-        validators[key] = baseFieldsSchema.merge(def.schema);
-    }
-    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 ?? {},
-    };
-}
-/** Parse a `Schema` from a JSON string (inverse of {@link serializeSchema}). */
-export function parseSchema(json) {
-    const parsed = JSON.parse(json);
-    if (parsed.v !== SCHEMA_JSON_VERSION) {
-        throw new AbloValidationError(`parseSchema: unsupported schema-JSON version ${parsed.v} (expected ${SCHEMA_JSON_VERSION})`, { code: 'schema_definition_invalid' });
-    }
-    return fromSchemaJSON(parsed);
-}
-// ── Hash ─────────────────────────────────────────────────────────────────────
-/**
- * Stable content hash of a `Schema`'s JSON form. FNV-1a over a canonical
- * (sorted-key) encoding — deterministic across runs and order-invariant, no
- * `crypto` dependency. Used for connect-time version gating: the client sends
- * the hash it was built against, the server compares it to the tenant's
- * active schema hash. Not a security primitive.
- */
-export function schemaHash(schema) {
-    return fnv1a(canonicalJson(toSchemaJSON(schema)));
-}
-/**
- * Content hash of ONE serialized model — the unit of the semantic drift check.
- * Two schemas agree on a model exactly when these match, which is what lets a
- * client compare only the models it declares instead of welding itself to the
- * whole-schema hash (where any additive push reads as drift). Computed over the
- * model's `SchemaJSON` entry with the same canonicalization and hash as
- * {@link schemaHash}, on both the client and the server's `GET /api/schema`.
- */
-export function modelHash(modelJson) {
-    return fnv1a(canonicalJson(modelJson));
-}
-/** FNV-1a over an already-canonical string — shared by both hashes above. */
-function fnv1a(canonical) {
-    let h = 0x811c9dc5;
-    for (let i = 0; i < canonical.length; i++) {
-        h ^= canonical.charCodeAt(i);
-        h = Math.imul(h, 0x01000193);
-    }
-    return (h >>> 0).toString(16).padStart(8, '0');
-}
-/** Stable JSON: object keys sorted recursively, `undefined` dropped. */
-function canonicalJson(value) {
-    if (value === null || typeof value !== 'object')
-        return JSON.stringify(value) ?? 'null';
-    if (Array.isArray(value))
-        return `[${value.map(canonicalJson).join(',')}]`;
-    const entries = Object.entries(value)
-        .filter(([, v]) => v !== undefined)
-        .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
-    return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${canonicalJson(v)}`).join(',')}}`;
-}

package/dist/schema/sugar.d.ts

@@ -1,109 +0,0 @@
-/**
- * A concise, claim-first way to declare a model. Each verb is shorthand for a
- * {@link model} call with two decisions already made, so a reader learns the two
- * facts that matter most about an entity before scanning its fields:
- *
- *   - Writability: `mutable.*` lets clients send create, update, and delete
- *     operations over the commit protocol. `readOnly.*` means the server owns the
- *     model — its changes stream to clients as deltas, but clients cannot mutate it.
- *   - Load strategy: `.instant` loads the model at bootstrap, `.lazy` loads it on
- *     first access, and `.manual` loads it only when you query it explicitly.
- *
- * The two-token form (`mutable.lazy({...})`) states the safety claim in the first
- * token and the load shape in the second. The plain {@link model} factory remains
- * available; these verbs are a convenience layered over it.
- *
- * @example
- * ```ts
- * tasks: mutable.lazy({ title: z.string() }, {
- *   typename: 'Task', tableName: 'tasks',
- *   relations: { ... },
- *   computed: tasksComputed,
- * }),
- * ```
- */
-import type { z } from 'zod';
-import { type ModelDef, type ModelOptions, type ComputedRecord, type RelationRecord } from '../transaction/schema/model.js';
-/**
- * Options accepted by every sugar verb. A strict subset of
- * {@link ModelOptions} — anything the verb infers (`mutable`, `load`,
- * `lazyObservable`) is deliberately absent so the call site can't
- * contradict its verb.
- */
-export interface SugarOptions<R extends RelationRecord = RelationRecord, C extends ComputedRecord = ComputedRecord> {
-    /** Relations to other models. Same shape as `model()`'s second arg. */
-    relations?: R;
-    /** Computed getters installed on the model class prototype. */
-    computed?: C;
-    /**
-     * Wire `__typename` (PascalCase, e.g. `'Task'`). Defaults to the schema
-     * key via `defineSchema` — override when the wire shape differs from
-     * the camelCase schema key.
-     */
-    typename?: string;
-    /**
-     * The physical table name. Override it when the table name differs from the
-     * snake_case of the typename — for example, a `Member` type stored in a table
-     * named `'member'` rather than `'members'`.
-     */
-    tableName?: string;
-    /**
-     * The row-access policy for tenant isolation — the rule deciding who may read a
-     * row. A discriminated union on `by` (`column`, `parent`, or `none`). See
-     * {@link ModelOptions.policy}.
-     */
-    policy?: ModelOptions['policy'];
-    /**
-     * Sync-group routing — which delta *channels* a row fans into
-     * (`root` / `grants` / `roles`). See {@link ModelOptions.groups}.
-     */
-    groups?: ModelOptions['groups'];
-    /** Max rows loaded during bootstrap. Only applies to `.instant`. */
-    bootstrapLimit?: number;
-    /** Bootstrap sort order (e.g. `'created_at DESC'`). */
-    bootstrapOrderBy?: string;
-    /** IndexedDB persistence hints — see {@link ModelOptions.persist}. */
-    persist?: ModelOptions['persist'];
-    /**
-     * Defer MobX observability to first access. Override the verb's
-     * default when a `.lazy` model is small enough that eager MobX setup
-     * is fine, or a `.instant` model is hot enough to justify deferral.
-     */
-    lazyObservable?: boolean;
-}
-/**
- * Client-writable entities. `mutable.*` is the opt-in signal for wire
- * mutations via `commit` — equivalent to setting
- * `{ mutable: true, load: X }` on `model()`.
- *
- * Pick the load suffix by data-access pattern:
- *   - `.instant`  — small, always-needed (Theme, Layout, StatusGroup)
- *   - `.lazy`     — large collections fetched on first query
- *     (Block, Message, Task)
- */
-export declare const mutable: {
-    instant: <Shape extends z.ZodRawShape, R extends RelationRecord = Record<string, never>, C extends ComputedRecord = Record<string, never>>(shape: Shape, opts?: SugarOptions<R, C>) => ModelDef<Shape, R, C>;
-    lazy: <Shape extends z.ZodRawShape, R extends RelationRecord = Record<string, never>, C extends ComputedRecord = Record<string, never>>(shape: Shape, opts?: SugarOptions<R, C>) => ModelDef<Shape, R, C>;
-};
-/**
- * Server-managed entities. `readOnly.*` means clients subscribe to
- * deltas but cannot emit mutations — any `commit` op for this model
- * is rejected at the server with "Unknown model."
- *
- * Use for:
- *   - Server-written state: `sync_deltas`, `presence`, version vectors
- *   - Ingestion pipelines: digest entries, filing jobs
- *   - Audit surfaces: anything where clients watch but only the server
- *     writes
- */
-export declare const readOnly: {
-    instant: <Shape extends z.ZodRawShape, R extends RelationRecord = Record<string, never>, C extends ComputedRecord = Record<string, never>>(shape: Shape, opts?: SugarOptions<R, C>) => ModelDef<Shape, R, C>;
-    lazy: <Shape extends z.ZodRawShape, R extends RelationRecord = Record<string, never>, C extends ComputedRecord = Record<string, never>>(shape: Shape, opts?: SugarOptions<R, C>) => ModelDef<Shape, R, C>;
-    /**
-     * Internal-only: kept out of bootstrap and never written by clients. The
-     * strongest safety posture — use for tables the SDK must know about (for type
-     * inference) but that no client should be able to write. Rows still reach a
-     * client that reads the model, so this is a write boundary, not a read one.
-     */
-    internal: <Shape extends z.ZodRawShape, R extends RelationRecord = Record<string, never>, C extends ComputedRecord = Record<string, never>>(shape: Shape, opts?: SugarOptions<R, C>) => ModelDef<Shape, R, C>;
-};

package/dist/schema/sugar.js

@@ -1,83 +0,0 @@
-/**
- * A concise, claim-first way to declare a model. Each verb is shorthand for a
- * {@link model} call with two decisions already made, so a reader learns the two
- * facts that matter most about an entity before scanning its fields:
- *
- *   - Writability: `mutable.*` lets clients send create, update, and delete
- *     operations over the commit protocol. `readOnly.*` means the server owns the
- *     model — its changes stream to clients as deltas, but clients cannot mutate it.
- *   - Load strategy: `.instant` loads the model at bootstrap, `.lazy` loads it on
- *     first access, and `.manual` loads it only when you query it explicitly.
- *
- * The two-token form (`mutable.lazy({...})`) states the safety claim in the first
- * token and the load shape in the second. The plain {@link model} factory remains
- * available; these verbs are a convenience layered over it.
- *
- * @example
- * ```ts
- * tasks: mutable.lazy({ title: z.string() }, {
- *   typename: 'Task', tableName: 'tasks',
- *   relations: { ... },
- *   computed: tasksComputed,
- * }),
- * ```
- */
-import { model, } from '../transaction/schema/model.js';
-/** Internal helper — builds a ModelDef with baseline safety+load flags applied. */
-function build(shape, opts, baseline) {
-    return model(shape, { relations: (opts?.relations ?? {}), mutable: baseline.mutable,
-        load: baseline.load,
-        lazyObservable: opts?.lazyObservable ?? baseline.lazyObservable,
-        typename: opts?.typename,
-        tableName: opts?.tableName,
-        policy: opts?.policy,
-        groups: opts?.groups,
-        bootstrapLimit: opts?.bootstrapLimit,
-        bootstrapOrderBy: opts?.bootstrapOrderBy,
-        persist: opts?.persist,
-        computed: opts?.computed, });
-}
-/**
- * Client-writable entities. `mutable.*` is the opt-in signal for wire
- * mutations via `commit` — equivalent to setting
- * `{ mutable: true, load: X }` on `model()`.
- *
- * Pick the load suffix by data-access pattern:
- *   - `.instant`  — small, always-needed (Theme, Layout, StatusGroup)
- *   - `.lazy`     — large collections fetched on first query
- *     (Block, Message, Task)
- */
-export const mutable = {
-    instant: (shape, opts) => 
-    // Reactive by default (see readonly.instant note): opt out with
-    // `lazyObservable: false` only for very large read-only list models.
-    build(shape, opts, { mutable: true, load: 'instant', lazyObservable: true }),
-    lazy: (shape, opts) => build(shape, opts, { mutable: true, load: 'lazy', lazyObservable: true }),
-};
-/**
- * Server-managed entities. `readOnly.*` means clients subscribe to
- * deltas but cannot emit mutations — any `commit` op for this model
- * is rejected at the server with "Unknown model."
- *
- * Use for:
- *   - Server-written state: `sync_deltas`, `presence`, version vectors
- *   - Ingestion pipelines: digest entries, filing jobs
- *   - Audit surfaces: anything where clients watch but only the server
- *     writes
- */
-export const readOnly = {
-    instant: (shape, opts) => 
-    // Reactive by default, like every variant: a remote delta that mutates a row
-    // in place must re-render reactive reads. Opt out per-model with
-    // `lazyObservable: false` for very large read-only lists where per-field
-    // atoms cost more than the QueryView's entry-replaced reactivity.
-    build(shape, opts, { mutable: false, load: 'instant', lazyObservable: true }),
-    lazy: (shape, opts) => build(shape, opts, { mutable: false, load: 'lazy', lazyObservable: true }),
-    /**
-     * Internal-only: kept out of bootstrap and never written by clients. The
-     * strongest safety posture — use for tables the SDK must know about (for type
-     * inference) but that no client should be able to write. Rows still reach a
-     * client that reads the model, so this is a write boundary, not a read one.
-     */
-    internal: (shape, opts) => build(shape, opts, { mutable: false, load: 'lazy', lazyObservable: true }),
-};

package/dist/schema/syncDeltaRow.d.ts

@@ -1,6 +0,0 @@
-/**
- * Compatibility entry point for the durable `sync_deltas` row contract, which
- * is owned by the transaction layer. The schema barrel continues to re-export
- * this path so existing `@abloatai/ablo/schema` consumers do not change.
- */
-export * from '../transaction/log/syncDeltaRow.js';

package/dist/schema/syncDeltaRow.js

@@ -1,6 +0,0 @@
-/**
- * Compatibility entry point for the durable `sync_deltas` row contract, which
- * is owned by the transaction layer. The schema barrel continues to re-export
- * this path so existing `@abloatai/ablo/schema` consumers do not change.
- */
-export * from '../transaction/log/syncDeltaRow.js';

package/dist/server/adapter.d.ts

@@ -1,173 +0,0 @@
-/**
- * `@abloatai/ablo/server` — the `DataAdapter` storage contract.
- *
- * A `DataAdapter` is the boundary between the sync engine and a database. The
- * engine asks it to do three things — `read` canonical rows, `commit` a change,
- * and `sync` the change log — and expects nothing beyond that. Everything
- * higher up, such as proposing a change or resolving a conflict, is handled
- * before the adapter is ever called.
- *
- * This module declares the contract and the value types that travel through it;
- * you supply the implementation for your own database. The reference Postgres
- * implementation ships separately, because it carries a SQL driver and raw
- * queries that have no place in this browser-safe build.
- *
- * Every shape here builds on {@link Row}, the single canonical form of a
- * database row that the rest of the engine reads and writes.
- */
-import type { SourceListQuery, SourceOperation, SourceRequestContext } from '../source/index.js';
-import type { ServerSyncDelta } from '../transaction/wire/delta.js';
-import type { BootstrapModel } from './readConfig.js';
-import type { CommitContext, CommitResult } from './commit.js';
-import type { StorageMode } from './storageMode.js';
-/**
- * A canonical database row: one record, keyed by column name. The value type is
- * `unknown` by design, not `any` — columns arrive as JSON or in whatever form
- * the driver hands back, so a caller must narrow a value before using it. Reach
- * for this type wherever a row is passed around; it is the one name for that
- * shape, and a later schema-typed `read<T>()` can specialize it to a concrete
- * model without changing any call site.
- */
-export type Row = Record<string, unknown>;
-/**
- * The result of a {@link Row} read. Its two shapes mirror the two kinds of
- * {@link ReadRequest}:
- *  - `bootstrap`: a full load, returned as a map from model name to its rows.
- *  - `query`: the rows of a single filtered query.
- */
-export type ReadResult = {
-    readonly kind: 'bootstrap';
-    /** model name → its rows. Empty models are omitted. */
-    readonly models: Record<string, Row[]>;
-    /** Models whose read failed (partial success), if any. */
-    readonly failedModels?: string[];
-    /**
-     * Present when a paged read (`ReadRequest.page`) stopped at its row
-     * limit with rows remaining: pass it back as the next page's cursor.
-     * Absent on the final page and on unpaged reads.
-     */
-    readonly nextCursor?: string;
-} | {
-    readonly kind: 'query';
-    readonly rows: readonly Row[];
-};
-/**
- * Where a `sync` call resumes: the client's last-seen position in the
- * `sync_deltas` change log. The cursor carries only that position. Everything
- * else a sync needs — the organization, the sync groups, the largest gap it
- * will stream — is bound onto the adapter when it is resolved, so a client can
- * never ask to read an organization other than its own. A `lastSyncId` of zero
- * or less means "no position yet", which `sync` answers with `needsFullRead`.
- */
-export interface SyncCursor {
-    readonly lastSyncId: number;
-}
-export interface DataAdapterCapabilities {
-    /** The backend can dry-run a change without committing it. */
-    readonly propose?: boolean;
-    /** `commit` is atomic (all-or-nothing) across the change's operations. */
-    readonly transactions?: boolean;
-    /** Changes fan out in real time (vs poll-only). */
-    readonly realtime?: boolean;
-    /** The backend can be introspected for its schema. */
-    readonly schemaIntrospection?: boolean;
-}
-/** Result of a dry-run proposal (only adapters with `capabilities.propose`). */
-export interface ProposalResult {
-    readonly ok: boolean;
-    readonly conflicts?: readonly {
-        readonly model: string;
-        readonly id: string;
-        readonly reason: string;
-    }[];
-    readonly rows?: readonly Row[];
-}
-/**
- * A request for canonical rows, in one of two shapes:
- *  - `bootstrap`: the full-load reader — every enabled model's rows at once.
- *  - `query`: a single filtered query against one model, used by the live
- *    `/sync/query` path.
- *
- * A `query` carries its own execution as the `runHosted` closure, the same way
- * a {@link ChangeSet} carries its write. This lets the adapter decide how to
- * answer the request — a data source runs the customer's `list`, a hosted
- * database runs the closure — without the query engine itself having to live
- * inside the adapter.
- */
-export type ReadRequest = {
-    readonly kind: 'bootstrap';
-    readonly models: readonly BootstrapModel[];
-    readonly requestedModels?: readonly string[];
-    readonly scope?: SourceRequestContext;
-    /**
-     * Keyset pagination for a SINGLE-model read (`requestedModels` names
-     * exactly one model): return at most `limit` rows, starting after the
-     * row whose id equals `cursor`. The result carries `nextCursor` while
-     * rows remain. Ignored for multi-model reads and by adapters whose
-     * backend pages upstream on its own.
-     */
-    readonly page?: {
-        readonly cursor?: string;
-        readonly limit: number;
-    };
-} | {
-    readonly kind: 'query';
-    readonly model: string;
-    /** Source-side model name, when it differs from `model`. */
-    readonly sourceModel?: string;
-    /** `__typename` stamped on each returned row. */
-    readonly typename: string;
-    readonly query: SourceListQuery;
-    readonly scope?: SourceRequestContext;
-    /** Runs the query against a hosted database: compile, take the tenant pool, apply row-level security, unpack the rows. */
-    readonly runHosted: () => Promise<Row[]>;
-};
-/**
- * A change to apply to the canonical store. `runHosted` holds the write already
- * bound to its execution: a hosted adapter simply runs it, while a data-source
- * adapter ignores it and ships the operations to the customer's own endpoint.
- * The adapter therefore decides how a change is applied, while the write logic
- * itself is prepared above it.
- */
-export interface ChangeSet {
-    readonly operations: readonly SourceOperation[];
-    readonly context: CommitContext;
-    readonly clientTxId: string;
-    readonly runHosted: () => Promise<CommitResult>;
-}
-export interface SyncResult {
-    /** Deltas in `(cursor.lastSyncId, nextCursor.lastSyncId]`, scoped to syncGroups. */
-    readonly changes: readonly ServerSyncDelta[];
-    readonly nextCursor: {
-        readonly lastSyncId: number;
-    };
-    /** True when the gap was too large to stream — caller must full-`read`. */
-    readonly needsFullRead: boolean;
-}
-/**
- * The interface every storage mode implements. The package defines the
- * contract; you implement it against your own database. An adapter is
- * responsible for one thing — reaching the data — and offers exactly three
- * methods to do it: `read` fetches canonical rows, `commit` applies a change,
- * and `sync` reads the change log. Anything above that line, such as proposing
- * a change or resolving a conflict, happens before the adapter is called.
- * `propose` is an optional capability, not a required method.
- */
-export interface DataAdapter {
-    /** Names the adapter's storage mode, for diagnostics. Routing is decided by
-     *  the resolver, not by reading this field. */
-    readonly mode: StorageMode;
-    readonly capabilities: DataAdapterCapabilities;
-    read(req: ReadRequest): Promise<ReadResult>;
-    commit(change: ChangeSet): Promise<CommitResult>;
-    sync(cursor: SyncCursor): Promise<SyncResult>;
-}
-/** A `DataAdapter` whose backend can dry-run a change. Narrow to this only after confirming the `propose` capability. */
-export interface ProposableDataAdapter extends DataAdapter {
-    propose(change: ChangeSet): Promise<ProposalResult>;
-}
-/** Resolves an authenticated scope to the adapter that serves it. */
-export type AdapterResolver = (scope: {
-    readonly projectId: string;
-    readonly accountScope?: string;
-}) => Promise<DataAdapter> | DataAdapter;

package/dist/server/adapter.js

@@ -1,18 +0,0 @@
-/**
- * `@abloatai/ablo/server` — the `DataAdapter` storage contract.
- *
- * A `DataAdapter` is the boundary between the sync engine and a database. The
- * engine asks it to do three things — `read` canonical rows, `commit` a change,
- * and `sync` the change log — and expects nothing beyond that. Everything
- * higher up, such as proposing a change or resolving a conflict, is handled
- * before the adapter is ever called.
- *
- * This module declares the contract and the value types that travel through it;
- * you supply the implementation for your own database. The reference Postgres
- * implementation ships separately, because it carries a SQL driver and raw
- * queries that have no place in this browser-safe build.
- *
- * Every shape here builds on {@link Row}, the single canonical form of a
- * database row that the rest of the engine reads and writes.
- */
-export {};