@syndroo/sdk 0.4.0-rc.1 → 0.7.0

package/dist/http.js

@@ -1,298 +1,400 @@
 /**
- * The single HTTP transport used by the SDK.
+ * HTTP transport for `@syndroo/sdk`.
  *
- * Invariants this module enforces for every request:
+ * Scope, deliberately narrow:
  *
- * - exactly one network request per call; the SDK never retries a write,
- *   because a retry without a stable idempotency key can duplicate a post;
- * - redirects are not followed, so the `Authorization` header can never reach
- *   a redirect target;
- * - every request is bounded by a finite deadline;
- * - the response body is read with a size limit, so an oversized or hostile
- *   response cannot exhaust the caller's memory;
- * - no logging, so credentials and content never reach stdout or stderr.
+ * - `POST /v1/connect`, `POST /v1/publish`, `POST /v1/status` only. There is no
+ *   GET business route, no health probe and no CRUD family.
+ * - The bearer secret is required and travels only in the `Authorization`
+ *   header. It is never placed in a URL, a query string or an error.
+ * - The base URL is checked before any socket is opened. Credentials/userinfo,
+ *   a query and a fragment are rejected, and plain HTTP is accepted only for a
+ *   loopback host, because a remote cleartext endpoint would expose the bearer
+ *   secret to the network.
+ * - Redirects are never followed (`redirect: "manual"`). Following one would
+ *   forward the `Authorization` header to an origin the caller never chose.
+ * - A request body is bounded and validated by the generated validator (64 KiB);
+ *   a response is read with a hard 1 MiB cap while streaming, decoded as strict
+ *   UTF-8 and parsed by the generated bounded parser, then validated as an
+ *   envelope whose `operation` must match the call.
+ * - Transport retries reuse one idempotency key. A valid envelope is never
+ *   retried, whatever its business result says: `failed`, `partial` and
+ *   `unknown` are protocol successes, not transport errors.
  */
-import { SyndrooAbortError, SyndrooApiError, SyndrooError, SyndrooNetworkError, SyndrooResponseError, SyndrooTimeoutError, truncate, } from "./errors.js";
-export const DEFAULT_TIMEOUT_MS = 30_000;
-export const DEFAULT_MAX_RESPONSE_BYTES = 8 * 1024 * 1024;
-export const MIN_MAX_RESPONSE_BYTES = 1024;
-const PREVIEW_LIMIT = 200;
-const MAX_RETRY_AFTER_MS = 24 * 60 * 60 * 1000;
-export async function sendRequest(config, request) {
-    const url = buildUrl(config.baseUrl, request.path, request.query);
-    const timeoutMs = request.timeoutMs ?? config.timeoutMs;
-    const isWrite = request.method !== "GET";
-    const userSignal = request.signal;
-    if (userSignal?.aborted === true) {
-        throw new SyndrooAbortError("The request was aborted before it was sent, so nothing reached Syndroo.", { cause: userSignal.reason, requestMayHaveBeenApplied: false });
-    }
-    // Read through a call so TypeScript's narrowing from the check above does not
-    // make the later failure classification unreachable.
-    const callerAbort = () => ({
-        aborted: userSignal?.aborted === true,
-        reason: userSignal?.reason,
-    });
-    const headers = new Headers({ accept: "application/json" });
-    if (request.authenticated !== false) {
-        headers.set("authorization", `Bearer ${config.apiKey}`);
-    }
-    if (request.idempotencyKey !== undefined) {
-        headers.set("idempotency-key", request.idempotencyKey);
-    }
-    const init = {
-        method: request.method,
-        headers,
-        redirect: "manual",
-    };
-    if (request.json !== undefined) {
-        headers.set("content-type", "application/json");
-        init.body = JSON.stringify(request.json);
-    }
-    const controller = new AbortController();
-    let timedOut = false;
-    const handle = setTimeout(() => {
-        timedOut = true;
-        controller.abort();
-    }, timeoutMs);
-    unrefTimer(handle);
-    init.signal = controller.signal;
-    const forwardAbort = () => {
-        controller.abort();
-    };
-    userSignal?.addEventListener("abort", forwardAbort, { once: true });
-    try {
-        const response = await globalThis.fetch(url, init);
-        if (isRedirectResponse(response)) {
-            throw new SyndrooApiError("Syndroo answered with a redirect. The SDK does not follow redirects " +
-                "because the Authorization header must never be forwarded to another " +
-                "location; point baseUrl at the final API origin instead.", {
-                code: "REDIRECT_NOT_FOLLOWED",
-                status: response.status,
-                requestMayHaveBeenApplied: false,
-            });
-        }
-        const text = await readBody(response, config.maxResponseBytes, isWrite);
-        const preview = truncate(text, PREVIEW_LIMIT);
-        if (!response.ok) {
-            throw apiError(response, text, preview, isWrite);
-        }
-        return {
-            status: response.status,
-            body: parseJson(text, response.status, preview, isWrite),
-        };
-    }
-    catch (error) {
-        if (error instanceof SyndrooError) {
-            throw error;
-        }
-        if (timedOut) {
-            throw new SyndrooTimeoutError(timeoutMessage(isWrite, timeoutMs), {
-                timeoutMs,
-                cause: error,
-                requestMayHaveBeenApplied: isWrite,
-            });
-        }
-        const caller = callerAbort();
-        if (caller.aborted) {
-            throw new SyndrooAbortError(abortMessage(isWrite), {
-                cause: caller.reason ?? error,
-                requestMayHaveBeenApplied: isWrite,
-            });
-        }
-        throw new SyndrooNetworkError(networkMessage(isWrite, error), {
-            cause: error,
-            networkCode: networkCodeOf(error),
-            requestMayHaveBeenApplied: isWrite,
-        });
+import { SyndrooError } from "./errors.js";
+import { parseStrictResponseJson } from "./generated/validation.js";
+import { validateWire } from "./generated/validators.js";
+/** Protocol and transport bounds. Changing one is an API decision. */
+export const LIMITS = Object.freeze({
+    /** Largest request body the wire protocol accepts. */
+    maxRequestBytes: 65536,
+    /** Largest response body the SDK will buffer. */
+    maxResponseBytes: 1048576,
+    /** Default per-request deadline. */
+    defaultTimeoutMs: 30000,
+    /** Smallest accepted per-request deadline. */
+    minTimeoutMs: 1,
+    /** Largest per-request deadline the protocol allows. */
+    maxTimeoutMs: 120000,
+    /** Largest number of transport retries the protocol allows. */
+    maxTransportRetries: 2,
+    /** Longest accepted caller-supplied idempotency key. */
+    maxIdempotencyKeyLength: 128,
+});
+/**
+ * Statuses retried at the transport layer only when no valid envelope came back.
+ *
+ * These are the classic "something between the client and the application
+ * failed" statuses: a gateway or a crashed worker answered while the Syndroo
+ * server never produced a protocol response. Retrying is safe because the
+ * request identity is reused, so an already-admitted operation is looked up
+ * instead of repeated. `429` is deliberately absent: rate limiting is an
+ * admission answer, not a transport failure.
+ */
+const RETRYABLE_STATUS = new Set([408, 500, 502, 503, 504]);
+/** Statuses that may carry an `ok: true` protocol envelope. */
+const ACCEPTED_STATUS = new Set([200, 202]);
+/**
+ * The blueprint's idempotency-key grammar: one to 128 characters from
+ * `[A-Za-z0-9._:-]`. Anything else (whitespace, punctuation, an over-long key)
+ * is rejected before a request is built.
+ */
+const IDEMPOTENCY_KEY_PATTERN = /^[A-Za-z0-9._:-]{1,128}$/;
+/** The loopback hosts that may be reached over plain HTTP. */
+export function isLoopbackHostname(hostname) {
+    const host = hostname.toLowerCase().replace(/^\[|\]$/g, "");
+    if (host === "localhost" || host.endsWith(".localhost")) {
+        return true;
+    }
+    if (host === "::1") {
+        return true;
+    }
+    const ipv4 = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/.exec(host);
+    if (ipv4 === null) {
+        return false;
     }
-    finally {
-        clearTimeout(handle);
-        userSignal?.removeEventListener("abort", forwardAbort);
+    const octets = ipv4.slice(1, 5).map((part) => Number.parseInt(part ?? "", 10));
+    if (octets.some((octet) => Number.isNaN(octet) || octet > 255)) {
+        return false;
     }
+    return octets[0] === 127;
 }
 /**
- * Node keeps the process alive for a pending timer. An SDK call must not pin a
- * CLI process open after its response or its deadline.
+ * Validate a base URL, or throw a static `INSECURE_BASE_URL` error.
+ *
+ * Rejected: a non-absolute URL, a scheme other than HTTP or HTTPS, embedded
+ * credentials, a query, a fragment, and plain HTTP to anything that is not
+ * loopback.
  */
-export function unrefTimer(handle) {
-    const candidate = handle;
-    const unref = candidate.unref;
-    if (typeof unref === "function") {
-        unref.call(handle);
+export function assertUsableBaseUrl(raw) {
+    if (typeof raw !== "string" || raw.length === 0) {
+        throw new SyndrooError("INSECURE_BASE_URL");
     }
-}
-function buildUrl(baseUrl, path, query) {
-    const url = new URL(`${baseUrl}${path}`);
-    for (const [key, value] of Object.entries(query ?? {})) {
-        url.searchParams.set(key, value);
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        throw new SyndrooError("INSECURE_BASE_URL");
+    }
+    if (url.protocol !== "https:" && url.protocol !== "http:") {
+        throw new SyndrooError("INSECURE_BASE_URL");
+    }
+    if (url.username !== "" || url.password !== "") {
+        throw new SyndrooError("INSECURE_BASE_URL");
+    }
+    if (url.hash !== "" || url.search !== "") {
+        throw new SyndrooError("INSECURE_BASE_URL");
+    }
+    if (url.protocol === "http:" && !isLoopbackHostname(url.hostname)) {
+        throw new SyndrooError("INSECURE_BASE_URL");
     }
     return url;
 }
-function isRedirectResponse(response) {
-    if (response.type === "opaqueredirect") {
-        return true;
+/** Validate the API key before any request is built. */
+export function assertApiKey(apiKey) {
+    if (typeof apiKey !== "string" || apiKey.length === 0 || /[\r\n\u0000]/.test(apiKey)) {
+        throw new SyndrooError("INVALID_ARGUMENT");
     }
-    return response.status >= 300 && response.status < 400;
+    return apiKey;
 }
-async function readBody(response, maxBytes, isWrite) {
-    const body = response.body;
-    if (body === null) {
-        return "";
+/** Validate a caller- or SDK-generated idempotency key. */
+export function assertIdempotencyKey(key) {
+    if (typeof key !== "string" || !IDEMPOTENCY_KEY_PATTERN.test(key)) {
+        throw new SyndrooError("INVALID_ARGUMENT");
     }
-    const reader = body.getReader();
-    const chunks = [];
-    let length = 0;
-    try {
-        for (;;) {
-            const { done, value } = await reader.read();
-            if (done) {
-                break;
-            }
-            length += value.byteLength;
-            if (length > maxBytes) {
-                await reader.cancel("Response exceeded the SDK response size limit").catch(() => undefined);
-                throw new SyndrooResponseError(`Syndroo returned a response larger than the configured limit of ${maxBytes} bytes. ` +
-                    "Raise maxResponseBytes only for a trusted deployment.", {
-                    status: response.status,
-                    requestMayHaveBeenApplied: mayHaveBeenApplied(response.status, isWrite),
-                });
-            }
-            chunks.push(value);
+    return key;
+}
+function assertIntegerInRange(value, min, max) {
+    if (!Number.isInteger(value) || value < min || value > max) {
+        throw new SyndrooError("INVALID_ARGUMENT");
+    }
+    return value;
+}
+/** Resolve and bound the per-call transport options. */
+export function resolveTransportOptions(options) {
+    const timeoutMs = options.timeoutMs === undefined
+        ? LIMITS.defaultTimeoutMs
+        : assertIntegerInRange(options.timeoutMs, LIMITS.minTimeoutMs, LIMITS.maxTimeoutMs);
+    const transportRetries = options.transportRetries === undefined
+        ? 0
+        : assertIntegerInRange(options.transportRetries, 0, LIMITS.maxTransportRetries);
+    return { timeoutMs, transportRetries };
+}
+/** Keep a pending timer from holding the process open, when the runtime allows it. */
+export function unrefTimer(timer) {
+    if (timer !== null && typeof timer === "object" && "unref" in timer) {
+        timer.unref();
+    }
+}
+/**
+ * Read a response body with a hard byte cap instead of buffering blindly.
+ *
+ * A rejection path calls `onReject` after releasing the body, so the caller can
+ * abort the request too: leaving a rejected response's body unread keeps the
+ * socket alive and can hold the process open.
+ */
+async function readBoundedBody(response, limit, onReject) {
+    const declared = response.headers.get("content-length");
+    if (declared !== null) {
+        const declaredBytes = Number.parseInt(declared, 10);
+        if (Number.isFinite(declaredBytes) && declaredBytes > limit) {
+            await cancelBody(response);
+            onReject();
+            throw new SyndrooError("RESPONSE_TOO_LARGE", { status: response.status });
         }
     }
-    finally {
-        reader.releaseLock();
+    const stream = response.body;
+    if (stream === null) {
+        return new Uint8Array(0);
     }
-    const bytes = new Uint8Array(length);
+    const reader = stream.getReader();
+    const chunks = [];
+    let total = 0;
+    for (;;) {
+        const { done, value } = await reader.read();
+        if (done) {
+            break;
+        }
+        if (value === undefined) {
+            continue;
+        }
+        total += value.byteLength;
+        if (total > limit) {
+            await reader.cancel();
+            onReject();
+            throw new SyndrooError("RESPONSE_TOO_LARGE", { status: response.status });
+        }
+        chunks.push(value);
+    }
+    const body = new Uint8Array(total);
     let offset = 0;
     for (const chunk of chunks) {
-        bytes.set(chunk, offset);
+        body.set(chunk, offset);
         offset += chunk.byteLength;
     }
-    return new TextDecoder().decode(bytes);
+    return body;
 }
-function parseJson(text, status, preview, isWrite) {
-    if (text === "") {
-        return undefined;
+/** Release a response body the SDK is not going to read. */
+async function cancelBody(response) {
+    const body = response.body;
+    if (body === null) {
+        return;
     }
     try {
-        return JSON.parse(text);
+        await body.cancel();
     }
     catch {
-        throw new SyndrooResponseError(`Syndroo returned HTTP ${status} with a body that is not JSON: ${preview}`, {
-            status,
-            preview,
-            requestMayHaveBeenApplied: mayHaveBeenApplied(status, isWrite),
-        });
+        // A body that is already errored or locked cannot be cancelled; the request
+        // abort that follows still releases the socket.
     }
 }
-function apiError(response, text, preview, isWrite) {
-    const envelope = errorEnvelope(text);
-    return new SyndrooApiError(envelope?.message ??
-        `Syndroo returned HTTP ${response.status} without a documented error body: ${preview}`, {
-        code: envelope?.code ?? `HTTP_${response.status}`,
-        status: response.status,
-        requestMayHaveBeenApplied: mayHaveBeenApplied(response.status, isWrite),
-        retryAfterMs: retryAfterMs(response.headers.get("retry-after")),
-    });
-}
-function errorEnvelope(text) {
-    if (text === "") {
-        return undefined;
+/**
+ * Parse and validate one response envelope.
+ *
+ * Extra fields are tolerated (the generated response validator ignores them);
+ * an unknown enum value, a missing required field, invalid UTF-8, invalid JSON
+ * or a mismatched `operation` are all `malformed`.
+ */
+function readEnvelope(bytes, operation) {
+    if (bytes.byteLength === 0) {
+        return { kind: "malformed" };
     }
     let parsed;
     try {
-        parsed = JSON.parse(text);
+        parsed = parseStrictResponseJson(bytes);
     }
     catch {
-        return undefined;
+        return { kind: "malformed" };
     }
-    if (typeof parsed !== "object" || parsed === null) {
-        return undefined;
+    try {
+        validateWire("Envelope", parsed, true);
     }
-    const error = parsed.error;
-    if (typeof error !== "object" || error === null) {
-        return undefined;
+    catch {
+        return { kind: "malformed" };
+    }
+    const envelope = parsed;
+    if (envelope.operation !== operation) {
+        return { kind: "malformed" };
     }
-    const record = error;
-    const code = typeof record.code === "string" ? record.code : undefined;
-    const message = typeof record.message === "string" ? record.message : undefined;
-    if (code === undefined || message === undefined) {
-        return undefined;
+    if (envelope.ok) {
+        return { kind: "result", result: envelope.result };
     }
-    return { code, message: truncate(message, PREVIEW_LIMIT) };
+    return { kind: "rejected", error: envelope.error };
 }
 /**
- * `Retry-After` is either a number of seconds or an HTTP date. Both are
- * converted to a bounded delay so a caller can honor backpressure without
- * trusting an attacker-controlled header to park the process for days.
+ * A transport bound to one base URL and one bearer secret.
+ *
+ * The class owns the retry loop, so a retry always reuses the same idempotency
+ * key: the key is part of `TransportRequest` and is never regenerated.
  */
-function retryAfterMs(header) {
-    if (header === null) {
-        return undefined;
+export class HttpTransport {
+    baseUrl;
+    apiKey;
+    fetchImpl;
+    constructor(config) {
+        this.baseUrl = assertUsableBaseUrl(config.baseUrl);
+        this.apiKey = assertApiKey(config.apiKey);
+        this.fetchImpl = config.fetch;
+    }
+    /** The origin the transport will talk to; safe for tests and diagnostics. */
+    get endpointOrigin() {
+        return this.baseUrl.origin;
+    }
+    /** Validate the body, then send it, retrying only transport-level failures. */
+    async send(request) {
+        if (request.idempotencyKey !== undefined) {
+            assertIdempotencyKey(request.idempotencyKey);
+        }
+        try {
+            validateWire(request.wireName, request.body, false);
+        }
+        catch {
+            throw new SyndrooError("INVALID_REQUEST");
+        }
+        const url = this.buildUrl(request.operation);
+        const payload = JSON.stringify(request.body);
+        const attempts = request.transportRetries + 1;
+        let lastError;
+        for (let attempt = 0; attempt < attempts; attempt += 1) {
+            try {
+                return await this.attempt(url, payload, request);
+            }
+            catch (error) {
+                const failure = error instanceof SyndrooError ? error : new SyndrooError("TRANSPORT");
+                if (!failure.retryable || attempt + 1 >= attempts) {
+                    throw failure;
+                }
+                lastError = failure;
+            }
+        }
+        throw lastError ?? new SyndrooError("TRANSPORT");
     }
-    const trimmed = header.trim();
-    const seconds = Number(trimmed);
-    if (trimmed !== "" && Number.isFinite(seconds) && seconds >= 0) {
-        return Math.min(seconds * 1000, MAX_RETRY_AFTER_MS);
+    buildUrl(operation) {
+        const base = this.baseUrl.origin + this.baseUrl.pathname.replace(/\/+$/, "");
+        return `${base}/v1/${operation}`;
     }
-    const date = Date.parse(trimmed);
-    if (Number.isNaN(date)) {
-        return undefined;
+    async attempt(url, payload, request) {
+        const controller = new AbortController();
+        const external = request.signal;
+        if (external !== undefined && external.aborted) {
+            throw new SyndrooError("ABORTED");
+        }
+        const onExternalAbort = () => controller.abort();
+        external?.addEventListener("abort", onExternalAbort, { once: true });
+        let deadlineElapsed = false;
+        const timer = setTimeout(() => {
+            deadlineElapsed = true;
+            controller.abort();
+        }, request.timeoutMs);
+        unrefTimer(timer);
+        try {
+            const response = await this.fetchImpl(url, {
+                method: "POST",
+                headers: buildHeaders(this.apiKey, request.idempotencyKey),
+                body: payload,
+                redirect: "manual",
+                signal: controller.signal,
+            });
+            if (response.status >= 300 && response.status < 400) {
+                await cancelBody(response);
+                controller.abort();
+                throw new SyndrooError("REDIRECT_NOT_ALLOWED", { status: response.status });
+            }
+            const bytes = await readBoundedBody(response, LIMITS.maxResponseBytes, () => controller.abort());
+            return unwrapEnvelope(readEnvelope(bytes, request.operation), response.status, request.operation);
+        }
+        catch (error) {
+            if (error instanceof SyndrooError) {
+                throw error;
+            }
+            throw classifyThrown(external, deadlineElapsed);
+        }
+        finally {
+            clearTimeout(timer);
+            external?.removeEventListener("abort", onExternalAbort);
+        }
+    }
+}
+function buildHeaders(apiKey, idempotencyKey) {
+    const headers = {
+        accept: "application/json",
+        "content-type": "application/json",
+        authorization: `Bearer ${apiKey}`,
+    };
+    if (idempotencyKey !== undefined) {
+        headers["idempotency-key"] = idempotencyKey;
     }
-    return Math.min(Math.max(date - Date.now(), 0), MAX_RETRY_AFTER_MS);
+    return headers;
 }
 /**
- * A write may have been applied when Syndroo accepted it (2xx) or when the
- * failure happened at or after the server's processing boundary (5xx). A 4xx
- * is a decision, so nothing was applied.
+ * Turn a validated envelope into a value or a static error.
+ *
+ * `ok: false` is an authoritative protocol answer, so it is never retried: the
+ * server already did whatever it is going to do. A non-envelope 2xx is a
+ * protocol violation; a non-envelope error status is an HTTP failure, retryable
+ * only for the statuses that mean "the application never answered".
+ *
+ * `202` is reserved by the protocol for an already durably admitted execution
+ * that has not reached a terminal status. It is a correlation, not a generic
+ * "accepted": a status query, a connect step, a prepared result or a terminal
+ * execution answered with `202` is a protocol violation.
  */
-function mayHaveBeenApplied(status, isWrite) {
-    if (!isWrite) {
-        return false;
+function unwrapEnvelope(outcome, status, operation) {
+    if (outcome.kind === "result") {
+        if (!ACCEPTED_STATUS.has(status)) {
+            throw new SyndrooError("INVALID_RESPONSE", { status });
+        }
+        if (status === 202 && !isAdmittedNonterminalExecution(operation, outcome.result)) {
+            throw new SyndrooError("INVALID_RESPONSE", { status });
+        }
+        return outcome.result;
     }
-    return status >= 500 || (status >= 200 && status < 300);
-}
-function timeoutMessage(isWrite, timeoutMs) {
-    if (!isWrite) {
-        return (`Request timed out after ${timeoutMs}ms. This was a read, so nothing was ` +
-            "created; retrying is safe.");
-    }
-    return (`Request timed out after ${timeoutMs}ms. Syndroo may still have accepted the ` +
-        "post: do not resend it with a new Idempotency-Key. Look the post up with " +
-        "posts.list, or retry the identical request with the same key.");
-}
-function abortMessage(isWrite) {
-    if (!isWrite) {
-        return "The request was aborted after it was sent. This was a read, so nothing was created.";
+    if (outcome.kind === "rejected") {
+        throw new SyndrooError("PROTOCOL", { status, serverError: outcome.error });
+    }
+    if (ACCEPTED_STATUS.has(status)) {
+        throw new SyndrooError("INVALID_RESPONSE", { status });
     }
-    return ("The request was aborted after it was sent, so Syndroo may still have " +
-        "accepted the post: do not resend it with a new Idempotency-Key. Look the " +
-        "post up with posts.list, or retry the identical request with the same key.");
+    throw new SyndrooError("HTTP_ERROR", { status, retryable: RETRYABLE_STATUS.has(status) });
 }
-function networkMessage(isWrite, error) {
-    const code = networkCodeOf(error);
-    const suffix = code === undefined ? "" : ` (${code})`;
-    if (!isWrite) {
-        return `The request failed before a response was received${suffix}.`;
-    }
-    return (`The request failed before a response was received${suffix}. Syndroo may ` +
-        "still have accepted the post: do not resend it with a new " +
-        "Idempotency-Key. Look the post up with posts.list, or retry the identical " +
-        "request with the same key.");
+/** True for the only result a `202` may carry: admitted, non-terminal execution. */
+function isAdmittedNonterminalExecution(operation, result) {
+    if (operation !== "publish" || result === null || typeof result !== "object") {
+        return false;
+    }
+    const candidate = result;
+    return (candidate.phase === "execution" &&
+        (candidate.status === "pending" || candidate.status === "running"));
 }
-function networkCodeOf(error) {
-    let current = error;
-    for (let depth = 0; depth < 4; depth += 1) {
-        if (typeof current !== "object" || current === null) {
-            return undefined;
-        }
-        const code = current.code;
-        if (typeof code === "string" && code !== "") {
-            return truncate(code, 40);
-        }
-        current = current.cause;
+/** Classify a thrown fetch or stream error without echoing it. */
+function classifyThrown(external, deadlineElapsed) {
+    if (external?.aborted === true) {
+        return new SyndrooError("ABORTED");
+    }
+    if (deadlineElapsed) {
+        return new SyndrooError("TIMEOUT", { retryable: true });
     }
-    return undefined;
+    return new SyndrooError("TRANSPORT", { retryable: true });
 }
 //# sourceMappingURL=http.js.map