@aexhq/sdk 0.46.4-canary → 0.50.0

package/dist/_contracts/testing/wire-conformance.js

@@ -1,276 +0,0 @@
-import { ApiErrorEnvelopeSchema } from "../schemas/response-common.js";
-import { observeWireResponses } from "../wire-observer.js";
-/**
- * Match a concrete path against a `{param}` pattern.
- *
- * Segment-wise rather than by regex so a placeholder cannot accidentally span a
- * `/` and make two different routes look like one.
- */
-export function pathMatches(pattern, actual) {
-    const patternSegments = pattern.split("/");
-    const actualSegments = actual.split("/");
-    if (patternSegments.length !== actualSegments.length) {
-        return false;
-    }
-    return patternSegments.every((segment, index) => (segment.startsWith("{") && segment.endsWith("}")) || segment === actualSegments[index]);
-}
-/**
- * Reduce whatever the caller had to hand — a base URL, a URL with a path, a bare
- * origin — to the origin `WireResponse` reports.
- *
- * Throws rather than falling back to "match everything": an unparseable
- * `AEX_API_URL` that silently disabled the filter would reintroduce exactly the
- * false violations the filter exists to prevent, and would do it quietly.
- */
-export function wireOrigin(baseUrl) {
-    try {
-        return new URL(baseUrl).origin;
-    }
-    catch (cause) {
-        throw new Error(`wire conformance: could not read an origin from ${JSON.stringify(baseUrl)} — ` +
-            `expected an absolute URL like "https://api.aex.dev"`, { cause });
-    }
-}
-function issuesOf(result) {
-    return (result.issues ?? []).map((issue) => {
-        const path = (issue.path ?? [])
-            .map((segment) => (typeof segment === "object" ? String(segment.key) : String(segment)))
-            .join(".");
-        return path ? `${path}: ${issue.message}` : issue.message;
-    });
-}
-/**
- * Which contract a status is judged against.
- *
- * The generated document is coarser than this — it declares `2XX` and a
- * `default` that catches everything else — but judging a redirect against the
- * error envelope would manufacture a violation out of an empty body, which is
- * noise rather than a finding. A 3xx is recorded, named and not judged.
- *
- * In practice `fetch` follows redirects, so `HttpClient` sees the final
- * response; this exists so that a caller who stops following them gets a
- * comprehensible report rather than a wall of false failures.
- */
-function contractFor(status) {
-    if (status < 300)
-        return "response";
-    if (status < 400)
-        return "redirect";
-    return "error-envelope";
-}
-/**
- * Start validating responses.
- *
- * Returns a handle carrying the report and a `stop()`. Validation is
- * synchronous: a schema whose `~standard.validate` returns a promise is treated
- * as unvalidatable and recorded as such rather than silently skipped, because
- * `HttpClient` cannot await an observer without changing request timing.
- */
-export function installWireConformance(bindings, options = {}) {
-    const originFilter = options.origin === undefined ? undefined : wireOrigin(options.origin);
-    const errorEnvelope = options.errorEnvelope === undefined ? ApiErrorEnvelopeSchema : options.errorEnvelope;
-    const validated = new Set();
-    const unschemad = new Set();
-    const errorsValidated = new Set();
-    const offPlane = new Set();
-    const violations = [];
-    let observed = 0;
-    /** Validate `body`, recording a violation on failure. Returns false if async. */
-    const check = (schema, kind, name, response) => {
-        const result = schema["~standard"].validate(response.body);
-        if (result instanceof Promise) {
-            return false;
-        }
-        if (result.issues) {
-            violations.push({
-                kind,
-                name,
-                method: response.method.toUpperCase(),
-                origin: response.origin,
-                path: response.path,
-                status: response.status,
-                issues: issuesOf(result),
-                body: response.body
-            });
-        }
-        return true;
-    };
-    const stop = observeWireResponses((response) => {
-        observed += 1;
-        const method = response.method.toUpperCase();
-        if (originFilter !== undefined && response.origin !== originFilter) {
-            offPlane.add(`${response.origin} ${method} ${response.path}`);
-            return;
-        }
-        const contract = contractFor(response.status);
-        if (contract === "redirect") {
-            unschemad.add(`${method} ${response.path} -> ${response.status} (redirect — no declared body)`);
-            return;
-        }
-        if (contract === "error-envelope") {
-            // An error body is the SAME envelope whatever route produced it, so it is
-            // checked without needing a binding — which is the point: the routes with
-            // no 2xx schema still have their failures covered.
-            if (errorEnvelope === null) {
-                return;
-            }
-            if (check(errorEnvelope, "error-envelope", `${method} ${response.path}`, response)) {
-                errorsValidated.add(`${method} ${response.path} -> ${response.status}`);
-            }
-            else {
-                unschemad.add(`${method} ${response.path} -> ${response.status} (async schema — not validated)`);
-            }
-            return;
-        }
-        const binding = bindings.find((candidate) => candidate.method === method && pathMatches(candidate.path, response.path));
-        if (!binding) {
-            unschemad.add(`${method} ${response.path}`);
-            return;
-        }
-        if (!check(binding.schema, "response", binding.name, response)) {
-            unschemad.add(`${binding.name} (async schema — not validated)`);
-            return;
-        }
-        validated.add(binding.name);
-    });
-    return {
-        stop,
-        report: () => ({
-            originFilter,
-            validated: [...validated].sort(),
-            unexercised: bindings
-                .map((binding) => binding.name)
-                .filter((name) => !validated.has(name))
-                .sort(),
-            unschemad: [...unschemad].sort(),
-            errorsValidated: [...errorsValidated].sort(),
-            offPlane: [...offPlane].sort(),
-            violations,
-            observed
-        })
-    };
-}
-/**
- * Fold reports from several processes into one.
- *
- * The suites that matter drive the SDK out of process — one bun child per
- * scenario, one test process per file — so no single process sees the whole
- * surface, and a per-process report would understate coverage by construction.
- *
- * `unexercised` is INTERSECTED, not concatenated: a name is unexercised overall
- * only when every fragment failed to exercise it. Concatenating would report a
- * route as unexercised because some other process did not happen to call it,
- * which is the mirror image of the false-green this harness exists to prevent.
- * That identity only holds when every fragment was produced from the same
- * binding table; {@link installWireConformance} is the only producer.
- */
-export function mergeWireConformanceReports(reports) {
-    const validated = new Set();
-    const unschemad = new Set();
-    const errorsValidated = new Set();
-    const offPlane = new Set();
-    const violations = [];
-    const originFilters = new Set();
-    let unexercised;
-    let observed = 0;
-    let anyUnfiltered = false;
-    for (const report of reports) {
-        observed += report.observed;
-        for (const name of report.validated)
-            validated.add(name);
-        for (const route of report.unschemad)
-            unschemad.add(route);
-        for (const route of report.errorsValidated)
-            errorsValidated.add(route);
-        for (const route of report.offPlane)
-            offPlane.add(route);
-        violations.push(...report.violations);
-        if (report.originFilter === undefined)
-            anyUnfiltered = true;
-        else
-            originFilters.add(report.originFilter);
-        unexercised =
-            unexercised === undefined
-                ? new Set(report.unexercised)
-                : new Set(report.unexercised.filter((name) => unexercised.has(name)));
-    }
-    return {
-        // One filter across every fragment is the only case that can be stated
-        // simply. A mixed run is reported as unfiltered so the formatter's warning
-        // fires rather than a filter being claimed that not every fragment applied.
-        originFilter: !anyUnfiltered && originFilters.size === 1 ? [...originFilters][0] : undefined,
-        validated: [...validated].sort(),
-        unexercised: [...(unexercised ?? new Set())].filter((name) => !validated.has(name)).sort(),
-        unschemad: [...unschemad].sort(),
-        errorsValidated: [...errorsValidated].sort(),
-        offPlane: [...offPlane].sort(),
-        violations,
-        observed
-    };
-}
-/** Render a body for a violation without letting one huge response bury the report. */
-function renderBody(body, limit = 2000) {
-    let text;
-    try {
-        text = JSON.stringify(body) ?? String(body);
-    }
-    catch {
-        text = String(body);
-    }
-    return text.length > limit ? `${text.slice(0, limit)}… (${text.length} bytes total)` : text;
-}
-/**
- * Render the report for a suite's output.
- *
- * Always prints the unexercised and unschemad lists, including when there are no
- * violations — a run that reports only "0 violations" invites the reader to
- * conclude the surface is verified. A violation always prints the BODY that
- * caused it as well as the schema's complaint, because triage needs both.
- */
-export function formatWireConformanceReport(report) {
-    const lines = [
-        `wire conformance: ${report.observed} response(s) observed, ` +
-            `${report.validated.length} operation(s) validated, ` +
-            `${report.errorsValidated.length} error response(s) checked, ` +
-            `${report.violations.length} violation(s)`
-    ];
-    lines.push(report.originFilter === undefined
-        ? `  ORIGIN FILTER: none — every observed response was matched by PATH alone. ` +
-            `Sound only for a process that drives ONE plane; the control plane serves ` +
-            `different bodies at GET /api/whoami and DELETE /api/workspaces/{id}.`
-        : `  ORIGIN FILTER: ${report.originFilter}`);
-    if (report.offPlane.length > 0) {
-        lines.push(`  OFF-PLANE (other origin, not checked against these bindings):`);
-        for (const route of report.offPlane) {
-            lines.push(`    - ${route}`);
-        }
-    }
-    if (report.validated.length > 0) {
-        lines.push(`  VALIDATED (${report.validated.length}): ${report.validated.join(", ")}`);
-    }
-    if (report.errorsValidated.length > 0) {
-        lines.push(`  ERROR ENVELOPES CHECKED (${report.errorsValidated.length}):`);
-        for (const route of report.errorsValidated) {
-            lines.push(`    - ${route}`);
-        }
-    }
-    if (report.unexercised.length > 0) {
-        lines.push(`  NOT EXERCISED (schema exists, no response seen) (${report.unexercised.length}): ` +
-            `${report.unexercised.join(", ")}`);
-    }
-    if (report.unschemad.length > 0) {
-        lines.push(`  NO SCHEMA (response seen, nothing to check it against):`);
-        for (const route of report.unschemad) {
-            lines.push(`    - ${route}`);
-        }
-    }
-    for (const violation of report.violations) {
-        lines.push(`  VIOLATION [${violation.kind}] ${violation.name} ` +
-            `(${violation.method} ${violation.origin}${violation.path} -> ${violation.status}):`);
-        for (const issue of violation.issues) {
-            lines.push(`    - ${issue}`);
-        }
-        lines.push(`    body: ${renderBody(violation.body)}`);
-    }
-    return lines.join("\n");
-}

package/dist/_contracts/turn-trace.d.ts

@@ -1,28 +0,0 @@
-import type { UsageSummary } from "./runtime-types.js";
-export interface ToolCallTrace {
-    readonly id: string;
-    readonly name: string;
-    readonly args: Readonly<Record<string, unknown>>;
-    readonly messageId?: string;
-    readonly startSeq?: number;
-    readonly startedAt?: string;
-    readonly result?: ToolCallResult;
-    readonly durationMs?: number;
-}
-export interface ToolCallResult {
-    readonly isError: boolean;
-    readonly content: unknown;
-    readonly seq?: number;
-    readonly recordedAt?: string;
-}
-export interface AssistantTextEntry {
-    readonly text: string;
-    readonly messageId?: string;
-    readonly seq?: number;
-    readonly recordedAt?: string;
-}
-export interface TurnTrace {
-    readonly toolCalls: readonly ToolCallTrace[];
-    readonly usage: UsageSummary;
-    readonly text: readonly AssistantTextEntry[];
-}

package/dist/_contracts/turn-trace.js

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

package/dist/_contracts/unknown-field-error.d.ts

@@ -1,13 +0,0 @@
-/**
- * Structured metadata for a strict-parser unknown-field diagnostic.
- *
- * This class is exported only from the workspace-internal contracts entrypoint.
- * Its inherited `Error` name and formatted message preserve existing callers.
- */
-export declare class UnknownFieldError extends Error {
-    readonly objectPath: string;
-    readonly unknownKey: string;
-    readonly permittedKeys: readonly string[];
-    constructor(objectPath: string, unknownKey: string, permittedKeys: readonly string[]);
-    withPermittedKeys(permittedKeys: readonly string[]): UnknownFieldError;
-}

package/dist/_contracts/unknown-field-error.js

@@ -1,21 +0,0 @@
-/**
- * Structured metadata for a strict-parser unknown-field diagnostic.
- *
- * This class is exported only from the workspace-internal contracts entrypoint.
- * Its inherited `Error` name and formatted message preserve existing callers.
- */
-export class UnknownFieldError extends Error {
-    objectPath;
-    unknownKey;
-    permittedKeys;
-    constructor(objectPath, unknownKey, permittedKeys) {
-        const copiedPermittedKeys = Object.freeze([...permittedKeys]);
-        super(`${objectPath}.${unknownKey} is not an allowed field; permitted: ${copiedPermittedKeys.join(", ")}`);
-        this.objectPath = objectPath;
-        this.unknownKey = unknownKey;
-        this.permittedKeys = copiedPermittedKeys;
-    }
-    withPermittedKeys(permittedKeys) {
-        return new UnknownFieldError(this.objectPath, this.unknownKey, permittedKeys);
-    }
-}

package/dist/_contracts/value-guards.d.ts

@@ -1,20 +0,0 @@
-/** JSON-compatible scalar values carried by public wire contracts. */
-export type JsonPrimitive = string | number | boolean | null;
-/** Recursively JSON-compatible values; numbers must be finite at runtime. */
-export type JsonValue = JsonPrimitive | JsonValue[] | {
-    readonly [key: string]: JsonValue;
-};
-/**
- * Broad object-record guard used at untrusted wire boundaries.
- *
- * Deliberately does not require a plain object or a particular prototype. The
- * package's existing parsers have always accepted every non-null, non-array
- * object at this first shape boundary and apply their domain checks afterwards.
- */
-export declare function isRecord(value: unknown): value is Record<string, unknown>;
-/** Recursively validate the package's JSON value contract. */
-export declare function isJsonValue(value: unknown): value is JsonValue;
-/** Validate an object record whose enumerable values are recursively JSON-compatible. */
-export declare function isJsonRecord(value: unknown): value is Record<string, JsonValue>;
-/** Narrow an unknown scalar to a member of an ordered readonly string tuple. */
-export declare function isStringLiteral<const TAllowed extends readonly string[]>(value: unknown, allowed: TAllowed): value is TAllowed[number];

package/dist/_contracts/value-guards.js

@@ -1,34 +0,0 @@
-/**
- * Broad object-record guard used at untrusted wire boundaries.
- *
- * Deliberately does not require a plain object or a particular prototype. The
- * package's existing parsers have always accepted every non-null, non-array
- * object at this first shape boundary and apply their domain checks afterwards.
- */
-export function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-/** Recursively validate the package's JSON value contract. */
-export function isJsonValue(value) {
-    if (typeof value === "number") {
-        return Number.isFinite(value);
-    }
-    if (value === null || typeof value === "string" || typeof value === "boolean") {
-        return true;
-    }
-    if (Array.isArray(value)) {
-        return value.every(isJsonValue);
-    }
-    if (isRecord(value)) {
-        return Object.values(value).every(isJsonValue);
-    }
-    return false;
-}
-/** Validate an object record whose enumerable values are recursively JSON-compatible. */
-export function isJsonRecord(value) {
-    return isRecord(value) && Object.values(value).every(isJsonValue);
-}
-/** Narrow an unknown scalar to a member of an ordered readonly string tuple. */
-export function isStringLiteral(value, allowed) {
-    return typeof value === "string" && allowed.includes(value);
-}

package/dist/_contracts/webhook-verify.d.ts

@@ -1,34 +0,0 @@
-/**
- * Customer-side verification for aex start webhooks (Standard Webhooks scheme).
- *
- * aex signs every delivery HMAC-SHA256 over `${webhook-id}.${webhook-timestamp}.${rawBody}`
- * and sends three headers:
- *   - `webhook-id`         : stable across retries (dedupe key)
- *   - `webhook-timestamp`  : unix seconds at send time
- *   - `webhook-signature`  : space-delimited list of `v1,<base64(hmac)>` entries
- *                            (a list during secret rotation — accept ANY match)
- *
- * The secret is the workspace signing secret surfaced once as `whsec_<base64>`;
- * the HMAC key is the raw bytes after the `whsec_` prefix. Verification accepts
- * the secret with or without the prefix.
- *
- * Pure Web Crypto — identical under Bun and Node; this mirrors the
- * `standardwebhooks` library so a customer can verify with either.
- */
-export interface VerifyAexWebhookInput {
-    /** The exact bytes of the request body, as a string (do NOT re-serialize). */
-    readonly rawBody: string;
-    /** The inbound request headers (case-insensitive lookup). */
-    readonly headers: Headers | Readonly<Record<string, string | string[] | undefined>>;
-    /** The workspace signing secret, `whsec_<base64>` (or the bare base64). */
-    readonly secret: string;
-    /** Max allowed clock skew between `webhook-timestamp` and now. Default 300s. */
-    readonly toleranceSeconds?: number;
-}
-/**
- * Verify an aex webhook delivery. Returns `true` only when the timestamp is
- * within tolerance AND one of the `v1,<base64>` entries in `webhook-signature`
- * matches the HMAC over `${id}.${timestamp}.${rawBody}`. Constant-time compare;
- * never throws on a bad signature (only on a malformed secret).
- */
-export declare function verifyAexWebhook(input: VerifyAexWebhookInput): Promise<boolean>;

package/dist/_contracts/webhook-verify.js

@@ -1,93 +0,0 @@
-/**
- * Customer-side verification for aex start webhooks (Standard Webhooks scheme).
- *
- * aex signs every delivery HMAC-SHA256 over `${webhook-id}.${webhook-timestamp}.${rawBody}`
- * and sends three headers:
- *   - `webhook-id`         : stable across retries (dedupe key)
- *   - `webhook-timestamp`  : unix seconds at send time
- *   - `webhook-signature`  : space-delimited list of `v1,<base64(hmac)>` entries
- *                            (a list during secret rotation — accept ANY match)
- *
- * The secret is the workspace signing secret surfaced once as `whsec_<base64>`;
- * the HMAC key is the raw bytes after the `whsec_` prefix. Verification accepts
- * the secret with or without the prefix.
- *
- * Pure Web Crypto — identical under Bun and Node; this mirrors the
- * `standardwebhooks` library so a customer can verify with either.
- */
-const encoder = new TextEncoder();
-function headerValue(headers, name) {
-    if (headers instanceof Headers) {
-        return headers.get(name) ?? undefined;
-    }
-    const lower = name.toLowerCase();
-    for (const [key, value] of Object.entries(headers)) {
-        if (key.toLowerCase() === lower) {
-            return Array.isArray(value) ? value[0] : value ?? undefined;
-        }
-    }
-    return undefined;
-}
-/** Strip the `whsec_` prefix and decode the base64 key material to bytes. */
-function decodeSecret(secret) {
-    const material = secret.startsWith("whsec_") ? secret.slice("whsec_".length) : secret;
-    const binary = atob(material);
-    const bytes = new Uint8Array(binary.length);
-    for (let i = 0; i < binary.length; i++)
-        bytes[i] = binary.charCodeAt(i);
-    return bytes;
-}
-async function hmacBase64(keyBytes, message) {
-    const key = await crypto.subtle.importKey("raw", keyBytes, { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
-    const sig = await crypto.subtle.sign("HMAC", key, encoder.encode(message));
-    let binary = "";
-    const view = new Uint8Array(sig);
-    for (let i = 0; i < view.length; i++)
-        binary += String.fromCharCode(view[i]);
-    return btoa(binary);
-}
-/** Length-then-constant-time comparison of two strings. */
-function timingSafeEqual(a, b) {
-    if (a.length !== b.length)
-        return false;
-    let diff = 0;
-    for (let i = 0; i < a.length; i++)
-        diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
-    return diff === 0;
-}
-/**
- * Verify an aex webhook delivery. Returns `true` only when the timestamp is
- * within tolerance AND one of the `v1,<base64>` entries in `webhook-signature`
- * matches the HMAC over `${id}.${timestamp}.${rawBody}`. Constant-time compare;
- * never throws on a bad signature (only on a malformed secret).
- */
-export async function verifyAexWebhook(input) {
-    const toleranceSeconds = input.toleranceSeconds ?? 300;
-    const id = headerValue(input.headers, "webhook-id");
-    const timestamp = headerValue(input.headers, "webhook-timestamp");
-    const signatureHeader = headerValue(input.headers, "webhook-signature");
-    if (!id || !timestamp || !signatureHeader)
-        return false;
-    const ts = Number(timestamp);
-    if (!Number.isFinite(ts))
-        return false;
-    const nowSeconds = Math.floor(Date.now() / 1000);
-    if (Math.abs(nowSeconds - ts) > toleranceSeconds)
-        return false;
-    const keyBytes = decodeSecret(input.secret);
-    const expected = await hmacBase64(keyBytes, `${id}.${timestamp}.${input.rawBody}`);
-    // `webhook-signature` is a space-delimited list of versioned signatures; a
-    // single delivery may carry several (current + previous key during rotation).
-    for (const entry of signatureHeader.split(" ")) {
-        const comma = entry.indexOf(",");
-        if (comma === -1)
-            continue;
-        const version = entry.slice(0, comma);
-        const value = entry.slice(comma + 1);
-        if (version !== "v1")
-            continue;
-        if (timingSafeEqual(value, expected))
-            return true;
-    }
-    return false;
-}

package/dist/_contracts/wire-observer.d.ts

@@ -1,49 +0,0 @@
-/**
- * The seam the wire-conformance harness (C4) attaches to.
- *
- * `HttpClient` reports every JSON response here — 2xx AND the error envelopes it
- * is about to throw on. Nothing observes it unless a harness installs an
- * observer, so the shipped cost is one null check per request and this file's
- * handful of bytes — deliberately small, because it ships in the published SDK
- * while the harness that uses it does not.
- *
- * It lives here rather than in `schemas/` because `http.ts` must not pull the
- * schema library in on the request path.
- */
-/** A JSON response as it came off the wire, before any client-side shaping. */
-export interface WireResponse {
-    readonly method: string;
-    /**
-     * Scheme + host + port of the plane that served it — `https://api.aex.dev`.
-     *
-     * Carried because a PATH does not identify a route: the control plane serves
-     * different bodies at two of the data plane's paths (`GET /api/whoami`,
-     * `DELETE /api/workspaces/{id}`). Without this, a process driving both planes
-     * validates a control-plane body against a data-plane schema and reports a
-     * violation that is not one. `URL.origin` is a getter on a URL the client has
-     * already constructed, and it is read inside the reporting thunk, so nothing
-     * computes it when no harness is observing.
-     */
-    readonly origin: string;
-    /** Path only — no origin, no query string. `/api/sessions/sess_1/messages`. */
-    readonly path: string;
-    readonly status: number;
-    /**
-     * The body EXACTLY as it was decoded, including on a non-2xx.
-     *
-     * Never the client's enrichment of it: `HttpClient` folds the `x-request-id`
-     * header into the error body it throws, and a harness validating that derived
-     * object would be checking our own client rather than the server's bytes.
-     */
-    readonly body: unknown;
-}
-export type WireResponseObserver = (response: WireResponse) => void;
-/**
- * Install an observer and get a function that removes it.
- *
- * Deliberately single-slot: two harnesses observing at once would double-count
- * coverage, and there is no case for it.
- */
-export declare function observeWireResponses(next: WireResponseObserver): () => void;
-/** Report a response. A no-op — and nearly free — when nothing is observing. */
-export declare function reportWireResponse(response: () => WireResponse): void;

package/dist/_contracts/wire-observer.js

@@ -1,34 +0,0 @@
-/**
- * The seam the wire-conformance harness (C4) attaches to.
- *
- * `HttpClient` reports every JSON response here — 2xx AND the error envelopes it
- * is about to throw on. Nothing observes it unless a harness installs an
- * observer, so the shipped cost is one null check per request and this file's
- * handful of bytes — deliberately small, because it ships in the published SDK
- * while the harness that uses it does not.
- *
- * It lives here rather than in `schemas/` because `http.ts` must not pull the
- * schema library in on the request path.
- */
-let observer;
-/**
- * Install an observer and get a function that removes it.
- *
- * Deliberately single-slot: two harnesses observing at once would double-count
- * coverage, and there is no case for it.
- */
-export function observeWireResponses(next) {
-    observer = next;
-    return () => {
-        if (observer === next) {
-            observer = undefined;
-        }
-    };
-}
-/** Report a response. A no-op — and nearly free — when nothing is observing. */
-export function reportWireResponse(response) {
-    if (observer === undefined) {
-        return;
-    }
-    observer(response());
-}

package/dist/_contracts/workflow-status.d.ts

@@ -1,7 +0,0 @@
-/** Internal orchestration states. Public session reads use `SessionStatus`. */
-export declare const SESSION_WORKFLOW_STATUSES: readonly ["queued", "claiming", "provisioning", "session_created", "dispatched", "provider_running", "provider_idle", "provider_rescheduled", "idle", "suspending", "suspended", "deleting", "deleted", "expired", "cancelling", "capturing_files", "cleaning_up", "succeeded", "failed", "timed_out", "cancelled", "interrupted", "cleanup_failed"];
-export type SessionWorkflowStatus = (typeof SESSION_WORKFLOW_STATUSES)[number];
-export type SessionWorkflowStatusKind = "active" | "terminal";
-export declare const TERMINAL_SESSION_WORKFLOW_STATUSES: readonly ["succeeded", "failed", "timed_out", "cancelled", "interrupted", "deleted", "expired", "cleanup_failed"];
-export declare function isTerminalSessionWorkflowStatus(status: SessionWorkflowStatus): boolean;
-export declare function getSessionWorkflowStatusKind(status: SessionWorkflowStatus): SessionWorkflowStatusKind;

package/dist/_contracts/workflow-status.js

@@ -1,43 +0,0 @@
-/** Internal orchestration states. Public session reads use `SessionStatus`. */
-export const SESSION_WORKFLOW_STATUSES = [
-    "queued",
-    "claiming",
-    "provisioning",
-    "session_created",
-    "dispatched",
-    "provider_running",
-    "provider_idle",
-    "provider_rescheduled",
-    "idle",
-    "suspending",
-    "suspended",
-    "deleting",
-    "deleted",
-    "expired",
-    "cancelling",
-    "capturing_files",
-    "cleaning_up",
-    "succeeded",
-    "failed",
-    "timed_out",
-    "cancelled",
-    "interrupted",
-    "cleanup_failed"
-];
-export const TERMINAL_SESSION_WORKFLOW_STATUSES = [
-    "succeeded",
-    "failed",
-    "timed_out",
-    "cancelled",
-    "interrupted",
-    "deleted",
-    "expired",
-    "cleanup_failed"
-];
-const terminalSessionWorkflowStatuses = new Set(TERMINAL_SESSION_WORKFLOW_STATUSES);
-export function isTerminalSessionWorkflowStatus(status) {
-    return terminalSessionWorkflowStatuses.has(status);
-}
-export function getSessionWorkflowStatusKind(status) {
-    return isTerminalSessionWorkflowStatus(status) ? "terminal" : "active";
-}