@stateforge-labs/herdr-sdk 0.0.0-stage → 0.3.0

package/dist/herdr/wire/connection.js

@@ -0,0 +1,65 @@
+// Role: one Unix-socket connection to herdr: opens it, writes NDJSON lines, reads lines through the LineSplitter and reports close and error.
+// Informs HERDR-ADR-0016 (W1 one connection per request) and plan 3.1 (connection).
+import { createConnection } from 'node:net';
+import { ErrorText, LINE_SEPARATOR, TEXT_ENCODING } from '../../constants.js';
+import { HerdrTransportError } from '../errors.js';
+import { LineSplitter } from './codec.js';
+export class Connection {
+    socket;
+    constructor(socket) {
+        this.socket = socket;
+    }
+    // Resolves once connected. A failure or a close before connecting rejects with CannotConnect; later failures go to onError
+    // and the close after connecting goes to onClose (exactly once, from the socket's own close event).
+    static open(path, handlers) {
+        return new Promise((resolve, reject) => {
+            const socket = createConnection({ path });
+            const state = { connected: false };
+            socket.setEncoding(TEXT_ENCODING);
+            attachReaders(socket, handlers, state);
+            socket.on('error', (error) => {
+                if (state.connected) {
+                    handlers.onError(error);
+                    return;
+                }
+                reject(cannotConnect(path, error));
+            });
+            socket.on('close', () => {
+                if (!state.connected) {
+                    reject(cannotConnect(path, undefined));
+                }
+            });
+            socket.on('connect', () => {
+                state.connected = true;
+                resolve(new Connection(socket));
+            });
+        });
+    }
+    writeLine(line) {
+        this.socket.write(`${line}${LINE_SEPARATOR}`);
+    }
+    // Half-close: ends the write side only. rpc does not use it: every call destroys its socket on exit (W1).
+    close() {
+        this.socket.end();
+    }
+    destroy() {
+        this.socket.destroy();
+    }
+}
+function cannotConnect(path, cause) {
+    return new HerdrTransportError(ErrorText.CannotConnect(path), { cause });
+}
+// Data becomes lines through a splitter; close is forwarded only once connected. The error listener is attached by open().
+function attachReaders(socket, handlers, state) {
+    const splitter = new LineSplitter();
+    socket.on('data', (chunk) => {
+        for (const line of splitter.push(chunk)) {
+            handlers.onLine(line);
+        }
+    });
+    socket.on('close', () => {
+        if (state.connected) {
+            handlers.onClose();
+        }
+    });
+}

package/dist/herdr/wire/dedicated.d.ts

@@ -0,0 +1,2 @@
+import type { OpenDedicated } from './types.js';
+export declare const openDedicated: OpenDedicated;

package/dist/herdr/wire/dedicated.js

@@ -0,0 +1,238 @@
+// Role: a connection kept open on purpose (a subscription, later a held connection): one request at a time, pushes handed to one listener, and one `ended` that says who closed it.
+// Informs HERDR-ADR-0016 (W1 one request per connection, W2 ack then a held stream of id-less pushes, W3 an id "" reply then EOF is an answer), HERDR-ADR-0007 and plan 3.6; contract in wire/types.ts (OpenDedicated, DedicatedConnection).
+import { CallOutcome, EMPTY_REPLY_ID, ErrorText, WireField } from '../../constants.js';
+import { outcomeOf, reportCall } from './codec.js';
+import { Connection } from './connection.js';
+import { HerdrError, HerdrTransportError } from '../errors.js';
+import { encodeRequest, isErrorEnvelope, isObject } from './codec.js';
+import { nextId } from './codec.js';
+// Texts only this layer words (the shared constants file is read-only for lane P4a).
+const DedicatedText = {
+    Aborted: 'dedicated connection: aborted before it opened',
+    Malformed: 'dedicated connection: unparseable line',
+    SocketError: 'dedicated connection: socket error',
+    RequestPending: (method) => `${method}: another request is still pending on this connection`,
+};
+const NO_CLEANUP = () => undefined;
+export const openDedicated = async function openDedicated(options) {
+    if (options.signal?.aborted === true) {
+        throw new HerdrTransportError(DedicatedText.Aborted);
+    }
+    const session = newSession(options.onCall);
+    const connection = await Connection.open(options.socketPath, handlersFor(session));
+    session.connection = connection;
+    session.detachSignal = listenForAbort(options.signal, () => {
+        finish(session, { byServer: false });
+    });
+    if (session.finished) {
+        connection.destroy();
+    }
+    return connectionOf(session);
+};
+function newSession(onCall) {
+    return {
+        onCall,
+        ending: newEnding(),
+        connection: undefined,
+        pending: undefined,
+        pushListener: undefined,
+        finished: false,
+        detachSignal: NO_CLEANUP,
+    };
+}
+function newEnding() {
+    let settle = NO_CLEANUP;
+    const ended = new Promise((resolve) => {
+        settle = resolve;
+    });
+    return {
+        ended,
+        settle: (end) => {
+            settle(end);
+        },
+    };
+}
+// Socket events feed the session: a line is routed, a server close ends it by server, a socket error ends it with a cause.
+function handlersFor(session) {
+    return {
+        onLine: (line) => {
+            routeLine(session, line);
+        },
+        onClose: () => {
+            finish(session, { byServer: true });
+        },
+        onError: (error) => {
+            finish(session, { byServer: false, cause: new HerdrTransportError(DedicatedText.SocketError, { cause: error }) });
+        },
+    };
+}
+function connectionOf(session) {
+    return {
+        request: requestOn(session),
+        onPush: (listener) => {
+            session.pushListener = listener;
+        },
+        ended: session.ending.ended,
+        destroy: () => {
+            finish(session, { byServer: false });
+        },
+    };
+}
+// Named generic so the request keeps the method's params and result types (ParamsOf, ResultOf).
+function requestOn(session) {
+    return function request(method, params, options = {}) {
+        return sendRequest(session, method, params, options);
+    };
+}
+// Reports the call to onCall once, whatever the outcome; the hook cannot change the result.
+function sendRequest(session, method, params, options) {
+    const startedAt = performance.now();
+    return exchange(session, method, params, options).then((value) => {
+        reportCall(session.onCall, { method, durationMs: performance.now() - startedAt, outcome: CallOutcome.Answered });
+        return typedResult(value);
+    }, (error) => {
+        reportCall(session.onCall, { method, durationMs: performance.now() - startedAt, ...outcomeOf(error) });
+        throw error;
+    });
+}
+// The reply is typed by the method's result; the wire layer trusts herdr's shape here, as rpc does.
+function typedResult(value) {
+    return value;
+}
+function exchange(session, method, params, options) {
+    if (session.finished) {
+        return Promise.reject(new HerdrTransportError(ErrorText.ClosedBeforeResponse(method)));
+    }
+    if (session.pending !== undefined) {
+        return Promise.reject(new HerdrTransportError(DedicatedText.RequestPending(method)));
+    }
+    return new Promise((resolve, reject) => {
+        const pending = {
+            method,
+            requestId: nextId(),
+            resolve,
+            reject,
+            timer: undefined,
+            detachAbort: NO_CLEANUP,
+        };
+        session.pending = pending;
+        pending.detachAbort = listenForAbort(options.signal, () => {
+            failRequest(session, new HerdrTransportError(ErrorText.Aborted(method)));
+        });
+        if (session.pending !== pending) {
+            // An abort that was already on the signal settled the request before it was sent.
+            return;
+        }
+        armTimeout(session, pending, options.timeoutMs);
+        if (!session.finished) {
+            session.connection?.writeLine(encodeRequest(pending.requestId, method, params));
+        }
+    });
+}
+function armTimeout(session, pending, timeoutMs) {
+    if (timeoutMs === undefined) {
+        return;
+    }
+    pending.timer = setTimeout(() => {
+        failRequest(session, new HerdrTransportError(ErrorText.NoResponse(pending.method, timeoutMs), { isTimeout: true }));
+    }, timeoutMs);
+}
+// Reads one line: an unparseable one ends the connection; an id-less one is a push; any other is a reply to the request.
+function routeLine(session, text) {
+    if (session.finished) {
+        return;
+    }
+    const line = parseObject(text);
+    if (line === undefined) {
+        finish(session, { byServer: false, cause: new HerdrTransportError(DedicatedText.Malformed) });
+        return;
+    }
+    if (!(WireField.Id in line)) {
+        session.pushListener?.(line);
+        return;
+    }
+    routeReply(session, line);
+}
+function parseObject(text) {
+    let value;
+    try {
+        value = JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+    return isObject(value) ? value : undefined;
+}
+// The reply carries the request id, or the empty id herdr uses for an unparseable request (W3). Any other id is a stray.
+function routeReply(session, reply) {
+    const pending = session.pending;
+    if (pending === undefined || !isAnswerTo(pending, reply)) {
+        return;
+    }
+    if (isErrorEnvelope(reply)) {
+        const { error } = reply;
+        settleRequest(session, (done) => {
+            done.reject(HerdrError.from(done.method, error));
+        });
+        return;
+    }
+    const result = resultOf(reply);
+    settleRequest(session, (done) => {
+        done.resolve(result);
+    });
+}
+function isAnswerTo(pending, reply) {
+    const id = idOf(reply);
+    return id === pending.requestId || id === EMPTY_REPLY_ID;
+}
+function idOf(reply) {
+    return WireField.Id in reply ? reply[WireField.Id] : undefined;
+}
+function resultOf(reply) {
+    return WireField.Result in reply ? reply[WireField.Result] : undefined;
+}
+// The first exit wins: clears the timer and the abort listener, then runs the outcome once.
+function settleRequest(session, outcome) {
+    const pending = session.pending;
+    if (pending === undefined) {
+        return;
+    }
+    session.pending = undefined;
+    clearTimeout(pending.timer);
+    pending.detachAbort();
+    outcome(pending);
+}
+// A request that timed out or was aborted rejects, and the connection is destroyed: its state after that is unknown.
+function failRequest(session, error) {
+    settleRequest(session, (pending) => {
+        pending.reject(error);
+    });
+    finish(session, { byServer: false, cause: error });
+}
+// Ends the connection once: a request still waiting rejects with the cause (or a closed-before-response error), the socket is destroyed, `ended` resolves.
+function finish(session, end) {
+    if (session.finished) {
+        return;
+    }
+    session.finished = true;
+    session.detachSignal();
+    settleRequest(session, (pending) => {
+        pending.reject(end.cause ?? new HerdrTransportError(ErrorText.ClosedBeforeResponse(pending.method)));
+    });
+    session.connection?.destroy();
+    session.ending.settle(end);
+}
+// Runs the handler when the signal aborts (at once when it already has). Returns the function that removes the listener.
+function listenForAbort(signal, onAbort) {
+    if (signal === undefined) {
+        return NO_CLEANUP;
+    }
+    if (signal.aborted) {
+        onAbort();
+        return NO_CLEANUP;
+    }
+    signal.addEventListener('abort', onAbort, { once: true });
+    return () => {
+        signal.removeEventListener('abort', onAbort);
+    };
+}

package/dist/herdr/wire/push-decoder.d.ts

@@ -0,0 +1,2 @@
+import type { DecodePush } from './types.js';
+export declare const decodePush: DecodePush;

package/dist/herdr/wire/push-decoder.js

@@ -0,0 +1,40 @@
+// Role: decodes one push line into a known frame or an UnknownFrame: the envelope is checked (event is a string, data is present), the data is not (P4).
+// Informs HERDR-ADR-0016 (W2 pushes carry no id, P3 unknown kinds surfaced, P4 envelope-only validation), HERDR-ADR-0007 and plan 3.6; contract in wire/types.ts (DecodePush).
+import { UNKNOWN_EVENT, WireField } from '../../constants.js';
+import { EventKind, SubscriptionEventKind } from '../generated/index.js';
+import { isObject } from './codec.js';
+// Field names and JSON type names this decoder reads (the push envelope has no other fields).
+const PushField = {
+    Data: 'data',
+};
+const JsonType = {
+    String: 'string',
+};
+// Every event name herdr can push, built once from the generated kinds (no hand list).
+const KNOWN_EVENTS = new Set([
+    ...Object.values(EventKind),
+    ...Object.values(SubscriptionEventKind),
+]);
+export const decodePush = function decodePush(line) {
+    if (!hasPushShape(line)) {
+        return undefined;
+    }
+    const event = line[WireField.Event];
+    return isKnownEvent(event) ? toPushFrame(line) : toUnknownFrame(line, event);
+};
+function hasPushShape(line) {
+    return (isObject(line) &&
+        WireField.Event in line &&
+        typeof line[WireField.Event] === JsonType.String &&
+        PushField.Data in line);
+}
+function isKnownEvent(name) {
+    return KNOWN_EVENTS.has(name);
+}
+// The envelope is checked, the data is not (P4): the typed frame is the line itself, the caller trusts herdr's data shape.
+function toPushFrame(line) {
+    return line;
+}
+function toUnknownFrame(line, rawEvent) {
+    return { event: UNKNOWN_EVENT, rawEvent, raw: line };
+}

package/dist/herdr/wire/rpc.d.ts

@@ -0,0 +1,3 @@
+import type { Rpc } from './types.js';
+export type { RpcOptions } from './types.js';
+export declare const rpc: Rpc;

package/dist/herdr/wire/rpc.js

@@ -0,0 +1,141 @@
+// Role: one request, one answer: opens a fresh connection per call, writes the request line, takes the first matching reply and destroys the socket on every exit.
+// Informs HERDR-ADR-0016 (W1 close after every response, W3 id "" accepted, W2 events carry no id), HERDR-ADR-0004 (Promise core), plan 3.1 and 3.3;
+// settle-once, destroy on every exit, late-open destroyed, AbortSignal, and a per-call timing hook.
+import { CallOutcome, EMPTY_REPLY_ID, ErrorText } from '../../constants.js';
+import { outcomeOf, reportCall } from './codec.js';
+import { Connection } from './connection.js';
+import { HerdrError, HerdrTransportError } from '../errors.js';
+import { encodeRequest, isErrorEnvelope, isObject } from './codec.js';
+import { nextId } from './codec.js';
+const NO_CLEANUP = () => undefined;
+export const rpc = async function rpc(opts, method, params) {
+    const startedAt = performance.now();
+    try {
+        const result = await exchange(opts, method, params);
+        reportCall(opts.onCall, { method, durationMs: performance.now() - startedAt, outcome: CallOutcome.Answered });
+        return result;
+    }
+    catch (error) {
+        reportCall(opts.onCall, { method, durationMs: performance.now() - startedAt, ...outcomeOf(error) });
+        throw error;
+    }
+};
+function exchange(opts, method, params) {
+    const requestId = nextId();
+    return new Promise((resolve, reject) => {
+        const call = {
+            method,
+            requestId,
+            requestLine: encodeRequest(requestId, method, params),
+            socketPath: opts.socketPath,
+            resolve,
+            reject,
+            done: false,
+            timer: undefined,
+            detachAbort: NO_CLEANUP,
+            connection: undefined,
+        };
+        armAbort(call, opts.signal);
+        if (call.done) {
+            return;
+        }
+        armTimeout(call, opts.timeoutMs);
+        openAndWrite(call).catch((error) => {
+            failWith(call, error);
+        });
+    });
+}
+// An already-aborted signal settles the call before any connection is opened.
+function armAbort(call, signal) {
+    if (signal === undefined) {
+        return;
+    }
+    const onAbort = () => {
+        failWith(call, new HerdrTransportError(ErrorText.Aborted(call.method)));
+    };
+    if (signal.aborted) {
+        onAbort();
+        return;
+    }
+    signal.addEventListener('abort', onAbort, { once: true });
+    call.detachAbort = () => {
+        signal.removeEventListener('abort', onAbort);
+    };
+}
+function armTimeout(call, timeoutMs) {
+    if (timeoutMs === undefined) {
+        return;
+    }
+    call.timer = setTimeout(() => {
+        failWith(call, new HerdrTransportError(ErrorText.NoResponse(call.method, timeoutMs), { isTimeout: true }));
+    }, timeoutMs);
+}
+async function openAndWrite(call) {
+    const opened = await Connection.open(call.socketPath, {
+        onLine: (line) => {
+            handleLine(call, line);
+        },
+        onClose: () => {
+            failWith(call, new HerdrTransportError(ErrorText.ClosedBeforeResponse(call.method)));
+        },
+        onError: (error) => {
+            failWith(call, new HerdrTransportError(ErrorText.SocketError(call.method), { cause: error }));
+        },
+    });
+    if (call.done) {
+        // The call settled while the socket was connecting (timeout, abort): nothing is written, the socket is closed.
+        opened.destroy();
+        return;
+    }
+    call.connection = opened;
+    opened.writeLine(call.requestLine);
+}
+// Reads one line: a malformed line fails the call, a line for another id is a stray and is ignored.
+function handleLine(call, line) {
+    let parsed;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch (error) {
+        failWith(call, new HerdrTransportError(ErrorText.Unparseable(call.method), { cause: error }));
+        return;
+    }
+    if (!isObject(parsed)) {
+        failWith(call, new HerdrTransportError(ErrorText.Unparseable(call.method)));
+        return;
+    }
+    const envelope = parsed;
+    if (!isAnswerTo(call, envelope)) {
+        return;
+    }
+    if (isErrorEnvelope(envelope)) {
+        failWith(call, HerdrError.from(call.method, envelope.error));
+        return;
+    }
+    answerWith(call, envelope.result);
+}
+// The reply carries the request id, or the empty id herdr uses for an unparseable request (W3).
+function isAnswerTo(call, envelope) {
+    return envelope.id === call.requestId || envelope.id === EMPTY_REPLY_ID;
+}
+// The first exit wins: clears the timer and the abort listener, runs the outcome, then destroys the socket.
+function settle(call, outcome) {
+    if (call.done) {
+        return;
+    }
+    call.done = true;
+    clearTimeout(call.timer);
+    call.detachAbort();
+    outcome();
+    call.connection?.destroy();
+}
+function failWith(call, error) {
+    settle(call, () => {
+        call.reject(error);
+    });
+}
+function answerWith(call, result) {
+    settle(call, () => {
+        call.resolve(result);
+    });
+}

package/dist/herdr/wire/socket-path.d.ts

@@ -0,0 +1,8 @@
+export type EnvMap = Readonly<Record<string, string | undefined>>;
+export interface SocketPathOptions {
+    socketPath?: string | undefined;
+    env?: EnvMap | undefined;
+}
+export declare function defaultSocketPath(env?: EnvMap): string;
+export declare function resolveSocketPath(options: SocketPathOptions): string;
+export declare function assertSocketExists(path: string): void;

package/dist/herdr/wire/socket-path.js

@@ -0,0 +1,23 @@
+// Role: finds the herdr socket: an explicit option, then HERDR_SOCKET, then ~/.config/herdr/herdr.sock; checks that the path is a socket.
+// Informs HERDR-ADR-0003 (layers) and plan 3.3 (socketPath option); explicit option and an existence check.
+import { statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { ErrorText, HerdrEnv, SocketPathPart } from '../../constants.js';
+import { HerdrTransportError } from '../errors.js';
+// The socket path when no explicit option is given. The env is passed in, so tests never read process.env.
+export function defaultSocketPath(env = process.env) {
+    return (env[HerdrEnv.Socket] ??
+        join(env[HerdrEnv.Home] ?? homedir(), SocketPathPart.ConfigDir, SocketPathPart.HerdrDir, SocketPathPart.SocketFile));
+}
+// An explicit socketPath option wins over the environment and the default.
+export function resolveSocketPath(options) {
+    return options.socketPath ?? defaultSocketPath(options.env);
+}
+// Throws a transport error when nothing is a socket at the path (missing path, regular file, directory).
+export function assertSocketExists(path) {
+    const stats = statSync(path, { throwIfNoEntry: false });
+    if (stats?.isSocket() !== true) {
+        throw new HerdrTransportError(ErrorText.NoSocket(path));
+    }
+}

package/dist/herdr/wire/types.d.ts

@@ -0,0 +1,78 @@
+import type { CallOutcome, UNKNOWN_EVENT } from '../../constants.js';
+import type { Method, PushFrame } from '../generated/index.js';
+import type { ParamsOf, ResultOf } from './codec.js';
+export type { ParamsOf, ResultOf } from './codec.js';
+/** One finished call, reported to the onCall hook (plan 3.3). */
+export interface CallEvent {
+    readonly method: Method;
+    readonly durationMs: number;
+    readonly outcome: CallOutcome;
+    /** The server's error code when outcome is Refused. */
+    readonly code?: string;
+}
+/** Timing hook. A hook that throws never changes the call's result (wire/call-hook.ts reportCall). */
+export type OnCall = (event: CallEvent) => void;
+/** Options of one per-request call. */
+export interface RpcOptions {
+    readonly socketPath: string;
+    /** No timeout when undefined. Long-poll callers pass timeout_ms + Timeout.LongPollMarginMs (plan 3.6). */
+    readonly timeoutMs?: number | undefined;
+    /** Abort destroys the connection and rejects with HerdrTransportError. */
+    readonly signal?: AbortSignal | undefined;
+    readonly onCall?: OnCall | undefined;
+}
+/**
+ * One request on a fresh connection, destroyed on every exit path (W1). The reply is the first line whose id is the
+ * request id or "" (W3). Rejects with HerdrError (server envelope) or HerdrTransportError (connect, timeout, abort,
+ * malformed line, close before a reply). Implemented by wire/rpc.ts (P2a).
+ */
+export type Rpc = <M extends Method>(opts: RpcOptions, method: M, params: ParamsOf<M>) => Promise<ResultOf<M>>;
+/** A push line whose `event` this library does not know: surfaced, never dropped, coerced or thrown (HERDR-ADR-0016 P3). */
+export interface UnknownFrame {
+    readonly event: typeof UNKNOWN_EVENT;
+    /** The `event` value herdr sent. */
+    readonly rawEvent: string;
+    /** The whole parsed line. */
+    readonly raw: object;
+}
+/** What a subscription yields: a known frame or an UnknownFrame. */
+export type DecodedFrame = PushFrame | UnknownFrame;
+/**
+ * Turns one parsed push line (an object without `id`) into a frame. Validates the envelope only (P4): `event` must be a
+ * string and `data` present; an unknown `event` gives UnknownFrame. Returns undefined for a line that is not a push
+ * frame shape (the caller fails the subscription with HerdrTransportError). Implemented by wire/push-decoder.ts (P4a).
+ */
+export type DecodePush = (line: object) => DecodedFrame | undefined;
+/** Options of a dedicated connection. */
+export interface DedicatedOptions {
+    readonly socketPath: string;
+    readonly signal?: AbortSignal | undefined;
+    readonly onCall?: OnCall | undefined;
+}
+/** Per-request options on a dedicated connection. */
+export interface DedicatedRequestOptions {
+    readonly timeoutMs?: number | undefined;
+    readonly signal?: AbortSignal | undefined;
+}
+/**
+ * One connection kept open on purpose: by a subscription (W2: ack, then a held stream) or by hold() for class C
+ * methods. Requests are sent one at a time (no pipelining, W1); a line with an id answers the pending request, a line
+ * without id is a push (W2). Implemented by wire/dedicated.ts (P4a); consumed by client/subscribe (P4a) and client/held (P4b).
+ */
+export interface DedicatedConnection {
+    /** Sends one request and waits for the line with its id (or ""). Rejects if another request is still pending. */
+    request<M extends Method>(method: M, params: ParamsOf<M>, options?: DedicatedRequestOptions): Promise<ResultOf<M>>;
+    /** Every line without an id, parsed, in arrival order. Set once, before the first request. */
+    onPush(listener: (line: object) => void): void;
+    /** Resolves when the connection closes for any reason; the value says whether the server closed it. */
+    readonly ended: Promise<DedicatedEnd>;
+    /** Destroys the socket. Idempotent. */
+    destroy(): void;
+}
+/** Why a dedicated connection ended. `byServer` false means destroy() or abort. */
+export interface DedicatedEnd {
+    readonly byServer: boolean;
+    readonly cause?: unknown;
+}
+/** Opens a dedicated connection; rejects with HerdrTransportError when nothing listens at the path. */
+export type OpenDedicated = (options: DedicatedOptions) => Promise<DedicatedConnection>;

package/dist/herdr/wire/types.js

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export { CallOutcome, Overflow, ProtocolPolicy, UNKNOWN_EVENT, WatchKind, PaneSetKind } from './constants.js';
+export { AgentStatus, EventKind, Method, PROTOCOL, ResultTag, SCHEMA_VERSION, ServerCapability, SubscriptionType, } from './herdr/generated/index.js';
+export type { ErrorBody, PushFrame, ResultByTag, Subscription } from './herdr/generated/index.js';
+export { connect } from './herdr/client/connect.js';
+export { watchPaneSet } from './herdr/client/watch-pane-set.js';
+export type { CallOptions, Client, ClientCapabilities, ConnectOptions, ServerInfo, } from './herdr/client/types.js';
+export type { EventSubscription, QueueOptions, Subscribe, SubscribeOptions } from './herdr/client/subscribe.js';
+export type { BackoffPolicy, PaneSetChange, PaneSetSource, PaneSetWatch, Sleep, Watch, WatchChange, WatchFn, WatchOptions, WatchPaneSetOptions, } from './herdr/client/watch.js';
+export type { Hold, HeldConnection, HoldOptions } from './herdr/client/held.js';
+export { HerdrError, HerdrTransportError, ProtocolMismatchError, SubscriptionEnded, UnsupportedByServerError, } from './herdr/errors.js';
+export type { CallEvent, DecodedFrame, OnCall, UnknownFrame } from './herdr/wire/types.js';

package/dist/index.js

@@ -0,0 +1,7 @@
+// Role: the package entry ("."): connect(), errors, generated constants and types, the client and stream types.
+// Informs plan 3.1, 3.3 and 3.6, HERDR-ADR-0003 (entry points) and HERDR-ADR-0017 (contracts); edited only by the integration step.
+export { CallOutcome, Overflow, ProtocolPolicy, UNKNOWN_EVENT, WatchKind, PaneSetKind } from './constants.js';
+export { AgentStatus, EventKind, Method, PROTOCOL, ResultTag, SCHEMA_VERSION, ServerCapability, SubscriptionType, } from './herdr/generated/index.js';
+export { connect } from './herdr/client/connect.js';
+export { watchPaneSet } from './herdr/client/watch-pane-set.js';
+export { HerdrError, HerdrTransportError, ProtocolMismatchError, SubscriptionEnded, UnsupportedByServerError, } from './herdr/errors.js';

package/dist/read-only.d.ts

@@ -0,0 +1,5 @@
+export { connectReadOnly } from './herdr/client/scoped.js';
+export { connectPrompt } from './herdr/client/scoped.js';
+export { Presets, WatchKind } from './constants.js';
+export { Method, PRESET_METHODS, SubscriptionType, EventKind, AgentStatus } from './herdr/generated/index.js';
+export type { PromptClient, ReadOnlyClient, ReadOnlyContentClient, ReadOnlyOptions, PresetOptions, SessionsReaderClient, } from './herdr/client/types.js';

package/dist/read-only.js

@@ -0,0 +1,6 @@
+// Role: the /read-only entry: connectReadOnly(), connectPrompt(), Presets, and the read-only client types.
+// Informs HERDR-ADR-0003, HERDR-ADR-0005 and HERDR-ADR-0017; edited only by the integration step.
+export { connectReadOnly } from './herdr/client/scoped.js';
+export { connectPrompt } from './herdr/client/scoped.js';
+export { Presets, WatchKind } from './constants.js';
+export { Method, PRESET_METHODS, SubscriptionType, EventKind, AgentStatus } from './herdr/generated/index.js';

package/dist/schema.d.ts

@@ -0,0 +1,5 @@
+export { METHODS } from './herdr/generated/method-table.js';
+export { ENTRY_METHODS } from './herdr/generated/entry-methods.js';
+export { JsonKind, PARAMS_SHAPE } from './herdr/generated/test-data/shapes.js';
+export type { FieldShape, ParamsShape } from './herdr/generated/test-data/shapes.js';
+export { CapabilityClass } from './herdr/generated/names/capability-class.js';

package/dist/schema.js

@@ -0,0 +1,6 @@
+// Role: the /schema entry: the method table and parameter shapes of the generated API, read as data by tools outside the SDK.
+// Each export is named straight from its generated module, so a bundler keeps only what a consumer imports. Nothing else imports this entry.
+export { METHODS } from './herdr/generated/method-table.js';
+export { ENTRY_METHODS } from './herdr/generated/entry-methods.js';
+export { JsonKind, PARAMS_SHAPE } from './herdr/generated/test-data/shapes.js';
+export { CapabilityClass } from './herdr/generated/names/capability-class.js';

package/dist/test-kit.d.ts

@@ -0,0 +1,2 @@
+export { createFakeHerdr } from './herdr/test-kit/fake-herdr.js';
+export type * from './herdr/test-kit/types.js';