@abloatai/ablo 0.34.0 → 0.35.0

package/dist/schema/openapi.d.ts

@@ -1,29 +0,0 @@
-/**
- * Generates an OpenAPI 3.1 specification from a pushed schema, so the API reference
- * describes your own models rather than a fixed set. The API surface is the schema:
- * defining a `task` model is what makes `/v1/models/task` exist. This walks each
- * model's `fields` (the introspectable {@link FieldMeta}) and emits, per model, the
- * CRUD and coordination routes the API serves:
- *   GET/POST   /v1/models/{model}
- *   GET/PATCH/DELETE /v1/models/{model}/{id}
- *   POST/DELETE      /v1/models/{model}/{id}/claim
- *   POST            /v1/models/{model}/{id}/claim/heartbeat
- *   POST            /v1/models/{model}/{id}/claim/reorder
- * plus POST /v1/commits. Authentication is a single Bearer scheme, your API key.
- *
- * Feed it into codegen (for example `ablo openapi > openapi.json`) or serve it
- * directly; the return value is a plain JSON-serializable object.
- */
-import type { Schema, SchemaRecord } from './schema.js';
-/** Options for {@link schemaToOpenApi} — the metadata stamped into the generated spec. */
-export interface SchemaToOpenApiOptions {
-    /** Spec title. Default `"Ablo API"`. */
-    readonly title?: string;
-    /** Spec version. Default `"1.0.0"`. */
-    readonly version?: string;
-    /** API base URL. Default `"https://api.abloatai.com/api"`. */
-    readonly serverUrl?: string;
-}
-type Json = Record<string, unknown>;
-export declare function schemaToOpenApi<S extends SchemaRecord>(schema: Schema<S>, options?: SchemaToOpenApiOptions): Json;
-export {};

package/dist/schema/openapi.js

@@ -1,124 +0,0 @@
-// Pulled from the endpoints module to keep this schema file free of the client's
-// error-handling and credential dependencies.
-import { ABLO_HOSTED_HTTP_BASE_URL } from '../client/hostedEndpoints.js';
-function fieldSchema(f) {
-    switch (f.type) {
-        case 'number':
-            return { type: 'number' };
-        case 'boolean':
-            return { type: 'boolean' };
-        case 'date':
-            return { type: 'string', format: 'date-time' };
-        case 'enum':
-            return f.enumValues ? { type: 'string', enum: [...f.enumValues] } : { type: 'string' };
-        case 'json':
-            return { type: 'object', additionalProperties: true };
-        case 'string':
-        default:
-            return { type: 'string' };
-    }
-}
-const pascal = (s) => s.charAt(0).toUpperCase() + s.slice(1);
-const idParam = () => ({ name: 'id', in: 'path', required: true, schema: { type: 'string' } });
-const jsonBody = (schema) => ({
-    required: true,
-    content: { 'application/json': { schema } },
-});
-const jsonResp = (description, schema) => ({
-    description,
-    content: { 'application/json': { schema } },
-});
-const commitReceipt = () => jsonResp('Commit receipt', {
-    type: 'object',
-    properties: {
-        object: { type: 'string', enum: ['commit_receipt'] },
-        clientTxId: { type: 'string' },
-        serverTxId: { type: 'string' },
-        success: { type: 'boolean' },
-        lastSyncId: { type: 'integer' },
-    },
-});
-export function schemaToOpenApi(schema, options = {}) {
-    const models = schema.models;
-    const paths = {};
-    const schemas = {};
-    for (const [key, def] of Object.entries(models)) {
-        const ref = { $ref: `#/components/schemas/${pascal(key)}` };
-        const properties = { id: { type: 'string' } };
-        const required = ['id'];
-        const createProps = {};
-        for (const [fname, fmeta] of Object.entries(def.fields)) {
-            const fs = fieldSchema(fmeta);
-            properties[fname] = fs;
-            createProps[fname] = fs;
-            if (!fmeta.isOptional)
-                required.push(fname);
-        }
-        schemas[pascal(key)] = { type: 'object', properties, required };
-        const createBody = jsonBody({ type: 'object', properties: createProps });
-        paths[`/v1/models/${key}`] = {
-            get: {
-                tags: [key],
-                summary: `List ${key}`,
-                parameters: [
-                    { name: 'limit', in: 'query', schema: { type: 'integer' } },
-                    { name: 'order_by', in: 'query', schema: { type: 'string' } },
-                    { name: 'order', in: 'query', schema: { type: 'string', enum: ['asc', 'desc'] } },
-                ],
-                responses: {
-                    '200': jsonResp('List of rows', {
-                        type: 'object',
-                        properties: { object: { type: 'string', enum: ['list'] }, data: { type: 'array', items: ref } },
-                    }),
-                },
-            },
-            post: { tags: [key], summary: `Create a ${key}`, requestBody: createBody, responses: { '200': commitReceipt() } },
-        };
-        paths[`/v1/models/${key}/{id}`] = {
-            get: {
-                tags: [key],
-                summary: `Retrieve a ${key}`,
-                parameters: [idParam()],
-                responses: {
-                    '200': jsonResp('The row', {
-                        type: 'object',
-                        properties: { data: ref, stamp: { type: 'integer' } },
-                    }),
-                },
-            },
-            patch: { tags: [key], summary: `Update a ${key}`, parameters: [idParam()], requestBody: createBody, responses: { '200': commitReceipt() } },
-            delete: { tags: [key], summary: `Delete a ${key}`, parameters: [idParam()], responses: { '200': commitReceipt() } },
-        };
-        paths[`/v1/models/${key}/{id}/claim`] = {
-            post: { tags: [key], summary: `Claim a ${key} (acquire lease)`, parameters: [idParam()], responses: { '200': jsonResp('Claim acquired', { type: 'object' }) } },
-            delete: { tags: [key], summary: `Release a ${key} claim`, parameters: [idParam()], responses: { '200': jsonResp('Released', { type: 'object' }) } },
-        };
-        paths[`/v1/models/${key}/{id}/claim/heartbeat`] = {
-            post: { tags: [key], summary: `Heartbeat a held ${key} claim (extend the lease for long-running work)`, parameters: [idParam()], responses: { '200': jsonResp('Lease extended (or queued slot refreshed)', { type: 'object', properties: { object: { type: 'string', enum: ['claim_heartbeat'] }, claimId: { type: 'string' }, status: { type: 'string', enum: ['held', 'queued'] }, expiresAt: { type: 'integer' }, position: { type: 'integer' } } }) } },
-        };
-        paths[`/v1/models/${key}/{id}/claim/reorder`] = {
-            post: { tags: [key], summary: `Reorder the ${key} wait-line (privileged)`, parameters: [idParam()], responses: { '200': jsonResp('Reordered', { type: 'object' }) } },
-        };
-    }
-    paths['/v1/commits'] = {
-        post: { tags: ['commits'], summary: 'Commit a batch of operations atomically', responses: { '200': commitReceipt() } },
-    };
-    return {
-        openapi: '3.1.0',
-        info: {
-            title: options.title ?? 'Ablo API',
-            version: options.version ?? '1.0.0',
-            description: 'Generated from your pushed Ablo schema — these routes are your models. ' +
-                'Authenticate every request with your API key as a Bearer token.',
-        },
-        servers: [{ url: options.serverUrl ?? `${ABLO_HOSTED_HTTP_BASE_URL}/api` }],
-        security: [{ bearerAuth: [] }],
-        components: {
-            securitySchemes: {
-                bearerAuth: { type: 'http', scheme: 'bearer', description: 'Your Ablo API key (sk_… / rk_…).' },
-            },
-            schemas,
-        },
-        paths,
-    };
-}

package/dist/transactions/durableWriteStore.js

@@ -1,30 +0,0 @@
-/**
- * Product-facing persistence contract for writes that must survive a process
- * restart or an ambiguous network response.
- *
- * The engine implements this contract with a transactional outbox internally,
- * but callers should only need to think in terms of pending durable writes.
- */
-import { z } from 'zod';
-import { durableCommitEnvelopeSchema } from './commitEnvelope.js';
-import { durableHttpCommitEnvelopeSchema } from './httpCommitEnvelope.js';
-/** Every write shape that Ablo may ask an injected store to persist. */
-export const pendingWriteSchema = z.union([
-    durableCommitEnvelopeSchema,
-    durableHttpCommitEnvelopeSchema,
-]);
-/** Runtime validation for injected adapters, including JavaScript consumers. */
-export const durableWriteStoreSchema = z.custom((value) => {
-    if (typeof value !== 'object' || value === null)
-        return false;
-    const candidate = value;
-    return (typeof candidate.seal === 'function' &&
-        typeof candidate.list === 'function' &&
-        typeof candidate.remove === 'function');
-}, { message: 'store must implement seal(), list(), and remove()' });
-/** Options for crash-durable `create`, `update`, and `delete` calls. */
-export const durableWritesConfigSchema = z.strictObject({
-    store: durableWriteStoreSchema,
-    /** Separates deployments or workflow lanes that share an authenticated actor. */
-    namespace: z.string().trim().min(1).optional(),
-});

package/dist/utils/json.js

@@ -1,88 +0,0 @@
-/**
- * json.ts — key-order-insensitive comparison helpers for JSON-shaped values.
- *
- * Why this exists as a first-class, exported util:
- *
- * A `field.json()` value may be backed by a Postgres `jsonb` column, and **jsonb
- * does not preserve object key order** (it reorders keys by length, then
- * bytewise, and drops insignificant whitespace — see
- * https://www.postgresql.org/docs/current/datatype-json.html). So a document an
- * app wrote as `{type,text}` streams back in a delta as `{text,type}`: the same
- * value, a different serialization.
- *
- * That bites any app that reconciles an Ablo row against an *external* state
- * container it doesn't control — a rich-text editor (Tiptap/ProseMirror/Slate),
- * a `useState`, a form buffer. The natural guard, `JSON.stringify(remote) ===
- * JSON.stringify(local)`, is silently wrong because the two sides serialize keys
- * in different orders, so it never matches — and the app re-applies the remote
- * value on every render, clobbering in-flight edits and fighting the cursor.
- *
- * The fix is to compare order-insensitively. `deepEqual` does structural
- * equality directly; `stableStringify` produces a canonical string (recursively
- * sorted keys) for when you need a stable cache key / dependency value. The SDK
- * already uses `deepEqual` internally for store-level echo detection; this
- * module makes the same guarantee available to app authors so they don't each
- * reinvent it.
- *
- * (If you need byte-exact key order preserved end-to-end, store the field in a
- * `text` column instead of `jsonb` — Ablo's adaptive codec serializes verbatim
- * there, matching Postgres's `json` type behavior.)
- */
-/** Structural equality for JSON-shaped values (scalars, arrays, plain objects); key order is ignored. */
-export function deepEqual(a, b) {
-    if (a === b)
-        return true;
-    if (a === null || b === null || typeof a !== 'object' || typeof b !== 'object') {
-        return false;
-    }
-    const aArr = Array.isArray(a);
-    if (aArr !== Array.isArray(b))
-        return false;
-    if (aArr) {
-        const av = a;
-        const bv = b;
-        if (av.length !== bv.length)
-            return false;
-        for (let i = 0; i < av.length; i++) {
-            if (!deepEqual(av[i], bv[i]))
-                return false;
-        }
-        return true;
-    }
-    const ao = a;
-    const bo = b;
-    const ak = Object.keys(ao);
-    const bk = Object.keys(bo);
-    if (ak.length !== bk.length)
-        return false;
-    for (const k of ak) {
-        if (!Object.prototype.hasOwnProperty.call(bo, k))
-            return false;
-        if (!deepEqual(ao[k], bo[k]))
-            return false;
-    }
-    return true;
-}
-/**
- * Canonical JSON serialization: recursively sorts object keys so two values that
- * differ only in key order (e.g. a jsonb round-trip) produce the same string.
- * Use this when you need a comparable/cacheable string rather than a boolean —
- * e.g. an echo guard or a `useEffect`/`useMemo` dependency.
- */
-export function stableStringify(value) {
-    return JSON.stringify(sortKeysDeep(value));
-}
-function sortKeysDeep(value) {
-    if (Array.isArray(value))
-        return value.map(sortKeysDeep);
-    if (value && typeof value === 'object') {
-        const source = value;
-        return Object.keys(source)
-            .sort()
-            .reduce((acc, key) => {
-            acc[key] = sortKeysDeep(source[key]);
-            return acc;
-        }, {});
-    }
-    return value;
-}

package/dist/wire/errorEnvelope.d.ts

@@ -1,55 +0,0 @@
-/**
- * The fixed, public-facing message returned for an unclassified 500. A raw
- * `err.message` can carry driver text, connection strings, or stack fragments,
- * so it is never placed on the wire; a caller that needs those details logs the
- * original error server-side before formatting the response.
- */
-export declare const INTERNAL_ERROR_PUBLIC_MESSAGE = "An internal error occurred.";
-/** The canonical error envelope. Every HTTP error response and every structured
- *  frame error carries this exact set of keys, regardless of which route or
- *  transport produced it. */
-export interface ErrorEnvelope {
-    readonly type: string;
-    readonly code?: string;
-    readonly param?: string;
-    readonly message: string;
-    readonly doc_url?: string;
-    readonly request_id?: string;
-    /** Field-level failures collected together, so a single 4xx can report every
-     *  invalid input at once — for example a schema push, a batch commit, or CLI
-     *  argument validation — instead of failing on the first. Use `param` for the
-     *  single-field case. */
-    readonly errors?: readonly {
-        readonly code?: string;
-        readonly message: string;
-        readonly param?: string;
-    }[];
-    /** Additional typed details. {@link AbloError} serialization spreads its
-     *  `details` — such as `missingIds`, `conflicts`, or `retryAfterSeconds` — as
-     *  top-level members here. Ignore any member you do not recognize, so new ones
-     *  can be added without breaking you. */
-    readonly [key: string]: unknown;
-}
-/** Maps an {@link AbloError} subclass name to its default HTTP status. Each
- *  subclass is chosen to match the status — a validation error is a 400, a
- *  permission error a 403 — so a throw site picks the right class and code and
- *  the status follows. An explicit `httpStatus` is supplied only when it
- *  diverges, such as a 404 on the base class or a 503 on a server error. */
-export declare function statusForType(type: string): number;
-/**
- * Converts any thrown value into the canonical {@link ErrorEnvelope} and an HTTP
- * status. A typed {@link AbloError} is serialized through its own `toJSON`, so
- * its code, param, doc_url, and structured details survive, and its status comes
- * from an explicit `httpStatus` or, failing that, {@link statusForType}.
- * Anything else becomes a 500 `internal_error` envelope — never a bare framework
- * "Internal Server Error" body, and never a raw error string leaked onto the
- * wire as an unregistered code.
- *
- * When `requestId` is supplied and the error does not already carry one, it is
- * stamped into the body so the response and the `x-request-id` header agree for
- * support correlation.
- */
-export declare function errorEnvelope(err: unknown, requestId?: string): {
-    body: ErrorEnvelope;
-    status: number;
-};

package/dist/wire/frames.d.ts

@@ -1,197 +0,0 @@
-/**
- * The write-path message shapes for the sync protocol. These cover the frames
- * a client sends to commit work — {@link CommitMessage}, a batch of raw
- * operations — and the server's {@link MutationResultMessage}
- * acknowledgement. The same frames flow over a WebSocket connection and over
- * the HTTP commit endpoint.
- *
- * Both the client and the server import these definitions from here, so the two
- * sides cannot drift. Each interface is paired with a Zod validator
- * ({@link commitOperationSchema}, {@link commitPayloadSchema}) pinned to it at
- * compile time, so the runtime check and the type stay in lockstep. Changing
- * any shape in this file changes the wire contract and requires the client and
- * server to update together.
- */
-import { z } from 'zod';
-import type { OnStaleMode, ReadDependency, TrackDependency } from '../coordination/index.js';
-import type { MutationResultMessageWire } from './commit.js';
-/**
- * A single operation within a {@link CommitMessage} batch. Each operation is
- * the smallest unit the server applies atomically — one create, update,
- * delete, archive, or unarchive against one model row.
- */
-export interface CommitOperation {
-    type: 'CREATE' | 'UPDATE' | 'DELETE' | 'ARCHIVE' | 'UNARCHIVE';
-    model: string;
-    id?: string | null;
-    input?: Record<string, unknown> | null;
-    /**
-     * A client-generated transaction id for this one operation. The server
-     * stamps it onto the `sync_deltas.transaction_id` column so the originating
-     * client can recognize the resulting broadcast as an echo of its own
-     * optimistic write. This is distinct from the batch-level `clientTxId` on
-     * {@link CommitMessage}, which the server uses to deduplicate retried batches.
-     */
-    transactionId?: string | null;
-    /**
-     * A read watermark captured when the client last read this row. The server
-     * checks whether the target has changed since this point; if it has, the
-     * operation's {@link CommitOperation.onStale} mode decides what happens.
-     */
-    readAt?: number | null;
-    /**
-     * What to do when the server detects the row changed since
-     * {@link CommitOperation.readAt}. `'reject'` (the default) fails the
-     * operation with a stale-context error; `'overwrite'` applies the write
-     * regardless; `'notify'` holds the write and returns a
-     * {@link StaleNotification} for the caller to resolve.
-     */
-    onStale?: OnStaleMode | null;
-    /**
-     * Write even when another participant holds a claim on this row. The default
-     * (`false`) rejects the operation with a claimed-entity error while a claim
-     * is held. Setting `bypass` overrides that, and the override is recorded. It
-     * is honored only for participants the claim guard trusts, such as human and
-     * framework identities; a bypass requested by an agent is ignored.
-     */
-    bypass?: boolean | null;
-    /**
-     * The monotonic fencing token of the held claim this write was issued under
-     * ({@link https://martin.kleppmann.com/2016/02/08/how-to-do-distributed-locking.html Kleppmann fencing}).
-     * The server rejects the write if a later holder already advanced this
-     * entity's persisted high-water past the token — closing the "lapsed holder
-     * resumes after its successor came and went" residual that the live-lease
-     * claim guard cannot see. Absent on every unclaimed write.
-     */
-    fenceToken?: number | null;
-}
-/**
- * Runtime validator for {@link CommitOperation}. Both commit transports — the
- * WebSocket `commit` frame and the HTTP `/v1/commits` endpoint — run this check
- * on every operation before it is applied, so a malformed operation is rejected
- * at the edge. It builds on the shared coordination schema, widening `bypass`
- * to also accept `null` so the validator and the interface match exactly. Note
- * that `readAt` must be a number: it feeds the server's stale-check comparison,
- * so a non-numeric watermark is refused here.
- */
-export declare const commitOperationSchema: z.ZodObject<{
-    readAt: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-    onStale: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
-        reject: "reject";
-        overwrite: "overwrite";
-        notify: "notify";
-    }>>>;
-    type: z.ZodEnum<{
-        CREATE: "CREATE";
-        UPDATE: "UPDATE";
-        DELETE: "DELETE";
-        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>>;
-    fenceToken: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-    bypass: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
-}, z.core.$strip>;
-/**
- * A client-to-server frame that asks the server to commit a batch of operations
- * atomically. It carries a list of {@link CommitOperation} entries plus the
- * batch metadata below.
- */
-export interface CommitMessage {
-    type: 'commit';
-    payload: {
-        operations: CommitOperation[];
-        clientTxId: string;
-        /**
-         * Optional lineage id linking this batch to the task that caused it. When
-         * present, the server validates it and records it on the delta's
-         * `caused_by_task_id` column for audit trails; when omitted or `null`, the
-         * batch simply carries no task attribution.
-         */
-        causedByTaskId?: string | null;
-        /**
-         * The reads this batch's writes were premised on. Each entry names either a
-         * specific row (`{ model, id, readAt, fields? }`) or a sync group
-         * (`{ group, readAt }`) that must not have changed since its `readAt`
-         * watermark. The server checks every entry and applies its `onStale`
-         * disposition to the whole batch if one moved. When omitted, only the rows
-         * being written are checked for staleness.
-         */
-        reads?: ReadDependency[] | null;
-        /**
-         * Durable read-dependencies to register for this batch's participant. Each
-         * entry — a row (`{ model, id }`) or a sync group (`{ group }`) — is persisted
-         * and re-checked against every future delta; a later match surfaces a
-         * `StaleNotification` on the participant's next commit. Distinct from `reads`,
-         * which is checked once here and discarded.
-         */
-        track?: TrackDependency[] | null;
-    };
-}
-/**
- * Runtime validator for the payload of {@link CommitMessage}. It checks every
- * field the server acts on — `operations`, `clientTxId`, `causedByTaskId`, and
- * `reads` — validating each operation with {@link commitOperationSchema} and
- * each read dependency with the shared read-dependency schema.
- */
-export declare const commitPayloadSchema: z.ZodObject<{
-    operations: z.ZodArray<z.ZodObject<{
-        readAt: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-        onStale: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
-            reject: "reject";
-            overwrite: "overwrite";
-            notify: "notify";
-        }>>>;
-        type: z.ZodEnum<{
-            CREATE: "CREATE";
-            UPDATE: "UPDATE";
-            DELETE: "DELETE";
-            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>>;
-        fenceToken: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-        bypass: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
-    }, z.core.$strip>>;
-    clientTxId: z.ZodString;
-    causedByTaskId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    reads: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-        model: z.ZodString;
-        id: z.ZodString;
-        readAt: z.ZodNumber;
-        fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        onStale: z.ZodOptional<z.ZodEnum<{
-            reject: "reject";
-            overwrite: "overwrite";
-            notify: "notify";
-        }>>;
-    }, z.core.$strip>, z.ZodObject<{
-        group: z.ZodString;
-        readAt: z.ZodNumber;
-        onStale: z.ZodOptional<z.ZodEnum<{
-            reject: "reject";
-            overwrite: "overwrite";
-            notify: "notify";
-        }>>;
-    }, z.core.$strip>]>>>>;
-    track: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-        model: z.ZodString;
-        id: z.ZodString;
-        readAt: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>, z.ZodObject<{
-        group: z.ZodString;
-        readAt: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>]>>>>;
-}, z.core.$strip>;
-/**
- * The server's acknowledgement of a {@link CommitMessage}. Runtime shape and
- * TypeScript type are both owned by `wire/commit.ts`; HTTP, WebSocket, and
- * cached replay no longer maintain parallel receipt declarations.
- */
-export type MutationResultMessage = MutationResultMessageWire;

package/dist/wire/frames.js

@@ -1,49 +0,0 @@
-/**
- * The write-path message shapes for the sync protocol. These cover the frames
- * a client sends to commit work — {@link CommitMessage}, a batch of raw
- * operations — and the server's {@link MutationResultMessage}
- * acknowledgement. The same frames flow over a WebSocket connection and over
- * the HTTP commit endpoint.
- *
- * Both the client and the server import these definitions from here, so the two
- * sides cannot drift. Each interface is paired with a Zod validator
- * ({@link commitOperationSchema}, {@link commitPayloadSchema}) pinned to it at
- * compile time, so the runtime check and the type stay in lockstep. Changing
- * any shape in this file changes the wire contract and requires the client and
- * server to update together.
- */
-import { z } from 'zod';
-// The runtime schema primitives are imported straight from the coordination
-// schema module to keep this file's runtime dependencies limited to Zod.
-import { commitOperationSchema as coordinationCommitOperationSchema, readDependencySchema, trackDependencySchema, } from '../coordination/schema.js';
-/**
- * Runtime validator for {@link CommitOperation}. Both commit transports — the
- * WebSocket `commit` frame and the HTTP `/v1/commits` endpoint — run this check
- * on every operation before it is applied, so a malformed operation is rejected
- * at the edge. It builds on the shared coordination schema, widening `bypass`
- * to also accept `null` so the validator and the interface match exactly. Note
- * that `readAt` must be a number: it feeds the server's stale-check comparison,
- * so a non-numeric watermark is refused here.
- */
-export const commitOperationSchema = coordinationCommitOperationSchema.extend({
-    bypass: z.boolean().nullish(),
-});
-// Pins the schema to the interface: this fails to compile if either side drifts.
-const _commitOperationContract = true;
-void _commitOperationContract;
-/**
- * Runtime validator for the payload of {@link CommitMessage}. It checks every
- * field the server acts on — `operations`, `clientTxId`, `causedByTaskId`, and
- * `reads` — validating each operation with {@link commitOperationSchema} and
- * each read dependency with the shared read-dependency schema.
- */
-export const commitPayloadSchema = z.object({
-    operations: z.array(commitOperationSchema),
-    clientTxId: z.string(),
-    causedByTaskId: z.string().nullish(),
-    reads: z.array(readDependencySchema).nullish(),
-    track: z.array(trackDependencySchema).nullish(),
-});
-// Pins the schema to the payload type: fails to compile if either side drifts.
-const _commitPayloadContract = true;
-void _commitPayloadContract;

package/dist/wire/listEnvelope.js

@@ -1,18 +0,0 @@
-/**
- * Wraps an already-fetched page of rows in the uniform {@link ListEnvelope}.
- *
- * Pagination stays the caller's job — fetch one more row than the limit to
- * decide `hasMore`, and derive the cursor from the last row's sort key. This
- * helper only applies the envelope so no endpoint has to build the shape by
- * hand. The defaults describe a small, unpaginated collection
- * (`has_more: false`, `next_cursor: null`); a paginated endpoint passes both
- * explicitly.
- */
-export function listEnvelope(data, opts = {}) {
-    return {
-        object: 'list',
-        data,
-        has_more: opts.hasMore ?? false,
-        next_cursor: opts.nextCursor ?? null,
-    };
-}