@abloatai/ablo 0.25.0 → 0.27.0

package/dist/config/index.d.ts

@@ -1,10 +0,0 @@
-/**
- * @abloatai/ablo/config — App initialization
- *
- * One-time setup at app boot. Provides DI interface types
- * and the initSyncEngine() function to wire real implementations.
- */
-export { initSyncEngine, resetSyncEngine, isSyncEngineInitialized } from '../context.js';
-export { noopLogger, noopObservability, noopAnalytics, browserOnlineStatus, defaultSessionErrorDetector, emptyConfig, type SyncEngineContext, } from '../SyncEngineContext.js';
-export type { SyncEngineConfig, SyncLogger, SyncObservabilityProvider, SyncAnalytics, MutationExecutor, MutationDispatcher, SessionErrorDetector, OnlineStatusProvider, CommitResult, MutationOperation, BreadcrumbLevel, SyncBreadcrumbCategory, TransactionFailureDetails, BootstrapFailureDetails, WebSocketErrorDetails, RollbackDetails, SpanAttributes, } from '../interfaces/index.js';
-export { SyncSessionError } from '../errors.js';

package/dist/config/index.js

@@ -1,12 +0,0 @@
-/**
- * @abloatai/ablo/config — App initialization
- *
- * One-time setup at app boot. Provides DI interface types
- * and the initSyncEngine() function to wire real implementations.
- */
-// Context lifecycle
-export { initSyncEngine, resetSyncEngine, isSyncEngineInitialized } from '../context.js';
-// Context type + no-op defaults (for testing or gradual adoption)
-export { noopLogger, noopObservability, noopAnalytics, browserOnlineStatus, defaultSessionErrorDetector, emptyConfig, } from '../SyncEngineContext.js';
-// Errors
-export { SyncSessionError } from '../errors.js';

package/dist/core/query-utils.d.ts

@@ -1,34 +0,0 @@
-/**
- * query-utils — Pure query helpers for the MobX `QueryView`. One source of
- * truth for sort, filter, and binary insertion logic.
- *
- * No MobX, no ObjectPool, no Model — just arrays and values.
- */
-/**
- * The incremental-update contract a view satisfies. `ViewRegistry` stores views
- * as this base type so it can dispatch to many views with different `T`
- * parameters from one Set — `View<T>` is invariant in T, so without this shared
- * base the registry would have to widen via `unknown as View<Record<...>>` at
- * every register/unregister/notify call.
- */
-export interface IncrementalView {
-    handleAdded(entity: Record<string, unknown>): void;
-    handleUpdated(entity: Record<string, unknown>): void;
-    handleRemoved(id: string): void;
-}
-/** Compare two values for sorting, null-safe. Returns -1 | 0 | 1. */
-export declare function compareValues(a: unknown, b: unknown, dir: 1 | -1): number;
-/**
- * Binary search for the correct insertion index in a sorted array.
- * Returns the index at which `item` should be inserted.
- */
-export declare function binaryInsertionIndex<T>(arr: ArrayLike<T>, item: T, sortKey: string, dir: 1 | -1): number;
-/**
- * Check whether an entity matches a declarative `where` clause.
- * Every key in `where` must exactly match the entity's value.
- */
-export declare function matchesWhere<T extends Record<string, unknown>>(entity: T, where: Partial<T>): boolean;
-/**
- * Find the index of an entity by id in an array. Returns -1 if not found.
- */
-export declare function findIndexById<T extends Record<string, unknown>>(arr: ArrayLike<T>, id: string): number;

package/dist/core/query-utils.js

@@ -1,59 +0,0 @@
-/**
- * query-utils — Pure query helpers for the MobX `QueryView`. One source of
- * truth for sort, filter, and binary insertion logic.
- *
- * No MobX, no ObjectPool, no Model — just arrays and values.
- */
-/** Compare two values for sorting, null-safe. Returns -1 | 0 | 1. */
-export function compareValues(a, b, dir) {
-    if (a === b)
-        return 0;
-    if (a == null)
-        return 1;
-    if (b == null)
-        return -1;
-    return (a < b ? -1 : 1) * dir;
-}
-/**
- * Binary search for the correct insertion index in a sorted array.
- * Returns the index at which `item` should be inserted.
- */
-export function binaryInsertionIndex(arr, item, sortKey, dir) {
-    let lo = 0;
-    let hi = arr.length;
-    const itemVal = item[sortKey];
-    while (lo < hi) {
-        const mid = (lo + hi) >>> 1;
-        const midVal = arr[mid][sortKey];
-        if (compareValues(midVal, itemVal, dir) <= 0) {
-            lo = mid + 1;
-        }
-        else {
-            hi = mid;
-        }
-    }
-    return lo;
-}
-/**
- * Check whether an entity matches a declarative `where` clause.
- * Every key in `where` must exactly match the entity's value.
- */
-export function matchesWhere(entity, where) {
-    for (const [key, value] of Object.entries(where)) {
-        if (value === undefined)
-            continue;
-        if (entity[key] !== value)
-            return false;
-    }
-    return true;
-}
-/**
- * Find the index of an entity by id in an array. Returns -1 if not found.
- */
-export function findIndexById(arr, id) {
-    for (let i = 0; i < arr.length; i++) {
-        if (arr[i]['id'] === id)
-            return i;
-    }
-    return -1;
-}

package/dist/interfaces/headless.d.ts

@@ -1,95 +0,0 @@
-/**
- * Headless DI interfaces — the three abstractions createSyncEngine needs
- * to run in Node.js without browser globals.
- *
- * STATUS: Type stubs only. No implementation yet. These interfaces are
- * the deliverable of Path C Phase 1. When all three have both a browser
- * implementation and a Node implementation, the SDK is truly headless.
- *
- * Usage (once implemented):
- *
- *   // Browser (default — no DI needed, uses browser globals)
- *   const engine = createSyncEngine({ url, userId, organizationId });
- *
- *   // Node.js / agent / sidecar (headless — DI overrides)
- *   import { inMemoryStorage, alwaysOnline } from '@abloatai/ablo/headless';
- *   const engine = createSyncEngine({
- *     url, userId, organizationId,
- *     storage: inMemoryStorage(),
- *     network: alwaysOnline(),
- *   });
- *
- * The `transport` override is optional because Node 22 has a built-in
- * global `WebSocket` class. It's included for testing (mock WebSocket)
- * and for environments where the built-in WebSocket isn't available
- * (Node 20, Deno, Bun — each has its own WebSocket story).
- *
- * See also: apps/sync-server/src/sdk-headless-entrypoint.test.ts
- * (the skipped tests that become the acceptance tests for Phase 1)
- */
-/** A record in an object store. */
-export type StorageRecord = Record<string, unknown> & {
-    id: string;
-};
-/** An object store — analogous to an IDBObjectStore. */
-export interface ObjectStore {
-    get(id: string): Promise<StorageRecord | undefined>;
-    getAll(): Promise<StorageRecord[]>;
-    getAllFromIndex(indexName: string, value: string): Promise<StorageRecord[]>;
-    put(record: StorageRecord): Promise<void>;
-    delete(id: string): Promise<void>;
-    clear(): Promise<void>;
-}
-/** A database — analogous to an IDBDatabase. */
-export interface StorageDatabase {
-    getStore(name: string): ObjectStore | undefined;
-    close(): void;
-}
-/**
- * Opens or creates a named database.
- *
- * Browser: wraps indexedDB.open(name, version)
- * Node: returns an in-memory database backed by Maps
- */
-export interface StorageProvider {
-    open(name: string, version?: number): Promise<StorageDatabase>;
-    delete(name: string): Promise<void>;
-}
-export interface NetworkProvider {
-    /** Current online status. */
-    isOnline(): boolean;
-    /**
-     * Subscribe to online/offline transitions. Returns an unsubscribe function.
-     * The callback receives `true` when coming online, `false` when going offline.
-     *
-     * Browser: listens for window 'online'/'offline' events + visibilitychange
-     * Node: never fires (always online)
-     * Test: fires when the test calls setOnline(true/false)
-     */
-    onStatusChange(callback: (online: boolean) => void): () => void;
-}
-/** Minimal WebSocket interface that SyncWebSocket uses. */
-export interface WebSocketLike {
-    readonly readyState: number;
-    readonly bufferedAmount: number;
-    send(data: string | ArrayBuffer): void;
-    close(code?: number, reason?: string): void;
-    ping?(): void;
-    addEventListener(type: 'open', handler: () => void): void;
-    addEventListener(type: 'close', handler: (event: {
-        code: number;
-        reason: string;
-    }) => void): void;
-    addEventListener(type: 'message', handler: (event: {
-        data: unknown;
-    }) => void): void;
-    addEventListener(type: 'error', handler: (event: unknown) => void): void;
-    removeEventListener(type: string, handler: (...args: unknown[]) => void): void;
-}
-export interface TransportProvider {
-    /**
-     * Create a WebSocket connection to the given URL.
-     * Returns an object satisfying the WebSocketLike interface.
-     */
-    connect(url: string): WebSocketLike;
-}

package/dist/interfaces/headless.js

@@ -1,41 +0,0 @@
-/**
- * Headless DI interfaces — the three abstractions createSyncEngine needs
- * to run in Node.js without browser globals.
- *
- * STATUS: Type stubs only. No implementation yet. These interfaces are
- * the deliverable of Path C Phase 1. When all three have both a browser
- * implementation and a Node implementation, the SDK is truly headless.
- *
- * Usage (once implemented):
- *
- *   // Browser (default — no DI needed, uses browser globals)
- *   const engine = createSyncEngine({ url, userId, organizationId });
- *
- *   // Node.js / agent / sidecar (headless — DI overrides)
- *   import { inMemoryStorage, alwaysOnline } from '@abloatai/ablo/headless';
- *   const engine = createSyncEngine({
- *     url, userId, organizationId,
- *     storage: inMemoryStorage(),
- *     network: alwaysOnline(),
- *   });
- *
- * The `transport` override is optional because Node 22 has a built-in
- * global `WebSocket` class. It's included for testing (mock WebSocket)
- * and for environments where the built-in WebSocket isn't available
- * (Node 20, Deno, Bun — each has its own WebSocket story).
- *
- * See also: apps/sync-server/src/sdk-headless-entrypoint.test.ts
- * (the skipped tests that become the acceptance tests for Phase 1)
- */
-export {};
-// ── Factory functions (to be implemented in Phase 1) ─────────────────────
-//
-// These will be the public API that headless consumers import:
-//
-//   import { inMemoryStorage, alwaysOnline } from '@abloatai/ablo/headless';
-//
-// Stubs below show the intended signatures. Implementation is Phase 1 work.
-// export function inMemoryStorage(): StorageProvider { ... }
-// export function alwaysOnline(): NetworkProvider { ... }
-// export function nodeWebSocket(): TransportProvider { ... }
-// export function controllableNetwork(): NetworkProvider & { setOnline(v: boolean): void } { ... }

package/dist/query/index.d.ts

@@ -1,6 +0,0 @@
-/**
- * Query module barrel — re-exports the public surface for convenience.
- * See types.ts and client.ts for the actual definitions.
- */
-export type { Query, QueryBatch, QueryBatchResult } from './types.js';
-export { postQuery, type PostQueryOptions } from './client.js';

package/dist/query/index.js

@@ -1,5 +0,0 @@
-/**
- * Query module barrel — re-exports the public surface for convenience.
- * See types.ts and client.ts for the actual definitions.
- */
-export { postQuery } from './client.js';

package/dist/realtime/index.d.ts

@@ -1,10 +0,0 @@
-/**
- * Internal compatibility entrypoint for the schema-powered realtime client.
- *
- * Use this build for applications that need typed model proxies,
- * subscriptions, presence, offline queueing, and a long-lived WebSocket.
- */
-export { Ablo, computeFKDepthPriority } from '../client/Ablo.js';
-export type { AbloOptions, InternalAbloOptions, LocalCountOptions, LocalReadOptions, ModelListScope, ServerReadOptions, ModelOperations, } from '../client/Ablo.js';
-import { Ablo } from '../client/Ablo.js';
-export default Ablo;

package/dist/realtime/index.js

@@ -1,9 +0,0 @@
-/**
- * Internal compatibility entrypoint for the schema-powered realtime client.
- *
- * Use this build for applications that need typed model proxies,
- * subscriptions, presence, offline queueing, and a long-lived WebSocket.
- */
-export { Ablo, computeFKDepthPriority } from '../client/Ablo.js';
-import { Ablo } from '../client/Ablo.js';
-export default Ablo;

package/dist/schema/plane.d.ts

@@ -1,23 +0,0 @@
-/**
- * Database PLANE — which database a model's rows live in. A sibling axis to
- * `tenancy` (which says how rows are isolated *within* a database):
- *
- *   - `tenant`  — the tenant data plane. For a BYO/dedicated customer this is
- *                 THEIR database; provisioning emits these tables there.
- *   - `control` — Ablo's control plane (the sync log, attribution, audit, …).
- *                 Never emitted into a customer DB; lives only in Ablo's own DB.
- *
- * P1 of the sync-delta decomposition (`docs/plans/sync-delta-zod-decomposition.md`):
- * declaring the boundary lets BYO provisioning *derive* "what a customer DB gets"
- * (`plane === 'tenant'`) instead of hand-coding it. Defaults to `tenant` —
- * today every `defineSchema` model is the customer's own data; only Ablo's
- * internal tables (once modeled in P2) declare `control`.
- */
-import { z } from 'zod';
-export declare const planeSchema: z.ZodEnum<{
-    tenant: "tenant";
-    control: "control";
-}>;
-export type SchemaPlane = z.infer<typeof planeSchema>;
-/** Default plane for a model that doesn't declare one — the tenant data plane. */
-export declare const DEFAULT_PLANE: SchemaPlane;

package/dist/schema/plane.js

@@ -1,19 +0,0 @@
-/**
- * Database PLANE — which database a model's rows live in. A sibling axis to
- * `tenancy` (which says how rows are isolated *within* a database):
- *
- *   - `tenant`  — the tenant data plane. For a BYO/dedicated customer this is
- *                 THEIR database; provisioning emits these tables there.
- *   - `control` — Ablo's control plane (the sync log, attribution, audit, …).
- *                 Never emitted into a customer DB; lives only in Ablo's own DB.
- *
- * P1 of the sync-delta decomposition (`docs/plans/sync-delta-zod-decomposition.md`):
- * declaring the boundary lets BYO provisioning *derive* "what a customer DB gets"
- * (`plane === 'tenant'`) instead of hand-coding it. Defaults to `tenant` —
- * today every `defineSchema` model is the customer's own data; only Ablo's
- * internal tables (once modeled in P2) declare `control`.
- */
-import { z } from 'zod';
-export const planeSchema = z.enum(['tenant', 'control']);
-/** Default plane for a model that doesn't declare one — the tenant data plane. */
-export const DEFAULT_PLANE = 'tenant';

package/dist/schema/sync-delta-row.js

@@ -1,103 +0,0 @@
-/**
- * Canonical Zod description of the `sync_deltas` STORAGE ROW, decomposed by the
- * subsystem it belongs to and the database plane it lives in.
- *
- * `sync_deltas` fuses five control-plane subsystems onto one denormalized row
- * (see `docs/plans/sync-delta-zod-decomposition.md`). This module is **P0** of
- * that decomposition: it DESCRIBES the existing columns as Zod schemas — no DB
- * change, no rewiring — so the subsystem + plane boundaries become explicit and
- * type-enforced:
- *
- *   - {@link syncDeltaCoreSchema}    — the SYNC-PROTOCOL slice. `tenant` plane:
- *                                      the only part that must be written
- *                                      atomically with the app row, and the shape
- *                                      a BYO outbox marker carries (the portable
- *                                      slice).
- *   - {@link deltaAttributionSchema} — who / on whose authority. `control` plane.
- *   - {@link deltaProvenanceSchema}  — which AI task caused it. `control` plane.
- *
- * {@link syncDeltaRowSchema} is the full stored row (core ∪ attribution ∪
- * provenance). {@link DELTA_PLANES} declares each slice's plane so provisioning
- * (P1) can derive "what a customer DB gets" from the schema, not hand-code it.
- *
- * Distinct from the WIRE `SyncDelta` (`sync/SyncWebSocket.ts`, client-facing) and
- * `SourceDelta` (`source/index.ts`, source-mode input) — those are projections of
- * this row. Field names mirror those + `AuditChainRow` (`@ablo/audit-chain`).
- *
- * Monorepo is on Zod v4 — `.extend(...).shape` (not deprecated `.merge`).
- */
-import { z } from 'zod';
-// ── Enums (mirror the Postgres enums; @@map name in the comment) ──────────────
-/** `participant_kind` */
-export const participantKindSchema = z.enum(['user', 'agent', 'system']);
-/** `confirmation_state` */
-export const confirmationStateSchema = z.enum([
-    'auto',
-    'previewed',
-    'approved',
-    'required_human_approval',
-    'auto_historical',
-]);
-/** `backfill_provenance` */
-export const backfillProvenanceSchema = z.enum(['exact', 'inferred', 'unknown']);
-/** A delta payload: the full post-mutation row (or null for deletes). */
-const deltaDataSchema = z.record(z.string(), z.unknown()).nullable();
-// ── Core — `tenant` plane (the sync-protocol slice) ───────────────────────────
-/**
- * Everything a client needs to materialize the change, plus the tenant key. The
- * portable slice: the only part written atomically with the app row, and the
- * shape a BYO outbox marker carries. `id` / `createdAt` / `syncGroups` are
- * control-plane-assigned at enrich/append time, so they're optional here (an
- * outbox marker doesn't have them yet).
- */
-export const syncDeltaCoreSchema = z.object({
-    /** Monotonic sync id; assigned control-plane on append (absent on a marker). */
-    id: z.union([z.bigint(), z.number()]).optional(),
-    /** `action_type` — single char: `I` | `U` | `D`. */
-    actionType: z.string().min(1).max(1),
-    modelName: z.string().min(1),
-    modelId: z.string().min(1),
-    data: deltaDataSchema,
-    previousData: deltaDataSchema.optional(),
-    /** Sync-group routing keys; computed control-plane (`buildDeltaSyncGroups`). */
-    syncGroups: z.array(z.string()).optional(),
-    /** The TRUSTED committing org — the coarse tenant-isolation boundary. */
-    organizationId: z.string().nullable(),
-    /** ISO timestamp; control-plane-assigned at append. */
-    createdAt: z.string().optional(),
-    transactionId: z.string().nullable(),
-});
-// ── Attribution — `control` plane ─────────────────────────────────────────────
-export const deltaAttributionSchema = z.object({
-    /** Legacy single-actor column, derived during the dual-write window. */
-    createdBy: z.string().nullable(),
-    actorId: z.string().nullable(),
-    actorKind: participantKindSchema.nullable(),
-    onBehalfOfId: z.string().nullable(),
-    onBehalfOfKind: participantKindSchema.nullable(),
-    capabilityId: z.string().nullable(),
-    delegationChainRootUserId: z.string().nullable().optional(),
-    confirmationState: confirmationStateSchema.nullable(),
-    backfillProvenance: backfillProvenanceSchema.nullable(),
-});
-// ── Provenance — `control` plane (→ tasks) ────────────────────────────────────
-export const deltaProvenanceSchema = z.object({
-    /** FK to `Task.id` — the LLM turn that produced this commit. */
-    causedByTaskId: z.string().nullable(),
-});
-// ── Full stored row + plane map ───────────────────────────────────────────────
-/** The complete `sync_deltas` row as stored today (core ∪ attribution ∪ provenance). */
-export const syncDeltaRowSchema = syncDeltaCoreSchema
-    .extend(deltaAttributionSchema.shape)
-    .extend(deltaProvenanceSchema.shape);
-/**
- * Each slice's database plane. The durable answer to "what does a BYO customer DB
- * get?" — only `tenant`-plane slices. Provisioning (P1) reads this instead of
- * hand-coding the boundary; the BYO outbox writes the `tenant` slice and the
- * relay enriches the `control` slices in Ablo's own database.
- */
-export const DELTA_PLANES = {
-    core: 'tenant',
-    attribution: 'control',
-    provenance: 'control',
-};

package/dist/schema/sync-delta-wire.js

@@ -1,102 +0,0 @@
-/**
- * Canonical Zod contract for the WIRE delta — the broadcast object that travels
- * server → client (the `delta` / `sync_response` frame payload). This is the
- * "same contract across both" seam: the SDK client and the sync-server each
- * derive their `SyncDelta` type from THESE schemas via `z.infer`, instead of
- * hand-maintaining two interfaces that drift (they had: the server typed
- * `actionType` as `string` and `createdBy` as a nested ref; the client typed
- * `actionType` as the 8-value union and `createdBy` as a flat string — a silent
- * divergence the client never noticed because it ignores attribution).
- *
- * Distinct from {@link import('./sync-delta-row.js').syncDeltaRowSchema} — that
- * is the STORED ROW (has `organizationId`, flat `actor_id`/`actor_kind`
- * columns, single-char action). The wire delta is a PROJECTION: no
- * `organizationId` (the server-trusted isolation predicate is never broadcast),
- * the full Linear action vocabulary, and attribution hydrated into nested
- * {@link ParticipantRef}s.
- *
- * Shape (per the "shared core + layer extensions" decision):
- *   - {@link syncDeltaWireCoreSchema} — the fields BOTH sides agree on.
- *   - {@link clientSyncDeltaSchema}    — core + the SDK-only extras.
- *   - {@link serverSyncDeltaSchema}    — core + the audit attribution the server
- *                                        enriches each broadcast with (the client
- *                                        structurally ignores these).
- *
- * Monorepo is on Zod v4.
- */
-import { z } from 'zod';
-import { participantKindSchema, confirmationStateSchema } from './sync-delta-row.js';
-/**
- * `action_type` on the WIRE — the full Linear-compatible vocabulary a broadcast
- * carries (vs the stored row's core CRUD). `I`nsert, `U`pdate, `D`elete,
- * `A`rchive, `V` reVive/unarchive, `C`overing (gained visibility), `G`roupAdded,
- * `S` groupRemoved.
- */
-export const syncDeltaActionSchema = z.enum(['I', 'U', 'D', 'A', 'V', 'C', 'G', 'S']);
-/**
- * A wire delta payload: the post-mutation row object, a control-frame STRING
- * (e.g. a serialized group-change payload on `G`/`S` deltas), or `null` (on
- * deletes). Wider than the stored `data` (row-or-null) precisely because the
- * group/permission frames serialize a string.
- */
-export const wireDeltaDataSchema = z
-    .union([z.record(z.string(), z.unknown()), z.string()])
-    .nullable();
-/**
- * A nested participant reference as carried on a BROADCAST delta. The server
- * hydrates the flat `actor_id`/`actor_kind` stored columns into this.
- */
-export const participantRefSchema = z.object({
-    kind: participantKindSchema,
-    id: z.string(),
-});
-/**
- * The fields BOTH server and client agree on for a broadcast delta — the shared
- * contract. `transactionId` is modelled as the client sees it (optional string);
- * the server projection widens it to nullable. No `organizationId` (never
- * broadcast). No `createdBy`/attribution here — those types differ per layer and
- * live in the extensions below.
- */
-export const syncDeltaWireCoreSchema = z.object({
-    id: z.number(),
-    actionType: syncDeltaActionSchema,
-    modelName: z.string().min(1),
-    modelId: z.string().min(1),
-    data: wireDeltaDataSchema,
-    previousData: wireDeltaDataSchema.optional(),
-    syncGroups: z.array(z.string()),
-    transactionId: z.string().optional(),
-    createdAt: z.string(),
-});
-/**
- * Client projection — core + the SDK-only fields the client reads locally.
- * `z.infer` of this is the SDK's `SyncDelta` (see `sync/SyncWebSocket.ts`).
- */
-export const clientSyncDeltaSchema = syncDeltaWireCoreSchema.extend({
-    /** @deprecated Flat actor id; superseded by the server's nested `actor`. The
-     *  client never reads it — kept only so the wire shape round-trips. */
-    createdBy: z.string().optional(),
-    /** Client-only payload slot (e.g. legacy group-change metadata). */
-    metadata: wireDeltaDataSchema.optional(),
-    /** Echo-matching id the client correlates against its optimistic mutation. */
-    clientMutationId: z.string().optional(),
-});
-/**
- * Server projection — core + the audit attribution the server enriches each
- * broadcast with (for the audit pane). The client ignores all of it. Overrides
- * `transactionId` to nullable (the server's stored-column reality).
- */
-export const serverSyncDeltaSchema = syncDeltaWireCoreSchema.extend({
-    transactionId: z.string().nullable(),
-    /** @deprecated Mirrors `actor` 1:1. */
-    createdBy: participantRefSchema.nullable(),
-    /** Who DID the action. */
-    actor: participantRefSchema.nullable(),
-    /** On WHOSE AUTHORITY they acted (equals `actor` for human-direct commits). */
-    onBehalfOf: participantRefSchema.nullable(),
-    /** FK to AgentCapabilityRoot.capabilityId; non-null for agent/system commits. */
-    capabilityId: z.string().nullable(),
-    confirmationState: confirmationStateSchema.nullable(),
-    /** FK to AgentTurn.id — the prompt that caused this delta. */
-    causedByTaskId: z.string().nullable(),
-});

package/dist/server/next.d.ts

@@ -1,51 +0,0 @@
-/**
- * `@abloatai/ablo/server/next` — mount Ablo's HTTP surface in a consumer's
- * Next.js App Router, the Better-Auth `toNextJsHandler` way:
- *
- * ```ts
- * // app/api/ablo/[...all]/route.ts
- * import { toAbloHandler } from '@abloatai/ablo/server/next';
- * import { ablo } from '@/lib/ablo';        // your configured Ablo HTTP app
- * export const { GET, POST } = toAbloHandler(ablo);
- * ```
- *
- * Ablo's HTTP endpoints (bootstrap / query / the commit fallback) are stateless
- * request→response, so they drop straight into a route handler. The realtime
- * WebSocket channel is deliberately NOT served here — it is a persistent
- * connection a serverless route handler cannot host, and stays an Ablo-hosted
- * (or long-running Node) service. That is the HTTP/WSS split the architecture
- * draws on purpose (see docs/plans/sync-gateway-audit-log-architecture.md).
- *
- * The package owns this MOUNT PRIMITIVE; the host owns the infra-bound app it
- * wraps (the Hono app holding the Hub + routes + auth). Mirrors Better Auth,
- * where `betterAuth()` builds the `.handler` and `toNextJsHandler` just maps it
- * onto the HTTP verbs.
- */
-/**
- * Anything that resolves a Web `Request` to a `Response` — e.g. a Hono app's
- * `.fetch`, a Better-Auth-style `{ handler }`, or a bare function.
- */
-export type AbloFetchHandler = (request: Request) => Response | Promise<Response>;
-/** The shapes `toAbloHandler` accepts: a Hono-style `{ fetch }`, a
- *  `{ handler }`, or a bare `(Request) => Response`. */
-export type AbloHttpApp = {
-    readonly fetch: AbloFetchHandler;
-} | {
-    readonly handler: AbloFetchHandler;
-} | AbloFetchHandler;
-/** The route-handler object a Next.js App Router `route.ts` re-exports. One
- *  handler bound to every method the `[...all]` catch-all may receive. */
-export interface AbloRouteHandlers {
-    readonly GET: AbloFetchHandler;
-    readonly POST: AbloFetchHandler;
-    readonly PATCH: AbloFetchHandler;
-    readonly PUT: AbloFetchHandler;
-    readonly DELETE: AbloFetchHandler;
-    readonly OPTIONS: AbloFetchHandler;
-}
-/**
- * Wrap a configured Ablo HTTP app into Next.js App Router route handlers.
- * Mirrors Better Auth's `toNextJsHandler` — accepts the app's `fetch`/`handler`
- * (or a bare function) and returns one handler per verb.
- */
-export declare function toAbloHandler(app: AbloHttpApp): AbloRouteHandlers;

package/dist/server/next.js

@@ -1,47 +0,0 @@
-/**
- * `@abloatai/ablo/server/next` — mount Ablo's HTTP surface in a consumer's
- * Next.js App Router, the Better-Auth `toNextJsHandler` way:
- *
- * ```ts
- * // app/api/ablo/[...all]/route.ts
- * import { toAbloHandler } from '@abloatai/ablo/server/next';
- * import { ablo } from '@/lib/ablo';        // your configured Ablo HTTP app
- * export const { GET, POST } = toAbloHandler(ablo);
- * ```
- *
- * Ablo's HTTP endpoints (bootstrap / query / the commit fallback) are stateless
- * request→response, so they drop straight into a route handler. The realtime
- * WebSocket channel is deliberately NOT served here — it is a persistent
- * connection a serverless route handler cannot host, and stays an Ablo-hosted
- * (or long-running Node) service. That is the HTTP/WSS split the architecture
- * draws on purpose (see docs/plans/sync-gateway-audit-log-architecture.md).
- *
- * The package owns this MOUNT PRIMITIVE; the host owns the infra-bound app it
- * wraps (the Hono app holding the Hub + routes + auth). Mirrors Better Auth,
- * where `betterAuth()` builds the `.handler` and `toNextJsHandler` just maps it
- * onto the HTTP verbs.
- */
-function resolveFetch(app) {
-    if (typeof app === 'function')
-        return app;
-    if ('fetch' in app)
-        return app.fetch;
-    return app.handler;
-}
-/**
- * Wrap a configured Ablo HTTP app into Next.js App Router route handlers.
- * Mirrors Better Auth's `toNextJsHandler` — accepts the app's `fetch`/`handler`
- * (or a bare function) and returns one handler per verb.
- */
-export function toAbloHandler(app) {
-    const fetch = resolveFetch(app);
-    const handler = (request) => fetch(request);
-    return {
-        GET: handler,
-        POST: handler,
-        PATCH: handler,
-        PUT: handler,
-        DELETE: handler,
-        OPTIONS: handler,
-    };
-}