@abloatai/ablo 0.26.0 → 0.27.0

package/dist/ai-sdk/coordination-context.d.ts

@@ -1,52 +0,0 @@
-/**
- * Coordination context middleware — reads peer claims on the same
- * entity from the sync engine's presence stream and injects a brief
- * coordination note into the prompt before the LLM call.
- *
- * The complement of `claim-broadcast.ts`: that one declares what
- * THIS agent is about to do; this one reads what OTHERS are doing
- * and tells the LLM about it. Together they make multiplayer-with-
- * AI structurally real — the AI knows when a human or another
- * agent is mid-edit and can defer / phrase its work as
- * "while you finish that, I'll …" / suggest waiting / coordinate
- * explicitly.
- *
- * Open-source-clean: depends only on `@ai-sdk/provider` types and
- * the package's own `SyncAgent`. Consumers compose via the AI
- * SDK's `wrapLanguageModel`.
- *
- * Cost: zero extra LLM calls (read happens locally from the agent's
- * cached presence stream — already in memory from the WS subscription).
- * Adds a few sentences to the system prompt (typically <100 tokens)
- * only when peers are actively editing.
- */
-import type { LanguageModelV3Middleware } from '@ai-sdk/provider';
-import type { Ablo } from '../client/Ablo.js';
-import type { SchemaRecord } from '../schema/schema.js';
-import type { ClaimTarget } from '../types/streams.js';
-export type { ClaimTarget };
-export interface CoordinationContextMiddlewareOptions<R extends SchemaRecord = SchemaRecord> {
-    readonly agent: Ablo<R> | null;
-    readonly target: ClaimTarget | null;
-    /**
-     * Optional claimId(s) to exclude from the read — typically this
-     * agent's own active claim so the coordination note doesn't tell
-     * the AI "you yourself are editing this." When middleware is
-     * composed with `claimBroadcastMiddleware` in the standard order,
-     * `transformParams` runs BEFORE the broadcast's `wrapStream`
-     * declares its claim, so the agent's own claim isn't yet in the
-     * cached presence and self-filtering isn't needed. The hook is
-     * here for callers that compose differently or for fleet
-     * coordination (filter sibling worker claims).
-     */
-    readonly excludeClaimIds?: readonly string[];
-}
-/**
- * Build the middleware. When `agent` or `target` is null, returns a
- * pass-through.
- *
- * Generic over the schema record — see `claimBroadcastMiddleware`
- * for why `Ablo<S>` and `Ablo<SchemaRecord>` aren't structurally
- * assignable.
- */
-export declare function coordinationContextMiddleware<R extends SchemaRecord = SchemaRecord>(options: CoordinationContextMiddlewareOptions<R>): LanguageModelV3Middleware;

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/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_RESIDENCY} 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_RESIDENCY = {
-    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/read-config.d.ts

@@ -1,67 +0,0 @@
-/**
- * `@abloatai/ablo/server` — per-model READ configuration the bootstrap
- * reader consumes. Host-side type config (physical table, tenancy column,
- * parent-scoping) — pure data, no `postgres` — so it lives in the server
- * subpath and feeds the `DataAdapter` read contract. The SQL that consumes it
- * (the bootstrap query builder) stays host-side.
- */
-/** A field→column mapping with an explicit post-`SELECT *` alias. */
-export interface ColumnOverride {
-    readonly field: string;
-    readonly column: string;
-    readonly alias: string;
-}
-export interface BootstrapModel {
-    name: string;
-    /**
-     * Additional names accepted for request-side lookup/filtering. In DB-canonical
-     * mode `name` stays the physical table name, while aliases cover generated
-     * compatibility names such as `WeatherReports` / `weatherReports`.
-     */
-    aliases?: readonly string[];
-    /**
-     * Schema key used by source endpoints. `name` remains the wire/result model
-     * name, usually the typename; source handlers are keyed by the developer's
-     * schema object (`files`, `slideLayers`, ...).
-     */
-    sourceModel?: string;
-    table: string;
-    syncGroups?: string[];
-    enabled?: boolean;
-    /** Max rows to return. Omit for unlimited. Maps to schema's bootstrapLimit. */
-    limit?: number;
-    /** SQL ORDER BY clause. Default: 'id'. Maps to schema's bootstrapOrderBy. */
-    orderBy?: string;
-    /** Whether the table has organization_id. Default: true. */
-    orgScoped?: boolean;
-    /** Physical tenancy column (default `organization_id`, configurable per model). */
-    orgColumn?: string;
-    /**
-     * Parent-table scoping for rows with no `organization_id` column. Mirrors the
-     * schema's `scopedVia` option. When set, the bootstrap query emits:
-     *
-     *   WHERE <table>.<localKey> IN
-     *     (SELECT <parentKey> FROM <parentTable> WHERE <parentOrgColumn> = $1)
-     *
-     * Applied IN ADDITION TO whatever `orgScoped` dictates — so a table can have
-     * its own `organization_id` AND further narrow via a parent, though the common
-     * use is `orgScoped: false` + `scopedVia` on tables that lack the column.
-     */
-    scopedVia?: {
-        localKey: string;
-        parentTable: string;
-        parentKey?: string;
-        parentOrgColumn?: string;
-    };
-    /** Client-facing field name → physical DB column for declared fields. */
-    fieldColumns?: Record<string, string>;
-    /** Physical-column aliases needed after SELECT * for `.from(...)` fields. */
-    columnOverrides?: readonly ColumnOverride[];
-    /**
-     * Physical columns the schema declares as `json` (`field.json()`). A json
-     * field stored in a TEXT column comes back from `row_to_json` as a serialized
-     * string; the bootstrap re-parses these so the wire is the canonical object
-     * regardless of physical column type (jsonb returns objects natively → no-op).
-     */
-    jsonColumns?: readonly string[];
-}

package/dist/server/read-config.js

@@ -1,8 +0,0 @@
-/**
- * `@abloatai/ablo/server` — per-model READ configuration the bootstrap
- * reader consumes. Host-side type config (physical table, tenancy column,
- * parent-scoping) — pure data, no `postgres` — so it lives in the server
- * subpath and feeds the `DataAdapter` read contract. The SQL that consumes it
- * (the bootstrap query builder) stays host-side.
- */
-export {};

package/dist/server/storage-mode.d.ts

@@ -1,8 +0,0 @@
-/** See module note — host-deployment vocabulary, never customer-facing. */
-export declare const storageModeSchema: z.ZodEnum<{
-    source: "source";
-    hosted: "hosted";
-    selfHosted: "selfHosted";
-}>;
-/** See module note — host-deployment vocabulary, never customer-facing. */
-export type StorageMode = z.infer<typeof storageModeSchema>;

package/dist/server/storage-mode.js

@@ -1,28 +0,0 @@
-/**
- * `@abloatai/ablo/server` — the storage-mode vocabulary the `DataAdapter`
- * contract supports. Analogous to Better Auth's adapter `id`/`adapterId`: a
- * diagnostic discriminator on the adapter, NOT a routing switch (routing goes
- * through the resolver/factory). The package owns this enum so the contract and
- * every host adapter agree on the closed set:
- *   - `hosted`     — Ablo's control-plane database.
- *   - `selfHosted` — the customer's database, same execution path as hosted.
- *   - `source`     — a customer-owned endpoint (credentialless ingestion).
- *
- * Deployment topology, not product vocabulary. Customers never see a
- * "storage mode" — their story is `ablo connect` (WAL replication: reads tail
- * their database's logical-replication stream, the data stays in their DB)
- * with the signed `dataSource()` endpoint as the marked fallback (ADR 0002,
- * docs/decisions/0002-read-path-logical-replication-vs-data-hosting.md).
- * The `databaseUrl` dial-in that this enum's `selfHosted` arm serves is
- * DEPRECATED pending the WAL read cutover — do not build on it.
- * This export exists for the sync-server host only.
- *
- * NOT `@internal`-tagged: tsconfig.build.json sets `stripInternal`, and these
- * symbols are re-exported by `server/index.ts` — tagging them strips them from
- * the emitted d.ts, leaving an empty `export {}` module behind a live
- * re-export. `skipLibCheck` masks the break and `StorageMode` silently
- * degrades to an error-any for every dist consumer (the sync-server host).
- */
-import { z } from 'zod';
-/** See module note — host-deployment vocabulary, never customer-facing. */
-export const storageModeSchema = z.enum(['hosted', 'source', 'selfHosted']);

package/dist/source/connector-protocol.d.ts

@@ -1,159 +0,0 @@
-/**
- * Data Source reverse-channel wire protocol.
- *
- * The `commit`/`load`/`list` leg of Data Source mode is normally an INBOUND
- * webhook (Ablo Cloud → your HTTPS endpoint). That requires a public URL, so it
- * doesn't work on `localhost` or inside a locked-down VPC with no inbound path.
- *
- * The reverse channel inverts the direction: the customer's connector dials OUT
- * to Ablo Cloud over a WebSocket and serves those same requests over the open
- * socket — the Stripe-CLI `stripe listen` pattern. This module defines the
- * frames that travel over that socket.
- *
- * Trust model is unchanged. A `request` frame carries the SAME Standard Webhooks
- * signature headers (`webhook-id` / `webhook-timestamp` / `webhook-signature`)
- * and the SAME raw body Ablo would have POSTed, so the connector verifies it
- * through the unchanged `verifyAbloSourceRequest`. Only the transport differs.
- *
- * Frames are validated with zod at the boundary (matching `contract.ts`): a
- * malformed frame is rejected at the edge, and every wire type is inferred from
- * one schema so the two sides can never silently drift.
- */
-import { z } from 'zod';
-/**
- * Wire-protocol version. Bumped on any breaking frame-shape change so an old
- * connector talking to a new server (or vice-versa) fails fast at `register`
- * instead of misparsing a frame mid-stream.
- */
-export declare const SOURCE_CONNECTOR_PROTOCOL_VERSION = 1;
-/** Path the connector dials. Appended to the connector's `baseURL`. */
-export declare const SOURCE_CONNECTOR_WS_PATH = "/v1/source/listen";
-/**
- * Negotiated WebSocket subprotocol that marks a reverse-channel source
- * connector (vs. the SDK sync client's `ablo.sync.v1`). The server selects and
- * echoes back ONLY this value, never the token-bearing subprotocol — keeping the
- * credential out of ALB / proxy logs exactly like the sync socket does.
- */
-export declare const WS_SOURCE_SUBPROTOCOL = "ablo.source.v1";
-/**
- * Build the `Sec-WebSocket-Protocol` list a connector offers: the source
- * protocol plus the bearer credential (`ablo.bearer.<apiKey>`). Browsers can't
- * set an `Authorization` header on a WebSocket, so the API key rides as a
- * subprotocol — the same mechanism the SDK sync client uses, read server-side by
- * the shared `extractBearer`.
- */
-export declare function sourceConnectorSubprotocols(apiKey: string): string[];
-/**
- * Connector → server, first frame after the socket opens and authenticates.
- * Auth and source resolution happen at the WS handshake from the API key; this
- * frame only carries protocol negotiation + advisory metadata.
- */
-export declare const registerFrameSchema: z.ZodObject<{
-    type: z.ZodLiteral<"register">;
-    protocolVersion: z.ZodNumber;
-    client: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export type RegisterFrame = z.infer<typeof registerFrameSchema>;
-/**
- * Server → connector, acknowledges a successful `register`. Echoes the resolved
- * source identity so the connector can log/verify which source it is serving.
- */
-export declare const readyFrameSchema: z.ZodObject<{
-    type: z.ZodLiteral<"ready">;
-    protocolVersion: z.ZodNumber;
-    sourceId: z.ZodOptional<z.ZodString>;
-    organizationId: z.ZodOptional<z.ZodString>;
-    environment: z.ZodOptional<z.ZodEnum<{
-        production: "production";
-        sandbox: "sandbox";
-    }>>;
-}, z.core.$strip>;
-export type ReadyFrame = z.infer<typeof readyFrameSchema>;
-/**
- * Server → connector, one drained `commit`/`load`/`list` request. `headers` and
- * `body` are byte-identical to what the inbound webhook path would have sent —
- * the connector replays them into a synthesized `Request` so the unchanged
- * handler verifies the signature exactly as in production.
- */
-export declare const requestFrameSchema: z.ZodObject<{
-    type: z.ZodLiteral<"request">;
-    id: z.ZodString;
-    method: z.ZodLiteral<"POST">;
-    url: z.ZodString;
-    headers: z.ZodRecord<z.ZodString, z.ZodString>;
-    body: z.ZodString;
-}, z.core.$strip>;
-export type RequestFrame = z.infer<typeof requestFrameSchema>;
-/**
- * Connector → server, the handler's `Response` for one `request`. The server
- * resolves the pending request keyed by `id` and feeds `status`/`body` back to
- * the `SourceClient` as if an HTTP response had returned.
- */
-export declare const responseFrameSchema: z.ZodObject<{
-    type: z.ZodLiteral<"response">;
-    id: z.ZodString;
-    status: z.ZodNumber;
-    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    body: z.ZodString;
-}, z.core.$strip>;
-export type ResponseFrame = z.infer<typeof responseFrameSchema>;
-/**
- * Either direction, out-of-band failure not tied to a single request body
- * (auth rejected, unsupported protocol version, malformed frame). When `id` is
- * present the error pertains to that pending request and fails it; otherwise it
- * is a connection-level error.
- */
-export declare const errorFrameSchema: z.ZodObject<{
-    type: z.ZodLiteral<"error">;
-    id: z.ZodOptional<z.ZodString>;
-    code: z.ZodString;
-    message: z.ZodString;
-}, z.core.$strip>;
-export type ErrorFrame = z.infer<typeof errorFrameSchema>;
-export declare const connectorFrameSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    type: z.ZodLiteral<"register">;
-    protocolVersion: z.ZodNumber;
-    client: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"ready">;
-    protocolVersion: z.ZodNumber;
-    sourceId: z.ZodOptional<z.ZodString>;
-    organizationId: z.ZodOptional<z.ZodString>;
-    environment: z.ZodOptional<z.ZodEnum<{
-        production: "production";
-        sandbox: "sandbox";
-    }>>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"request">;
-    id: z.ZodString;
-    method: z.ZodLiteral<"POST">;
-    url: z.ZodString;
-    headers: z.ZodRecord<z.ZodString, z.ZodString>;
-    body: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"response">;
-    id: z.ZodString;
-    status: z.ZodNumber;
-    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    body: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"error">;
-    id: z.ZodOptional<z.ZodString>;
-    code: z.ZodString;
-    message: z.ZodString;
-}, z.core.$strip>], "type">;
-export type ConnectorFrame = z.infer<typeof connectorFrameSchema>;
-/** Thrown when an incoming frame fails to parse or validate. */
-export declare class ConnectorProtocolError extends Error {
-    readonly code = "source_connector_protocol_error";
-    constructor(message: string);
-}
-/** Serialize a frame for transmission. */
-export declare function encodeFrame(frame: ConnectorFrame): string;
-/**
- * Parse + validate an incoming frame. Accepts the string or binary payloads the
- * `ws` library / WebSocket `message` events deliver. Throws
- * `ConnectorProtocolError` on any malformed or unknown frame so callers can
- * reject the connection rather than act on garbage.
- */
-export declare function decodeFrame(raw: string | ArrayBuffer | Uint8Array): ConnectorFrame;