@abloatai/ablo 0.36.0 → 0.37.0

package/dist/transaction/wire/feedEvent.d.ts

@@ -1,204 +0,0 @@
-/**
- * What `GET /v1/logs` returns: one envelope, two arms.
- *
- * The feed answers two questions that a caller without a socket cannot
- * otherwise ask — "what changed" and "who is working on what" — and it answers
- * them through one endpoint, one envelope, and one cursor grammar rather than
- * growing a second feed with its own pagination dialect beside the first.
- *
- * The arms stay separately sequenced. A claim is a lease, not a settled fact,
- * and putting one into the log that clients materialize rows from — and that
- * WAL-echo promotion and compaction operate over — would make a claim-churn
- * storm indistinguishable from committed change. They share a reading, not a
- * sequence; {@link FeedCursor} is what carries both positions.
- */
-import { z } from 'zod';
-import { type LogEvent } from './accountResponses.js';
-import { type ClaimEvent } from './claimEvent.js';
-import { type ListEnvelope } from './listEnvelope.js';
-/**
- * One entry, from either source. Discriminated on `object`, so a consumer
- * reading an arm it does not know still parses the page and can skip the entry
- * — which is what lets the claim arm be added to a running feed at all.
- */
-export declare const feedEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    object: z.ZodLiteral<"log_event">;
-    id: z.ZodNumber;
-    at: z.ZodString;
-    model: z.ZodString;
-    op: z.ZodEnum<{
-        update: "update";
-        visible: "visible";
-        create: "create";
-        delete: "delete";
-        archive: "archive";
-        revive: "revive";
-        group_added: "group_added";
-        group_removed: "group_removed";
-    }>;
-    recordId: z.ZodString;
-    actor: z.ZodNullable<z.ZodString>;
-}, z.core.$strip>, z.ZodReadonly<z.ZodObject<{
-    target: z.ZodReadonly<z.ZodObject<{
-        model: z.ZodString;
-        id: z.ZodString;
-        path: z.ZodOptional<z.ZodString>;
-        range: z.ZodOptional<z.ZodObject<{
-            startLine: z.ZodNumber;
-            endLine: z.ZodNumber;
-            startColumn: z.ZodOptional<z.ZodNumber>;
-            endColumn: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>>;
-        field: z.ZodOptional<z.ZodString>;
-        fields: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
-        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, z.core.$strip>>;
-    description: z.ZodString;
-    expiresAt: z.ZodNumber;
-    onBehalfOfId: z.ZodNullable<z.ZodString>;
-    onBehalfOfKind: z.ZodNullable<z.ZodPreprocess<z.ZodEnum<{
-        user: "user";
-        agent: "agent";
-        system: "system";
-    }>>>;
-    capabilityId: z.ZodNullable<z.ZodString>;
-    fenceToken: z.ZodOptional<z.ZodNumber>;
-    position: z.ZodOptional<z.ZodNumber>;
-    participantKind: z.ZodPreprocess<z.ZodEnum<{
-        user: "user";
-        agent: "agent";
-        system: "system";
-    }>>;
-    actor: z.ZodString;
-    object: z.ZodLiteral<"claim_event">;
-    seq: z.ZodNumber;
-    at: z.ZodString;
-    claimId: z.ZodString;
-    status: z.ZodEnum<{
-        active: "active";
-        committed: "committed";
-        expired: "expired";
-        canceled: "canceled";
-        queued: "queued";
-    }>;
-}, z.core.$strip>>], "object">;
-export type FeedEvent = LogEvent | ClaimEvent;
-/** `GET /v1/logs` — the canonical list envelope over the feed. */
-export declare const logListResponseSchema: z.ZodObject<{
-    object: z.ZodLiteral<"list">;
-    data: z.ZodReadonly<z.ZodArray<z.ZodType<{
-        object: "log_event";
-        id: number;
-        at: string;
-        model: string;
-        op: "update" | "visible" | "create" | "delete" | "archive" | "revive" | "group_added" | "group_removed";
-        recordId: string;
-        actor: string | null;
-    } | Readonly<{
-        target: Readonly<{
-            model: string;
-            id: string;
-            path?: string | undefined;
-            range?: {
-                startLine: number;
-                endLine: number;
-                startColumn?: number | undefined;
-                endColumn?: number | undefined;
-            } | undefined;
-            field?: string | undefined;
-            fields?: readonly string[] | undefined;
-            meta?: Record<string, unknown> | undefined;
-        }>;
-        description: string;
-        expiresAt: number;
-        onBehalfOfId: string | null;
-        onBehalfOfKind: "user" | "agent" | "system" | null;
-        capabilityId: string | null;
-        participantKind: "user" | "agent" | "system";
-        actor: string;
-        object: "claim_event";
-        seq: number;
-        at: string;
-        claimId: string;
-        status: "active" | "committed" | "expired" | "canceled" | "queued";
-        fenceToken?: number | undefined;
-        position?: number | undefined;
-    }>, unknown, z.core.$ZodTypeInternals<{
-        object: "log_event";
-        id: number;
-        at: string;
-        model: string;
-        op: "update" | "visible" | "create" | "delete" | "archive" | "revive" | "group_added" | "group_removed";
-        recordId: string;
-        actor: string | null;
-    } | Readonly<{
-        target: Readonly<{
-            model: string;
-            id: string;
-            path?: string | undefined;
-            range?: {
-                startLine: number;
-                endLine: number;
-                startColumn?: number | undefined;
-                endColumn?: number | undefined;
-            } | undefined;
-            field?: string | undefined;
-            fields?: readonly string[] | undefined;
-            meta?: Record<string, unknown> | undefined;
-        }>;
-        description: string;
-        expiresAt: number;
-        onBehalfOfId: string | null;
-        onBehalfOfKind: "user" | "agent" | "system" | null;
-        capabilityId: string | null;
-        participantKind: "user" | "agent" | "system";
-        actor: string;
-        object: "claim_event";
-        seq: number;
-        at: string;
-        claimId: string;
-        status: "active" | "committed" | "expired" | "canceled" | "queued";
-        fenceToken?: number | undefined;
-        position?: number | undefined;
-    }>, unknown>>>>;
-    has_more: z.ZodBoolean;
-    next_cursor: z.ZodNullable<z.ZodString>;
-}, z.core.$strip>;
-export type LogListResponse = ListEnvelope<FeedEvent>;
-/**
- * The query string on `GET /v1/logs`.
- *
- * Values arrive as strings, so this describes the wire spelling rather than the
- * parsed result — the same reason {@link listQuerySchema} does.
- *
- * Scope is NOT here and never will be: the plane, the organization and the sync
- * groups all come off the credential. A caller cannot widen what it sees by
- * asking, which is what makes this feed safe to hand an agent.
- */
-export declare const logQuerySchema: z.ZodObject<{
-    after: z.ZodOptional<z.ZodString>;
-    limit: z.ZodOptional<z.ZodString>;
-    model: z.ZodOptional<z.ZodString>;
-    op: z.ZodOptional<z.ZodEnum<{
-        update: "update";
-        visible: "visible";
-        create: "create";
-        delete: "delete";
-        archive: "archive";
-        revive: "revive";
-        group_added: "group_added";
-        group_removed: "group_removed";
-    }>>;
-    since: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export type LogQuery = z.infer<typeof logQuerySchema>;
-/**
- * The claim arm has no producer yet: claim transitions are broadcast today and
- * recorded nowhere, so there is no sequence to read `seq` from. Until that log
- * exists the route emits only `log_event`s, and there is deliberately NO
- * request parameter for selecting arms — a knob that cannot be honoured is how
- * a contract comes to describe a server that does not exist.
- *
- * What is here is the definition the producer will fill: the union parses
- * today's pages unchanged, and the cursor already carries the second position.
- */

package/dist/transaction/wire/feedEvent.js

@@ -1,65 +0,0 @@
-/**
- * What `GET /v1/logs` returns: one envelope, two arms.
- *
- * The feed answers two questions that a caller without a socket cannot
- * otherwise ask — "what changed" and "who is working on what" — and it answers
- * them through one endpoint, one envelope, and one cursor grammar rather than
- * growing a second feed with its own pagination dialect beside the first.
- *
- * The arms stay separately sequenced. A claim is a lease, not a settled fact,
- * and putting one into the log that clients materialize rows from — and that
- * WAL-echo promotion and compaction operate over — would make a claim-churn
- * storm indistinguishable from committed change. They share a reading, not a
- * sequence; {@link FeedCursor} is what carries both positions.
- */
-import { z } from 'zod';
-import { logEventSchema, logOpSchema } from './accountResponses.js';
-import { claimEventSchema } from './claimEvent.js';
-import { listEnvelopeSchema } from './listEnvelope.js';
-/**
- * One entry, from either source. Discriminated on `object`, so a consumer
- * reading an arm it does not know still parses the page and can skip the entry
- * — which is what lets the claim arm be added to a running feed at all.
- */
-export const feedEventSchema = z.discriminatedUnion('object', [
-    logEventSchema,
-    claimEventSchema,
-]);
-/** `GET /v1/logs` — the canonical list envelope over the feed. */
-export const logListResponseSchema = listEnvelopeSchema(feedEventSchema);
-/**
- * The query string on `GET /v1/logs`.
- *
- * Values arrive as strings, so this describes the wire spelling rather than the
- * parsed result — the same reason {@link listQuerySchema} does.
- *
- * Scope is NOT here and never will be: the plane, the organization and the sync
- * groups all come off the credential. A caller cannot widen what it sees by
- * asking, which is what makes this feed safe to hand an agent.
- */
-export const logQuerySchema = z.object({
-    /**
-     * The `next_cursor` from the previous page, copied back unchanged. Omit it to
-     * start from the most recent entries — this is a tail, so the first page is
-     * the end of the log and `after` walks forward from there.
-     */
-    after: z.string().optional(),
-    /** Entries per page. Clamped server-side; the default is a short tail. */
-    limit: z.string().optional(),
-    /** Only this model's entries. */
-    model: z.string().optional(),
-    /** Only this kind of change. */
-    op: logOpSchema.optional(),
-    /** Only entries at or after this ISO 8601 timestamp. */
-    since: z.string().optional(),
-});
-/**
- * The claim arm has no producer yet: claim transitions are broadcast today and
- * recorded nowhere, so there is no sequence to read `seq` from. Until that log
- * exists the route emits only `log_event`s, and there is deliberately NO
- * request parameter for selecting arms — a knob that cannot be honoured is how
- * a contract comes to describe a server that does not exist.
- *
- * What is here is the definition the producer will fill: the union parses
- * today's pages unchanged, and the cursor already carries the second position.
- */

package/dist/transaction/wire/frames.d.ts

@@ -1,194 +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. Zod schemas are the definition site and every TypeScript
- * shape is inferred from them. Changing any schema in this file changes the
- * wire contract and requires the client and server to update together.
- */
-import { z } from 'zod';
-import type { MutationResultMessageWire } from './commit.js';
-/**
- * A single operation within a commit batch and its authoritative runtime
- * validator. Each operation is the smallest unit the server applies atomically
- * — one create, update, delete, archive, or unarchive against one model row.
- * 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`. The TypeScript type is inferred from this schema so
- * the runtime and compile-time contracts have one definition site.
- */
-export declare const wireCommitOperationSchema: 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>;
-export type WireCommitOperation = z.infer<typeof wireCommitOperationSchema>;
-/**
- * @deprecated Renamed to {@link WireCommitOperation} — coordination/schema owns
- * the base `CommitOperation`; this is the wire-extended form, and the two are
- * different types that shared one name. Removed in 0.36.0.
- */
-export type CommitOperation = WireCommitOperation;
-/** @deprecated Renamed to {@link wireCommitOperationSchema}. Removed in 0.36.0. */
-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>;
-/**
- * The authoritative payload schema for a client-to-server commit frame. It
- * checks every field the server acts on — `operations`, `clientTxId`, and
- * `reads` — validating each operation with {@link wireCommitOperationSchema} and
- * each premise entry with the shared {@link readDependencySchema}.
- */
-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;
-    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.ZodReadonly<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<{
-        id: z.ZodString;
-        model: 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>;
-/** A client-to-server frame that asks the server to commit a batch atomically. */
-export declare const commitMessageSchema: z.ZodObject<{
-    type: z.ZodLiteral<"commit">;
-    payload: 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;
-        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.ZodReadonly<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<{
-            id: z.ZodString;
-            model: 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>;
-}, z.core.$strip>;
-export type CommitMessage = z.infer<typeof commitMessageSchema>;
-/**
- * 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/transaction/wire/frames.js

@@ -1,50 +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. Zod schemas are the definition site and every TypeScript
- * shape is inferred from them. Changing any schema 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';
-// ── Client → Server ────────────────────────────────────────────────────────
-/**
- * A single operation within a commit batch and its authoritative runtime
- * validator. Each operation is the smallest unit the server applies atomically
- * — one create, update, delete, archive, or unarchive against one model row.
- * 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`. The TypeScript type is inferred from this schema so
- * the runtime and compile-time contracts have one definition site.
- */
-export const wireCommitOperationSchema = coordinationCommitOperationSchema.extend({
-    bypass: z.boolean().nullish(),
-});
-/** @deprecated Renamed to {@link wireCommitOperationSchema}. Removed in 0.36.0. */
-export const commitOperationSchema = wireCommitOperationSchema;
-/**
- * The authoritative payload schema for a client-to-server commit frame. It
- * checks every field the server acts on — `operations`, `clientTxId`, and
- * `reads` — validating each operation with {@link wireCommitOperationSchema} and
- * each premise entry with the shared {@link readDependencySchema}.
- */
-export const commitPayloadSchema = z.object({
-    operations: z.array(wireCommitOperationSchema),
-    clientTxId: z.string(),
-    reads: z.array(readDependencySchema).nullish(),
-    track: z.array(trackDependencySchema).nullish(),
-});
-/** A client-to-server frame that asks the server to commit a batch atomically. */
-export const commitMessageSchema = z.object({
-    type: z.literal('commit'),
-    payload: commitPayloadSchema,
-});