unstructured-transform-client 0.18.18

package/dist/index.js

@@ -0,0 +1,35 @@
+/**
+ * TypeScript client for the Unstructured Transform v2 API.
+ *
+ *     import { TransformClient } from "@utic/transform-client";
+ *
+ *     const client = new TransformClient({ apiKey: "..." });
+ *     const result = await client.parse.run({ input: file });
+ *
+ * Everything exported here is public. The `_generated` directory is not — it
+ * is produced from openapi.yaml at build time and its layout is the
+ * generator's business, so importing from it directly will break without
+ * notice. The models re-exported below are the exception: they are the
+ * response types this SDK returns, so a caller needs to be able to name them.
+ */
+export { DEFAULT_SERVER_URL, TransformClient } from "./client.js";
+export { isTerminal } from "./sse.js";
+export { asFile } from "./files.js";
+export { isAccepted } from "./outcome.js";
+export { VERSION } from "./version.js";
+// The generator's error classes. `ResponseError` carries a non-2xx response,
+// `FetchError` a transport failure, `RequiredError` a missing argument caught
+// before the request goes out.
+export { FetchError, RequiredError, ResponseError } from "./_generated/runtime.js";
+// Enums are VALUES, not only types. typescript-fetch emits each as a const
+// object of members plus a union type, so `export type` alone ships the type
+// and silently drops the object — leaving callers unable to write
+// `error.code === ErrorCode.UnsupportedFileType` against the very codes the
+// API returns. Exported as values so the members exist at runtime.
+export { ErrorCode, JobStatus, OutputFormat, } from "./_generated/models/index.js";
+// Generated per-operation as `ParseRunProfileEnum` (named after `parseRun`,
+// the operation ID), re-exported under a name that describes the field
+// instead of the endpoint that happens to declare it first. Same domain on
+// extract.fromDocument's `profile`, which has no generated operation of its
+// own to name an enum after.
+export { ParseRunProfileEnum as Profile } from "./_generated/apis/ParseApi.js";

package/dist/multipart.d.ts

@@ -0,0 +1,50 @@
+/**
+ * The multipart request openapi-generator refuses to emit.
+ *
+ * POST /api/v2/extract declares two request bodies in openapi.yaml:
+ *
+ *     application/json      -> ExtractRequest         (extract against a parse)
+ *     multipart/form-data   -> ExtractDocumentRequest (extract from a document)
+ *
+ * The generator emits a method for the first and nothing for the second.
+ * `ExtractDocumentRequest` is absent from the generated models in both
+ * languages. There is no warning; the operation simply cannot be called that
+ * way from a generated client.
+ *
+ * Sent with plain `fetch` and a `FormData` body rather than through the
+ * generated `BaseAPI`: the generated request pipeline is built around a
+ * declared operation, and there is no declared operation to hand it. The
+ * credential and identification headers come from the client, so this call is
+ * authenticated and identified exactly like every other.
+ */
+import type { Outcome } from "./outcome.js";
+import type { TransformClient } from "./client.js";
+export interface MultipartRequest<TResult> {
+    path: string;
+    fileField: string;
+    /** Omitted when the caller referenced an already-uploaded file instead. */
+    file?: Blob;
+    /**
+     * The filename the part carries. Required whenever `file` is given.
+     *
+     * `FormData.append(name, blob)` labels the part `blob` when no filename is
+     * supplied, and the service validates an upload's extension against an
+     * allowlist — so a perfectly good PDF comes back as "Unsupported file type".
+     * The Python SDK refuses a nameless document for the same reason.
+     */
+    filename?: string;
+    fields: Record<string, string | undefined>;
+    waitSeconds?: number;
+    /**
+     * The generated mapper for the 200 body.
+     *
+     * Required, not optional. A raw `as TResult` cast compiles and is wrong: the
+     * wire is snake_case and the SDK's types are camelCase, so `format_version`
+     * and `extracted_data` simply would not appear under the properties the
+     * types promise. Every generated call path runs its body through the
+     * generated mapper, and the Python facade does the equivalent via
+     * `response_deserialize` — this was the one path that did not.
+     */
+    fromJSON: (json: unknown) => TResult;
+}
+export declare function postMultipart<TResult>(client: TransformClient, request: MultipartRequest<TResult>): Promise<Outcome<TResult>>;

package/dist/multipart.js

@@ -0,0 +1,65 @@
+/**
+ * The multipart request openapi-generator refuses to emit.
+ *
+ * POST /api/v2/extract declares two request bodies in openapi.yaml:
+ *
+ *     application/json      -> ExtractRequest         (extract against a parse)
+ *     multipart/form-data   -> ExtractDocumentRequest (extract from a document)
+ *
+ * The generator emits a method for the first and nothing for the second.
+ * `ExtractDocumentRequest` is absent from the generated models in both
+ * languages. There is no warning; the operation simply cannot be called that
+ * way from a generated client.
+ *
+ * Sent with plain `fetch` and a `FormData` body rather than through the
+ * generated `BaseAPI`: the generated request pipeline is built around a
+ * declared operation, and there is no declared operation to hand it. The
+ * credential and identification headers come from the client, so this call is
+ * authenticated and identified exactly like every other.
+ */
+import { JobAcceptedFromJSON } from "./_generated/models/index.js";
+import { ResponseError } from "./_generated/runtime.js";
+import { fetchWithRetries } from "./retry.js";
+export async function postMultipart(client, request) {
+    const form = new FormData();
+    for (const [name, value] of Object.entries(request.fields)) {
+        // undefined fields are omitted rather than sent empty: the service
+        // distinguishes an absent optional field from a present empty one, and
+        // sending `prompt=` would assert the caller supplied an empty prompt.
+        if (value !== undefined) {
+            form.append(name, value);
+        }
+    }
+    if (request.file !== undefined) {
+        if (!request.filename) {
+            throw new TypeError("a file part needs a filename; see files.ts");
+        }
+        form.append(request.fileField, request.file, request.filename);
+    }
+    const headers = { ...client.requestHeaders };
+    if (request.waitSeconds !== undefined) {
+        headers["Prefer"] = `wait=${request.waitSeconds}`;
+    }
+    // Content-Type is deliberately NOT set. fetch derives it from the FormData
+    // body along with the multipart boundary; setting it by hand omits the
+    // boundary and the server cannot parse the body.
+    delete headers["Content-Type"];
+    const response = await fetchWithRetries(client.retries, {
+        url: `${client.serverUrl}${request.path}`,
+        fetchApi: client.fetchApi,
+        init: {
+            method: "POST",
+            headers,
+            body: form,
+        },
+    });
+    if (!response.ok) {
+        // The generated error type, so a caller catches one class of error from
+        // this SDK rather than two depending on which path produced it.
+        throw new ResponseError(response, "Response returned an error code");
+    }
+    const body = await response.json();
+    return response.status === 202
+        ? { status: 202, body: JobAcceptedFromJSON(body) }
+        : { status: 200, body: request.fromJSON(body) };
+}

package/dist/outcome.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Telling a finished result from an accepted job.
+ *
+ * THE BUG THIS EXISTS FOR: every one of these operations can answer 200 with a
+ * result or 202 with a job handle, and the generated code deserializes any 2xx
+ * through the 200 model:
+ *
+ *     return new runtime.JSONApiResponse(response, (j) => ParseResultFromJSON(j));
+ *
+ * So a 202 came back as a `ParseResult` whose every field was `undefined`,
+ * typed as though it were real. That is not an edge case — `waitSeconds: 0` is
+ * the documented way to get a job handle, so the flow the API docs recommend
+ * returned garbage, and TypeScript said it was fine.
+ *
+ * Python is unaffected: its generated code carries a per-status response map
+ * and deserializes 202 to `JobAccepted` correctly.
+ *
+ * Callers discriminate with `isAccepted(outcome)`, which narrows the union.
+ */
+import { type JobAccepted } from "./_generated/models/index.js";
+import type { ApiResponse } from "./_generated/runtime.js";
+/** Either the finished thing, or the handle to follow. */
+export type Outcome<TResult> = {
+    status: 200;
+    body: TResult;
+} | {
+    status: 202;
+    body: JobAccepted;
+};
+/** Narrows an outcome to the still-running case. */
+export declare function isAccepted<TResult>(outcome: Outcome<TResult>): outcome is {
+    status: 202;
+    body: JobAccepted;
+};
+/**
+ * Resolve a generated `*Raw` response into the union.
+ *
+ * The `*Raw` variants are what make this possible at all: the plain ones
+ * return only the deserialized value, with the status already discarded.
+ *
+ * On 202 the body is read from the raw response and run through
+ * `JobAcceptedFromJSON`, rather than through the 200 model the generated
+ * wrapper would have applied.
+ */
+export declare function resolveOutcome<TResult>(response: ApiResponse<TResult>): Promise<Outcome<TResult>>;

package/dist/outcome.js

@@ -0,0 +1,40 @@
+/**
+ * Telling a finished result from an accepted job.
+ *
+ * THE BUG THIS EXISTS FOR: every one of these operations can answer 200 with a
+ * result or 202 with a job handle, and the generated code deserializes any 2xx
+ * through the 200 model:
+ *
+ *     return new runtime.JSONApiResponse(response, (j) => ParseResultFromJSON(j));
+ *
+ * So a 202 came back as a `ParseResult` whose every field was `undefined`,
+ * typed as though it were real. That is not an edge case — `waitSeconds: 0` is
+ * the documented way to get a job handle, so the flow the API docs recommend
+ * returned garbage, and TypeScript said it was fine.
+ *
+ * Python is unaffected: its generated code carries a per-status response map
+ * and deserializes 202 to `JobAccepted` correctly.
+ *
+ * Callers discriminate with `isAccepted(outcome)`, which narrows the union.
+ */
+import { JobAcceptedFromJSON, } from "./_generated/models/index.js";
+/** Narrows an outcome to the still-running case. */
+export function isAccepted(outcome) {
+    return outcome.status === 202;
+}
+/**
+ * Resolve a generated `*Raw` response into the union.
+ *
+ * The `*Raw` variants are what make this possible at all: the plain ones
+ * return only the deserialized value, with the status already discarded.
+ *
+ * On 202 the body is read from the raw response and run through
+ * `JobAcceptedFromJSON`, rather than through the 200 model the generated
+ * wrapper would have applied.
+ */
+export async function resolveOutcome(response) {
+    if (response.raw.status === 202) {
+        return { status: 202, body: JobAcceptedFromJSON(await response.raw.json()) };
+    }
+    return { status: 200, body: await response.value() };
+}

package/dist/retry.d.ts

@@ -0,0 +1,16 @@
+/** Retry policy for the hand-written SDK facade. */
+export interface RetryConfig {
+    maxAttempts?: number;
+    initialDelayMs?: number;
+    maxDelayMs?: number;
+    maxElapsedMs?: number;
+    retryAfterMaxMs?: number;
+}
+export interface RetryRequest {
+    url: string;
+    init: RequestInit;
+    fetchApi?: typeof fetch;
+}
+export type RetryOption = RetryConfig | false | undefined;
+export declare function normalizeRetries(retries: RetryOption): Required<RetryConfig> | undefined;
+export declare function fetchWithRetries(retries: Required<RetryConfig> | undefined, request: RetryRequest): Promise<Response>;

package/dist/retry.js

@@ -0,0 +1,181 @@
+/** Retry policy for the hand-written SDK facade. */
+const DEFAULT_RETRIES = {
+    maxAttempts: 3,
+    initialDelayMs: 250,
+    maxDelayMs: 2000,
+    maxElapsedMs: 10000,
+    retryAfterMaxMs: 2000,
+};
+// Errors that prove the request never left this process, identified by their
+// STRUCTURED code — never by matching text.
+//
+// This used to concatenate `name`, `message` and `code` and look for
+// substrings, which reads any error whose prose happens to contain one of these
+// words as proof of a pre-send failure. On a document API that is not
+// hypothetical: `certificate` was in this set, and "certificate" is a common
+// document type, so an error mentioning `certificate-of-insurance.pdf` would
+// have retried a `POST /api/v2/parse` the service had already accepted —
+// a second paid job, the first left running unwatched. Caught in review of the
+// PR that widened this allowance to every write.
+//
+// `message` is attacker- and upstream-controlled in a way `code` is not, so
+// only `code`/`errno` is consulted. UND_ERR_CONNECT_TIMEOUT is undici's
+// connect-phase timeout: a connection never established, not a read that timed
+// out. TLS is deliberately absent — see the Python twin's docstring: the same
+// error shape covers a handshake failure and a TLS failure discovered while
+// reading a response on a reused connection, and nothing distinguishes them.
+const BEFORE_SEND_CODES = new Set([
+    "ECONNREFUSED",
+    "ENOTFOUND",
+    "EAI_AGAIN",
+    "UND_ERR_CONNECT_TIMEOUT",
+]);
+const SAFE_METHODS = new Set(["GET", "DELETE"]);
+const RETRYABLE_STATUSES = new Set([429, 500, 502, 503, 504]);
+export function normalizeRetries(retries) {
+    if (retries === false)
+        return undefined;
+    return { ...DEFAULT_RETRIES, ...(retries ?? {}) };
+}
+export async function fetchWithRetries(retries, request) {
+    const fetchApi = request.fetchApi ?? fetch;
+    if (retries === undefined || retries.maxAttempts <= 1) {
+        return fetchApi(request.url, request.init);
+    }
+    const method = (request.init.method ?? "GET").toUpperCase();
+    const signal = request.init.signal ?? undefined;
+    const started = Date.now();
+    let attempt = 1;
+    for (;;) {
+        try {
+            const response = await fetchApi(request.url, cloneInit(request.init));
+            if (!shouldRetryStatus(method, response.status) || !canRetry(retries, attempt, started)) {
+                return response;
+            }
+            await drain(response);
+            await sleepFor(retries, attempt, response.headers.get("Retry-After"), started, signal);
+            if (!canRetry(retries, attempt, started)) {
+                return response;
+            }
+        }
+        catch (error) {
+            if (!shouldRetryError(method, error, signal) || !canRetry(retries, attempt, started)) {
+                throw error;
+            }
+            await sleepFor(retries, attempt, undefined, started, signal);
+            if (!canRetry(retries, attempt, started)) {
+                throw error;
+            }
+        }
+        attempt += 1;
+    }
+}
+function shouldRetryStatus(method, status) {
+    return SAFE_METHODS.has(method) && RETRYABLE_STATUSES.has(status);
+}
+function shouldRetryError(method, error, signal) {
+    // A caller-initiated abort (e.g. cancelling jobs.stream) is not a transport
+    // failure — retrying it would repeat a fetch the caller already cancelled
+    // and delay their cancellation behind a full backoff sleep.
+    if (isCallerAbort(error, signal)) {
+        return false;
+    }
+    if (SAFE_METHODS.has(method)) {
+        return true;
+    }
+    // Everything else gets exactly one allowance: a failure proving the request
+    // never arrived. That covers the non-idempotent submits — POST /api/v2/parse,
+    // /api/v2/extract, /api/v2/upload — where a retry after a read timeout or 5xx
+    // could create a second paid job and leave the first unwatched. It also
+    // covers every OTHER method this policy does not name, such as
+    // POST /api/v2/jobs/{id}/cancel.
+    //
+    // Those used to differ, and backwards: the three submits got the before-send
+    // allowance and anything unnamed got nothing at all, so an unnamed POST was
+    // treated as more dangerous than a POST we know creates a paid job. A request
+    // that never left cannot have duplicated an effect no matter what the
+    // operation does, so there is nothing for the stricter case to protect.
+    // `jobs.cancel` failing once against a preview with no retry is what surfaced
+    // it (2026-09-10).
+    //
+    // Deliberately NOT widened past that. A 5xx or a read timeout means the
+    // request may well have arrived, and whether a repeated cancel is harmless is
+    // platform-api's contract to state, not this client's to assume.
+    return isBeforeSendError(error);
+}
+function isCallerAbort(error, signal) {
+    if (signal?.aborted || (signal !== undefined && Object.is(error, signal.reason))) {
+        return true;
+    }
+    return error instanceof Error && error.name === "AbortError";
+}
+function isBeforeSendError(error) {
+    let current = error;
+    const seen = new Set();
+    while (current instanceof Error && !seen.has(current)) {
+        seen.add(current);
+        const code = current.code ?? current.errno;
+        if (typeof code === "string" && BEFORE_SEND_CODES.has(code.toUpperCase())) {
+            return true;
+        }
+        current = current.cause;
+    }
+    return false;
+}
+function canRetry(retries, attempt, started) {
+    return attempt < retries.maxAttempts && Date.now() - started < retries.maxElapsedMs;
+}
+async function sleepFor(retries, attempt, retryAfter, started, signal) {
+    const parsed = retryAfterDelayMs(retryAfter);
+    const delay = parsed === undefined
+        ? Math.min(retries.maxDelayMs, retries.initialDelayMs * 2 ** (attempt - 1)) *
+            (1 + Math.random() * 0.2)
+        : Math.min(parsed, retries.retryAfterMaxMs);
+    const remaining = retries.maxElapsedMs - (Date.now() - started);
+    const boundedDelay = Math.max(0, Math.min(delay, remaining));
+    if (!signal) {
+        await new Promise((resolve) => setTimeout(resolve, boundedDelay));
+        return;
+    }
+    // An abort mid-backoff should cut the sleep short rather than making the
+    // caller wait out a full delay before their cancellation takes effect.
+    await new Promise((resolve) => {
+        if (signal.aborted) {
+            resolve();
+            return;
+        }
+        const timer = setTimeout(() => {
+            signal.removeEventListener("abort", onAbort);
+            resolve();
+        }, boundedDelay);
+        const onAbort = () => {
+            clearTimeout(timer);
+            resolve();
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+    });
+}
+function retryAfterDelayMs(value) {
+    if (!value)
+        return undefined;
+    const seconds = Number(value);
+    if (Number.isFinite(seconds))
+        return Math.max(0, seconds * 1000);
+    const date = Date.parse(value);
+    return Number.isNaN(date) ? undefined : Math.max(0, date - Date.now());
+}
+async function drain(response) {
+    try {
+        await response.arrayBuffer();
+    }
+    catch {
+        // best effort before retrying
+    }
+}
+function cloneInit(init) {
+    const body = init.body;
+    if (body instanceof ReadableStream) {
+        throw new TypeError("streaming request bodies cannot be retried");
+    }
+    return { ...init };
+}

package/dist/sse.d.ts

@@ -0,0 +1,50 @@
+/**
+ * The job progress stream.
+ *
+ * `GET /api/v2/jobs/{jobId}` with `Accept: text/event-stream` is the same
+ * resource as the JSON representation, selected by Accept rather than by a
+ * second route. Both are declared on that operation's 200 in openapi.yaml.
+ *
+ * THE EVENT VOCABULARY is fixed by the service and pinned by its own
+ * `tests/test_sse.py`. Mirrored here deliberately rather than inferred:
+ *
+ *     event: status   data: {"id", "status"}     on every public status CHANGE
+ *     : keep-alive                               a comment per unchanged poll
+ *     event: result   data: a JobResult          exactly once, then the stream ends
+ *     event: error    data: {"code", "message"}  exactly once instead, on failure
+ *
+ * Keep-alive comments are consumed and never yielded — they carry nothing a
+ * caller can act on, and surfacing them would make every consumer filter them.
+ *
+ * Written by hand rather than with `EventSource`, for two reasons that both
+ * matter: EventSource cannot set request headers at all, so it could not send
+ * the credential, and it reconnects automatically on close — which for a
+ * stream that ENDS on its terminal event means silently re-running the whole
+ * thing forever.
+ */
+import { type RetryConfig } from "./retry.js";
+/** One event from a job stream. */
+export interface JobEvent {
+    /** The vocabulary name: `status`, `result`, or `error`. */
+    event: string;
+    /** The decoded JSON payload, or the raw string if it was not JSON. */
+    data: unknown;
+}
+/** Whether the stream ends after this event. */
+export declare function isTerminal(event: JobEvent): boolean;
+export interface StreamOptions {
+    url: string;
+    headers: Record<string, string>;
+    signal?: AbortSignal;
+    fetchApi?: typeof fetch;
+    retries?: Required<RetryConfig>;
+}
+/**
+ * Yield events until the stream closes.
+ *
+ * A non-2xx response throws rather than yielding an `error` event: an `error`
+ * EVENT means the job failed, an error STATUS means the request did, and
+ * collapsing the two would let an expired credential look like a failed
+ * document.
+ */
+export declare function streamJobEvents(options: StreamOptions): AsyncGenerator<JobEvent, void, undefined>;

package/dist/sse.js

@@ -0,0 +1,140 @@
+/**
+ * The job progress stream.
+ *
+ * `GET /api/v2/jobs/{jobId}` with `Accept: text/event-stream` is the same
+ * resource as the JSON representation, selected by Accept rather than by a
+ * second route. Both are declared on that operation's 200 in openapi.yaml.
+ *
+ * THE EVENT VOCABULARY is fixed by the service and pinned by its own
+ * `tests/test_sse.py`. Mirrored here deliberately rather than inferred:
+ *
+ *     event: status   data: {"id", "status"}     on every public status CHANGE
+ *     : keep-alive                               a comment per unchanged poll
+ *     event: result   data: a JobResult          exactly once, then the stream ends
+ *     event: error    data: {"code", "message"}  exactly once instead, on failure
+ *
+ * Keep-alive comments are consumed and never yielded — they carry nothing a
+ * caller can act on, and surfacing them would make every consumer filter them.
+ *
+ * Written by hand rather than with `EventSource`, for two reasons that both
+ * matter: EventSource cannot set request headers at all, so it could not send
+ * the credential, and it reconnects automatically on close — which for a
+ * stream that ENDS on its terminal event means silently re-running the whole
+ * thing forever.
+ */
+import { fetchWithRetries } from "./retry.js";
+/** Whether the stream ends after this event. */
+export function isTerminal(event) {
+    return event.event === "result" || event.event === "error";
+}
+/**
+ * Yield events until the stream closes.
+ *
+ * A non-2xx response throws rather than yielding an `error` event: an `error`
+ * EVENT means the job failed, an error STATUS means the request did, and
+ * collapsing the two would let an expired credential look like a failed
+ * document.
+ */
+export async function* streamJobEvents(options) {
+    const response = await fetchWithRetries(options.retries, {
+        url: options.url,
+        fetchApi: options.fetchApi,
+        init: {
+            method: "GET",
+            headers: { ...options.headers, Accept: "text/event-stream" },
+            signal: options.signal,
+        },
+    });
+    if (!response.ok) {
+        const body = await response.text();
+        throw new Error(`job stream request failed with ${response.status}: ${body.slice(0, 500)}`);
+    }
+    if (!response.body) {
+        throw new Error("job stream response carried no body");
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    // Accumulated, not dispatched per line. One event may carry SEVERAL `data:`
+    // lines, which the SSE format joins with a newline and delivers as a single
+    // event at the blank line. Dispatching on each `data:` line split one
+    // multi-line payload into several events, each holding a fragment of JSON
+    // that would not parse.
+    let eventName;
+    let dataLines = [];
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            // `stream: true` matters: a chunk boundary can fall inside a multi-byte
+            // character, and decoding each chunk independently would corrupt it.
+            buffer += decoder.decode(value, { stream: true });
+            let newline;
+            while ((newline = buffer.indexOf("\n")) !== -1) {
+                const line = buffer.slice(0, newline).replace(/\r$/, "");
+                buffer = buffer.slice(newline + 1);
+                if (line === "") {
+                    // The blank line is what dispatches. Nothing to dispatch when no
+                    // data arrived, which is the case for a keep-alive.
+                    if (dataLines.length > 0) {
+                        const event = {
+                            event: eventName ?? "message",
+                            data: decode(dataLines.join("\n")),
+                        };
+                        yield event;
+                        if (isTerminal(event))
+                            return;
+                    }
+                    eventName = undefined;
+                    dataLines = [];
+                    continue;
+                }
+                if (line.startsWith(":")) {
+                    continue; // keep-alive comment
+                }
+                if (line.startsWith("event:")) {
+                    eventName = line.slice("event:".length).trim();
+                    continue;
+                }
+                if (line.startsWith("data:")) {
+                    // One leading space after the colon is framing, not payload;
+                    // anything past it is data and is preserved.
+                    const value = line.slice("data:".length);
+                    dataLines.push(value.startsWith(" ") ? value.slice(1) : value);
+                }
+            }
+        }
+    }
+    finally {
+        // Cancel BEFORE releasing the lock. A terminal event returns early, and a
+        // caller can break out of the loop at any point, so the body is usually
+        // half read when we get here. releaseLock() alone only detaches the
+        // reader — the response stays active and holds its connection.
+        //
+        // The rejection is swallowed because arriving here with an already-closed
+        // or errored stream is normal, and not something a caller can act on.
+        try {
+            await reader.cancel();
+        }
+        catch {
+            // already closed
+        }
+        reader.releaseLock();
+    }
+}
+/**
+ * Decode a data payload, tolerating a non-JSON one.
+ *
+ * Every event this service sends carries JSON, but a proxy injecting a
+ * plain-text notice should surface as that text rather than crash the consumer
+ * in the middle of a job.
+ */
+function decode(payload) {
+    try {
+        return JSON.parse(payload);
+    }
+    catch {
+        return payload;
+    }
+}

package/dist/version.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The published package version.
+ *
+ * Kept in step with `services/transform-api`'s `[project].version` and with
+ * the Python SDK — all three describe one contract revision. Agreement is
+ * asserted by `tests/version.test.ts` rather than read from package.json at
+ * runtime, because importing JSON differs across module systems and bundlers
+ * and would make this module's behaviour depend on how it was built.
+ */
+export declare const VERSION = "0.18.18";

package/dist/version.js

@@ -0,0 +1,10 @@
+/**
+ * The published package version.
+ *
+ * Kept in step with `services/transform-api`'s `[project].version` and with
+ * the Python SDK — all three describe one contract revision. Agreement is
+ * asserted by `tests/version.test.ts` rather than read from package.json at
+ * runtime, because importing JSON differs across module systems and bundlers
+ * and would make this module's behaviour depend on how it was built.
+ */
+export const VERSION = "0.18.18";