@loomcycle/client 0.8.19

package/dist/client.js

@@ -0,0 +1,366 @@
+/**
+ * LoomcycleClient — the single public class exported by
+ * @loomcycle/client. Speaks HTTP+SSE to a running loomcycle sidecar.
+ *
+ * hooks-connector PR C: full Python-adapter parity + hook management.
+ * 27 methods total — 26 async (run streaming, continuation, agent
+ * metadata, transcript, health, users, pause/resume/state, snapshot
+ * lifecycle capture / list / get / restore / delete, memory admin,
+ * interruption listing + resolve, hook registration / list / delete)
+ * plus one synchronous helper (exportSnapshotURL builds a URL string
+ * without issuing a request).
+ *
+ * Construction:
+ *
+ *   const client = new LoomcycleClient({
+ *     baseUrl: "http://127.0.0.1:8787",  // or process.env.LOOMCYCLE_BASE_URL
+ *     authToken: "...",                  // or process.env.LOOMCYCLE_AUTH_TOKEN
+ *   });
+ *
+ * Streaming methods (`runStreaming`, `continueSession`) return
+ * AsyncIterable<AgentEvent>; non-streaming methods return
+ * Promise<T>. Non-2xx responses throw typed errors from errors.ts
+ * via fetch-helpers.ts:raiseFromResponse — see README.md for the
+ * full mapping table.
+ */
+import { deleteRequest, jsonFetch, postJSON, raiseFromResponse, } from "./fetch-helpers.js";
+import { parseSSE } from "./stream.js";
+export class LoomcycleClient {
+    ctx;
+    constructor(opts = {}) {
+        this.ctx = {
+            baseUrl: (opts.baseUrl ?? "http://127.0.0.1:8787").replace(/\/$/, ""),
+            authToken: opts.authToken,
+            fetchImpl: opts.fetch ?? fetch,
+        };
+    }
+    // ---- Run lifecycle ----
+    /**
+     * Run an agent and stream events. Returns AsyncIterable<AgentEvent>;
+     * the iterator completes when the server closes the SSE stream.
+     *
+     * Errors during the run surface as `{ type: "error", error }` events;
+     * only transport / HTTP-level failures throw — and those throw typed
+     * errors (e.g. AuthError for 401, BackpressureError for 429).
+     */
+    async *runStreaming(opts) {
+        // Build the body conditionally so omitted fields stay off the wire.
+        // The pointer-vs-empty distinction on allowed_hosts is preserved by
+        // treating `null` as "omit" — same as the server's nil semantics —
+        // so callers threading a possibly-unset slice don't accidentally
+        // send `allowed_hosts: null` (which JSON-decodes to a deny-all on
+        // some implementations).
+        const body = {
+            agent: opts.agent,
+            segments: opts.segments,
+        };
+        if (opts.allowedTools !== undefined)
+            body.allowed_tools = opts.allowedTools;
+        if (opts.allowedHosts !== undefined && opts.allowedHosts !== null) {
+            body.allowed_hosts = opts.allowedHosts;
+        }
+        if (opts.webSearchFilter !== undefined)
+            body.web_search_filter = opts.webSearchFilter;
+        if (opts.sessionId !== undefined)
+            body.session_id = opts.sessionId;
+        if (opts.tenantId !== undefined)
+            body.tenant_id = opts.tenantId;
+        if (opts.userId !== undefined)
+            body.user_id = opts.userId;
+        if (opts.agentId !== undefined)
+            body.agent_id = opts.agentId;
+        if (opts.userTier !== undefined)
+            body.user_tier = opts.userTier;
+        if (opts.userBearer !== undefined)
+            body.user_bearer = opts.userBearer;
+        yield* this.streamSSE("/v1/runs", body, opts.signal);
+    }
+    /**
+     * Continue an existing session with a new run. The session's prior
+     * transcript is replayed into the model's context server-side;
+     * this iterator yields only the NEW events from the continuation.
+     *
+     * Raises SessionNotFoundError when sessionId is unknown,
+     * SessionBusyError when another request is in flight on the same
+     * session.
+     */
+    async *continueSession(opts) {
+        const body = {
+            segments: opts.segments,
+        };
+        if (opts.allowedTools !== undefined)
+            body.allowed_tools = opts.allowedTools;
+        if (opts.allowedHosts !== undefined && opts.allowedHosts !== null) {
+            body.allowed_hosts = opts.allowedHosts;
+        }
+        if (opts.webSearchFilter !== undefined)
+            body.web_search_filter = opts.webSearchFilter;
+        if (opts.agentId !== undefined)
+            body.agent_id = opts.agentId;
+        if (opts.userTier !== undefined)
+            body.user_tier = opts.userTier;
+        if (opts.userBearer !== undefined)
+            body.user_bearer = opts.userBearer;
+        yield* this.streamSSE(`/v1/sessions/${encodeURIComponent(opts.sessionId)}/messages`, body, opts.signal);
+    }
+    // ---- Agent metadata ----
+    /** Read one agent's status + usage stats. Raises AgentNotFoundError
+     *  when the agent_id is unknown. */
+    async getAgent(agentId, opts) {
+        return jsonFetch(this.ctx, `/v1/agents/${encodeURIComponent(agentId)}`, opts);
+    }
+    /** Cancel a live agent (cascades to children via parent_agent_id).
+     *  Returns count of agents cancelled. Idempotent — already-terminated
+     *  agents return 0. */
+    async cancelAgent(agentId, opts) {
+        const resp = await postJSON(this.ctx, `/v1/agents/${encodeURIComponent(agentId)}/cancel`, { reason: opts?.reason ?? "" }, opts);
+        return { cancelledCount: resp.cancelled_count };
+    }
+    /** List a user's recent agent runs, optionally filtered by status. */
+    async listUserAgents(userId, opts) {
+        const q = opts?.status ? `?status=${encodeURIComponent(opts.status)}` : "";
+        const resp = await jsonFetch(this.ctx, `/v1/users/${encodeURIComponent(userId)}/agents${q}`, opts);
+        return resp.agents ?? [];
+    }
+    /** Read the full event log for a session. Each entry has seq,
+     *  run_id, ts_ns, type, event (the providers.Event payload). */
+    async getTranscript(sessionId, opts) {
+        return jsonFetch(this.ctx, `/v1/sessions/${encodeURIComponent(sessionId)}/transcript`, opts);
+    }
+    /** Liveness probe. Unauthenticated. Returns build info + uptime.
+     *  Hits /healthz, not /v1/. */
+    async health(opts) {
+        return jsonFetch(this.ctx, "/healthz", opts);
+    }
+    /** Admin: list known users with running-count summary. Drives the
+     *  Web UI's user picker; operators with bearer auth can call too. */
+    async listUsers(opts) {
+        return jsonFetch(this.ctx, "/v1/_users", opts);
+    }
+    // ---- v0.8.17/8.18 Pause / Resume / State ----
+    /** Quiesce the runtime. Idempotent tools cancel immediately;
+     *  non-idempotent + external tools get a grace window then
+     *  force-cancel. Raises AlreadyPausingError on 409,
+     *  PauseNotConfiguredError on 503. */
+    async pauseRuntime(opts) {
+        const body = opts?.timeoutMs && opts.timeoutMs > 0
+            ? { timeout_ms: opts.timeoutMs }
+            : undefined;
+        return postJSON(this.ctx, "/v1/_pause", body, opts);
+    }
+    /** Release the runtime quiesce. Raises NotPausedError on 409. */
+    async resumeRuntime(opts) {
+        return postJSON(this.ctx, "/v1/_resume", undefined, opts);
+    }
+    /** Current runtime state. Cheap query — atomic state + a
+     *  bounded snapshots count. */
+    async getRuntimeState(opts) {
+        return jsonFetch(this.ctx, "/v1/_state", opts);
+    }
+    // ---- Snapshot lifecycle ----
+    /** Capture running-state into a per-section-semver JSON envelope.
+     *  Raises SnapshotTooLargeError on 413 when the envelope exceeds
+     *  LOOMCYCLE_SNAPSHOT_MAX_BYTES (default 512 MiB). */
+    async createSnapshot(opts) {
+        const body = {};
+        if (opts?.label)
+            body.label = opts.label;
+        if (opts?.includeHistory)
+            body.include_history = true;
+        if (opts?.includeHistorySince)
+            body.include_history_since = opts.includeHistorySince;
+        if (opts?.maxBytes && opts.maxBytes > 0)
+            body.max_bytes = opts.maxBytes;
+        return postJSON(this.ctx, "/v1/_snapshots", body, opts);
+    }
+    /** List captured snapshots (most-recent first). Capped at 200
+     *  server-side; the limit param defaults to 200 too. */
+    async listSnapshots(opts) {
+        const params = new URLSearchParams();
+        if (opts?.limit && opts.limit > 0)
+            params.set("limit", String(opts.limit));
+        if (opts?.labelContains)
+            params.set("label_contains", opts.labelContains);
+        const qs = params.toString();
+        const path = qs ? `/v1/_snapshots?${qs}` : "/v1/_snapshots";
+        const resp = await jsonFetch(this.ctx, path, opts);
+        return resp.entries ?? [];
+    }
+    /** Fetch the full snapshot envelope including JSON content.
+     *  Distinct from exportSnapshot (which is operator-facing
+     *  "where did this land on the host" semantics with a download
+     *  URL). Raises SnapshotNotFoundError on 404. */
+    async getSnapshot(snapshotId, opts) {
+        return jsonFetch(this.ctx, `/v1/_snapshots/${encodeURIComponent(snapshotId)}`, opts);
+    }
+    /** Returns the URL of the snapshot's canonical envelope —
+     *  synchronous and side-effect-free; does NOT issue an HTTP
+     *  request. The endpoint is bearer-authed like every other
+     *  `/v1/_snapshots/*` route, so callers must attach the same
+     *  `Authorization: Bearer <token>` header when fetching this
+     *  URL (e.g. `curl -H "Authorization: Bearer $TOKEN" ...`).
+     *  There is no token query-param fallback. */
+    exportSnapshotURL(snapshotId) {
+        return `${this.ctx.baseUrl}/v1/_snapshots/${encodeURIComponent(snapshotId)}/export`;
+    }
+    /** Restore from a same-instance snapshot id OR an inline
+     *  envelope JSON. Idempotent: ON CONFLICT DO NOTHING per row;
+     *  the returned counters reflect rows actually written.
+     *  Raises SnapshotVersionError on 422 when a section's
+     *  declared version is newer than the reader supports. */
+    async restoreSnapshot(opts) {
+        if (!opts.snapshotId && opts.json === undefined) {
+            // Client-side validation — match Python adapter's
+            // InvalidArgumentError pattern but the typed-error layer
+            // lives in errors.ts; for a thrown plain error here the
+            // method's catchers just see the message.
+            throw new Error("restoreSnapshot: pass snapshotId or json (one is required)");
+        }
+        if (opts.snapshotId && opts.json !== undefined) {
+            throw new Error("restoreSnapshot: pass only one of snapshotId or json");
+        }
+        // When json is supplied the id path-segment is ignored
+        // server-side; we use a placeholder "inline" segment to keep
+        // the URL well-formed.
+        const id = opts.snapshotId ?? "inline";
+        const body = {};
+        if (opts.includeHistory)
+            body.include_history = true;
+        if (opts.json !== undefined)
+            body.json = opts.json;
+        return postJSON(this.ctx, `/v1/_snapshots/${encodeURIComponent(id)}/restore`, body, opts);
+    }
+    /** Delete a snapshot. Idempotent — succeeds whether or not the
+     *  row existed (server returns 204 in both cases). */
+    async deleteSnapshot(snapshotId, opts) {
+        await deleteRequest(this.ctx, `/v1/_snapshots/${encodeURIComponent(snapshotId)}`, opts);
+    }
+    // ---- Memory admin ----
+    /** List the kinds of memory scopes the server knows about
+     *  (agent, user — or whatever the operator yaml declares). */
+    async listMemoryScopes(opts) {
+        return jsonFetch(this.ctx, "/v1/_memory/scopes", opts);
+    }
+    /** List the scope_ids that have at least one memory row under
+     *  a given scope. */
+    async listMemoryScopeIDs(scope, opts) {
+        return jsonFetch(this.ctx, `/v1/_memory/scopes/${encodeURIComponent(scope)}`, opts);
+    }
+    /** List memory entries under a (scope, scope_id) tuple.
+     *  Optional prefix narrows by key prefix. */
+    async listMemoryEntries(scope, scopeID, opts) {
+        const params = new URLSearchParams();
+        if (opts?.prefix)
+            params.set("prefix", opts.prefix);
+        // Guard against `limit: 0` (falsy but valid-looking) and negatives —
+        // both would either send `limit=0` (server treats as default but the
+        // semantic is unclear) or `limit=-N` (server rejects). Only send the
+        // param when the caller passed a meaningful positive number.
+        if (opts?.limit && opts.limit > 0)
+            params.set("limit", String(opts.limit));
+        const qs = params.toString();
+        const path = `/v1/_memory/scopes/${encodeURIComponent(scope)}/${encodeURIComponent(scopeID)}/keys${qs ? "?" + qs : ""}`;
+        return jsonFetch(this.ctx, path, opts);
+    }
+    /** Read a single memory entry by (scope, scope_id, key). */
+    async getMemoryEntry(scope, scopeID, key, opts) {
+        return jsonFetch(this.ctx, `/v1/_memory/scopes/${encodeURIComponent(scope)}/${encodeURIComponent(scopeID)}/keys/${encodeURIComponent(key)}`, opts);
+    }
+    // ---- Interruption ----
+    /** List interrupts addressable to a user_id. Default filter is
+     *  status=pending. */
+    async listUserInterrupts(userId, opts) {
+        const status = opts?.status ?? "pending";
+        return jsonFetch(this.ctx, `/v1/users/${encodeURIComponent(userId)}/interrupts?status=${encodeURIComponent(status)}`, opts);
+    }
+    /** List interrupts emitted by a specific run. */
+    async listRunInterrupts(runId, opts) {
+        const status = opts?.status ?? "pending";
+        return jsonFetch(this.ctx, `/v1/runs/${encodeURIComponent(runId)}/interrupts?status=${encodeURIComponent(status)}`, opts);
+    }
+    /** Resolve a pending Interruption.ask from outside the agent
+     *  loop. Lets a TS-side dashboard or service act as the human
+     *  answerer when operator yaml configures the consumer-MCP
+     *  backend. */
+    async resolveInterrupt(runId, interruptId, opts) {
+        return postJSON(this.ctx, `/v1/runs/${encodeURIComponent(runId)}/interrupts/${encodeURIComponent(interruptId)}/resolve`, {
+            kind: opts.kind ?? "question",
+            answer: opts.answer,
+            resolved_by: opts.resolvedBy ?? "client",
+        }, opts);
+    }
+    // ---- Hook management (hooks-connector series, PR C) ----
+    /** Register a pre- or post-tool webhook. The callback_url must be
+     *  an http:// or https:// endpoint the CONSUMER runs — loomcycle
+     *  POSTs PreHookCall / PostHookCall payloads to it. This method
+     *  manages registration only; the receiver is the consumer's own
+     *  HTTP framework (Express, Next.js, etc.).
+     *
+     *  Re-registering the same (owner, name) replaces the prior entry
+     *  with a fresh id (idempotent app-restart contract).
+     *
+     *  Raises InvalidArgumentError on 400 (bad URL / phase / missing
+     *  required fields). */
+    async registerHook(opts) {
+        const body = {
+            owner: opts.owner,
+            name: opts.name,
+            phase: opts.phase,
+            callback_url: opts.callbackUrl,
+        };
+        if (opts.agents !== undefined)
+            body.agents = opts.agents;
+        if (opts.tools !== undefined)
+            body.tools = opts.tools;
+        if (opts.failMode !== undefined)
+            body.fail_mode = opts.failMode;
+        if (opts.timeoutMs !== undefined && opts.timeoutMs > 0) {
+            body.timeout_ms = opts.timeoutMs;
+        }
+        return postJSON(this.ctx, "/v1/hooks", body, opts);
+    }
+    /** List every currently-registered hook. Returns the array
+     *  unwrapped (the wire envelope is `{hooks: [...]}` — we strip
+     *  the envelope to match listUserAgents). In-memory only — empty
+     *  after a loomcycle restart. */
+    async listHooks(opts) {
+        const resp = await jsonFetch(this.ctx, "/v1/hooks", opts);
+        return resp.hooks ?? [];
+    }
+    /** Delete a registered hook by id. Raises HookNotFoundError on
+     *  404. Returns void on success (the HTTP 200 body `{deleted: id}`
+     *  is dropped — callers already know the id they passed). */
+    async deleteHook(id, opts) {
+        await deleteRequest(this.ctx, `/v1/hooks/${encodeURIComponent(id)}`, opts);
+    }
+    // ---- Internal helpers ----
+    /** Shared SSE POST → stream-of-AgentEvent path. Used by
+     *  runStreaming + continueSession. */
+    async *streamSSE(path, body, signal) {
+        const headers = {
+            "Content-Type": "application/json",
+            // Accept BOTH text/event-stream (the success path) AND
+            // application/json (the error path — non-2xx responses come
+            // back as JSON so raiseFromResponse can extract typed errors).
+            // Per the Streamable HTTP spec; strict reverse proxies in
+            // front of the sidecar 406 otherwise. Same rationale as the
+            // v0.8.x MCP HTTP-transport hardening note in CLAUDE.md.
+            Accept: "text/event-stream, application/json",
+        };
+        if (this.ctx.authToken)
+            headers.Authorization = `Bearer ${this.ctx.authToken}`;
+        const resp = await this.ctx.fetchImpl(this.ctx.baseUrl + path, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(body),
+            signal,
+        });
+        if (!resp.ok) {
+            await raiseFromResponse(resp);
+        }
+        if (!resp.body) {
+            throw new Error("loomcycle: response has no body");
+        }
+        yield* parseSSE(resp.body.getReader());
+    }
+}

package/dist/errors.d.ts

@@ -0,0 +1,135 @@
+/**
+ * Typed exceptions raised by LoomcycleClient. Mirrors the Python
+ * adapter's `errors.py` taxonomy 1:1 — same names, same semantics,
+ * just adapted to HTTP status codes (no gRPC StatusCode equivalents).
+ *
+ * Every error stores the raw HTTP status (`status`) and the raw
+ * response body (`bodyText`, truncated to 1 KiB) for log correlation
+ * when the typed class doesn't carry enough.
+ *
+ * Dispatch from raw HTTP response to typed error lives in
+ * `fetch-helpers.ts:raiseFromResponse` — that's the one place to
+ * look when adding a new error type.
+ *
+ * PR 5a foundation: classes defined; dispatch wiring lands here +
+ * in fetch-helpers.ts. The current `runStreaming` (the only public
+ * method in v0.1.0-alpha) throws a plain Error today; PR 5a keeps
+ * that behavior. PR 5b switches `runStreaming` + every new method
+ * to raise typed errors via `raiseFromResponse`.
+ */
+export declare class LoomcycleError extends Error {
+    readonly status?: number;
+    readonly bodyText?: string;
+    constructor(message: string, opts?: {
+        status?: number;
+        bodyText?: string;
+    });
+}
+/** Base class for every HTTP 404 the client surfaces. Lets callers
+ *  catch any not-found case with a single `instanceof NotFoundError`
+ *  check, regardless of which specific resource was missing
+ *  (agent / session / snapshot / generic 404 like a missing memory
+ *  row or interrupt). */
+export declare class NotFoundError extends LoomcycleError {
+    constructor(message: string, opts?: {
+        status?: number;
+        bodyText?: string;
+    });
+}
+export declare class AgentNotFoundError extends NotFoundError {
+    constructor(message: string, opts?: {
+        status?: number;
+        bodyText?: string;
+    });
+}
+export declare class SessionNotFoundError extends NotFoundError {
+    constructor(message: string, opts?: {
+        status?: number;
+        bodyText?: string;
+    });
+}
+export declare class SessionBusyError extends LoomcycleError {
+    constructor(message: string, opts?: {
+        status?: number;
+        bodyText?: string;
+    });
+}
+export declare class AgentIDInUseError extends LoomcycleError {
+    constructor(message: string, opts?: {
+        status?: number;
+        bodyText?: string;
+    });
+}
+export declare class BackpressureError extends LoomcycleError {
+    constructor(message: string, opts?: {
+        status?: number;
+        bodyText?: string;
+    });
+}
+export declare class AuthError extends LoomcycleError {
+    constructor(message: string, opts?: {
+        status?: number;
+        bodyText?: string;
+    });
+}
+export declare class UnavailableError extends LoomcycleError {
+    constructor(message: string, opts?: {
+        status?: number;
+        bodyText?: string;
+    });
+}
+export declare class InvalidArgumentError extends LoomcycleError {
+    constructor(message: string, opts?: {
+        status?: number;
+        bodyText?: string;
+    });
+}
+/** Subclasses UnavailableError for back-compat: code that broadly
+ *  catches UnavailableError keeps working when this more-specific
+ *  variant fires. */
+export declare class PauseNotConfiguredError extends UnavailableError {
+    constructor(message: string, opts?: {
+        status?: number;
+        bodyText?: string;
+    });
+}
+export declare class AlreadyPausingError extends LoomcycleError {
+    constructor(message: string, opts?: {
+        status?: number;
+        bodyText?: string;
+    });
+}
+export declare class NotPausedError extends LoomcycleError {
+    constructor(message: string, opts?: {
+        status?: number;
+        bodyText?: string;
+    });
+}
+export declare class SnapshotNotFoundError extends NotFoundError {
+    constructor(message: string, opts?: {
+        status?: number;
+        bodyText?: string;
+    });
+}
+export declare class SnapshotTooLargeError extends LoomcycleError {
+    constructor(message: string, opts?: {
+        status?: number;
+        bodyText?: string;
+    });
+}
+export declare class SnapshotVersionError extends LoomcycleError {
+    constructor(message: string, opts?: {
+        status?: number;
+        bodyText?: string;
+    });
+}
+/** HookNotFoundError — raised by deleteHook when no hook has the
+ *  supplied id (HTTP 404 with "hook" in the body). Extends
+ *  NotFoundError so consumers catching the broader category get this
+ *  one too. */
+export declare class HookNotFoundError extends NotFoundError {
+    constructor(message: string, opts?: {
+        status?: number;
+        bodyText?: string;
+    });
+}

package/dist/errors.js

@@ -0,0 +1,138 @@
+/**
+ * Typed exceptions raised by LoomcycleClient. Mirrors the Python
+ * adapter's `errors.py` taxonomy 1:1 — same names, same semantics,
+ * just adapted to HTTP status codes (no gRPC StatusCode equivalents).
+ *
+ * Every error stores the raw HTTP status (`status`) and the raw
+ * response body (`bodyText`, truncated to 1 KiB) for log correlation
+ * when the typed class doesn't carry enough.
+ *
+ * Dispatch from raw HTTP response to typed error lives in
+ * `fetch-helpers.ts:raiseFromResponse` — that's the one place to
+ * look when adding a new error type.
+ *
+ * PR 5a foundation: classes defined; dispatch wiring lands here +
+ * in fetch-helpers.ts. The current `runStreaming` (the only public
+ * method in v0.1.0-alpha) throws a plain Error today; PR 5a keeps
+ * that behavior. PR 5b switches `runStreaming` + every new method
+ * to raise typed errors via `raiseFromResponse`.
+ */
+export class LoomcycleError extends Error {
+    status;
+    bodyText;
+    constructor(message, opts) {
+        super(message);
+        this.name = "LoomcycleError";
+        this.status = opts?.status;
+        this.bodyText = opts?.bodyText;
+    }
+}
+/** Base class for every HTTP 404 the client surfaces. Lets callers
+ *  catch any not-found case with a single `instanceof NotFoundError`
+ *  check, regardless of which specific resource was missing
+ *  (agent / session / snapshot / generic 404 like a missing memory
+ *  row or interrupt). */
+export class NotFoundError extends LoomcycleError {
+    constructor(message, opts) {
+        super(message, opts);
+        this.name = "NotFoundError";
+    }
+}
+export class AgentNotFoundError extends NotFoundError {
+    constructor(message, opts) {
+        super(message, opts);
+        this.name = "AgentNotFoundError";
+    }
+}
+export class SessionNotFoundError extends NotFoundError {
+    constructor(message, opts) {
+        super(message, opts);
+        this.name = "SessionNotFoundError";
+    }
+}
+export class SessionBusyError extends LoomcycleError {
+    constructor(message, opts) {
+        super(message, opts);
+        this.name = "SessionBusyError";
+    }
+}
+export class AgentIDInUseError extends LoomcycleError {
+    constructor(message, opts) {
+        super(message, opts);
+        this.name = "AgentIDInUseError";
+    }
+}
+export class BackpressureError extends LoomcycleError {
+    constructor(message, opts) {
+        super(message, opts);
+        this.name = "BackpressureError";
+    }
+}
+export class AuthError extends LoomcycleError {
+    constructor(message, opts) {
+        super(message, opts);
+        this.name = "AuthError";
+    }
+}
+export class UnavailableError extends LoomcycleError {
+    constructor(message, opts) {
+        super(message, opts);
+        this.name = "UnavailableError";
+    }
+}
+export class InvalidArgumentError extends LoomcycleError {
+    constructor(message, opts) {
+        super(message, opts);
+        this.name = "InvalidArgumentError";
+    }
+}
+// ---- v0.8.18 — Pause/Snapshot typed errors ----
+/** Subclasses UnavailableError for back-compat: code that broadly
+ *  catches UnavailableError keeps working when this more-specific
+ *  variant fires. */
+export class PauseNotConfiguredError extends UnavailableError {
+    constructor(message, opts) {
+        super(message, opts);
+        this.name = "PauseNotConfiguredError";
+    }
+}
+export class AlreadyPausingError extends LoomcycleError {
+    constructor(message, opts) {
+        super(message, opts);
+        this.name = "AlreadyPausingError";
+    }
+}
+export class NotPausedError extends LoomcycleError {
+    constructor(message, opts) {
+        super(message, opts);
+        this.name = "NotPausedError";
+    }
+}
+export class SnapshotNotFoundError extends NotFoundError {
+    constructor(message, opts) {
+        super(message, opts);
+        this.name = "SnapshotNotFoundError";
+    }
+}
+export class SnapshotTooLargeError extends LoomcycleError {
+    constructor(message, opts) {
+        super(message, opts);
+        this.name = "SnapshotTooLargeError";
+    }
+}
+export class SnapshotVersionError extends LoomcycleError {
+    constructor(message, opts) {
+        super(message, opts);
+        this.name = "SnapshotVersionError";
+    }
+}
+/** HookNotFoundError — raised by deleteHook when no hook has the
+ *  supplied id (HTTP 404 with "hook" in the body). Extends
+ *  NotFoundError so consumers catching the broader category get this
+ *  one too. */
+export class HookNotFoundError extends NotFoundError {
+    constructor(message, opts) {
+        super(message, opts);
+        this.name = "HookNotFoundError";
+    }
+}