@cueai/omni-reader-mcp 1.0.0

package/dist/iiis-client.js

@@ -0,0 +1,694 @@
+import { createHash } from "node:crypto";
+import { GRANTED_STREAM_PROTOCOL_VERSION, RESULT_CHUNK_MAX_BYTES, } from "./constants.js";
+import { OmniBridgeError } from "./errors.js";
+import { createMultipartBody } from "./multipart-body.js";
+import { NOOP_PROGRESS } from "./progress.js";
+class TransportFailure extends Error {
+}
+const ACTIVE_STATUSES = new Set(["CLAIMED", "UPLOADING", "PROCESSING", "SETTLING"]);
+const TERMINAL_STATUSES = new Set([
+    "EXPIRED",
+    "SETTLEMENT_DENIED",
+    "FAILED",
+    "CANCELED",
+    "DELIVERY_EXPIRED",
+    "DELIVERED",
+]);
+const RECOVERABLE_SETTLEMENT_ERRORS = new Set([
+    "SETTLEMENT_IN_PROGRESS",
+    "SETTLEMENT_RETRYABLE",
+    "SETTLEMENT_JOURNAL_UNAVAILABLE",
+    "OPERATION_STORE_UNAVAILABLE",
+    "RESULT_STORAGE_UNAVAILABLE",
+    "CUBE_CONTROL_UNAVAILABLE",
+]);
+const BASE64URL_PATTERN = /^[A-Za-z0-9_-]+$/;
+const SHA256_PATTERN = /^sha256:[0-9a-f]{64}$/;
+function bridgeError(code, message, facts = {}) {
+    return new OmniBridgeError({
+        code,
+        message,
+        fileUploaded: facts.fileUploaded ?? false,
+        billed: facts.billed ?? false,
+        contentReleased: facts.contentReleased ?? false,
+        retryable: facts.retryable ?? false,
+    });
+}
+function recoveryFacts(value) {
+    return {
+        fileUploaded: value?.fileUploaded ?? false,
+        billed: value?.billed ?? false,
+        contentReleased: value?.contentReleased ?? false,
+    };
+}
+function mergeRecoveryFacts(left, right) {
+    return {
+        fileUploaded: left.fileUploaded || right.fileUploaded === true,
+        billed: left.billed || right.billed === true,
+        contentReleased: left.contentReleased || right.contentReleased === true,
+    };
+}
+function errorWithRecoveryFacts(error, facts) {
+    return bridgeError(error.code, error.message, {
+        fileUploaded: error.fileUploaded || facts.fileUploaded,
+        billed: error.billed || facts.billed,
+        contentReleased: error.contentReleased || facts.contentReleased,
+        retryable: error.retryable,
+    });
+}
+function resultStorageUnavailable(facts) {
+    return bridgeError("RESULT_STORAGE_UNAVAILABLE", "Released result delivery did not complete.", { ...facts, retryable: true });
+}
+function canceledAfterUpload() {
+    return bridgeError("CANCELED_AFTER_UPLOAD_STARTED", "The parse operation was canceled after upload started.", { fileUploaded: true });
+}
+function throwIfCanceled(input) {
+    if (input.signal?.aborted)
+        throw canceledAfterUpload();
+}
+function operationUrl(input, suffix = "") {
+    const base = new URL(input.uploadUrl);
+    if (base.protocol !== "https:" || base.username !== "" || base.password !== "") {
+        throw bridgeError("INSECURE_IIIS_URL", "The IIIS upload endpoint must use credential-free HTTPS.");
+    }
+    return new URL(`operations/${encodeURIComponent(input.operationId)}${suffix}`, base).toString();
+}
+function operationHeaders(input) {
+    return { authorization: `Bearer ${input.operationToken}` };
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function safeInteger(value, minimum = 0) {
+    return typeof value === "number"
+        && Number.isSafeInteger(value)
+        && value >= minimum;
+}
+function validateProtocol(event) {
+    if (event.protocol_version !== GRANTED_STREAM_PROTOCOL_VERSION) {
+        throw bridgeError("PROTOCOL_MISMATCH", "IIIS returned an unsupported protocol version.");
+    }
+}
+function progressValue(event) {
+    validateProtocol(event);
+    if (!safeInteger(event.done) || !safeInteger(event.total)) {
+        throw bridgeError("INVALID_PROGRESS_EVENT", "IIIS returned an invalid progress event.");
+    }
+    return {
+        done: event.done,
+        total: event.total,
+        message: String(event.message ?? event.stage ?? "Parsing"),
+    };
+}
+function monotonicProgress(sink) {
+    let last = 0;
+    return {
+        async report(progress, total, message) {
+            const next = Math.min(total, Math.max(last, progress));
+            last = next;
+            await sink.report(next, total, message);
+        },
+    };
+}
+async function errorFromResponse(response, input) {
+    try {
+        const body = await response.json();
+        if (isRecord(body) && typeof body.code === "string" && typeof body.message === "string") {
+            return bridgeError(body.code, body.message, {
+                fileUploaded: body.file_uploaded === true,
+                billed: body.billed === true,
+                contentReleased: body.content_released === true,
+                retryable: body.retryable === true,
+            });
+        }
+    }
+    catch {
+        throwIfCanceled(input);
+        // Never expose untrusted response text.
+    }
+    return bridgeError("IIIS_UNAVAILABLE", "IIIS could not complete the parse request.", {
+        retryable: response.status >= 500,
+    });
+}
+async function protocolJson(response, input, description) {
+    try {
+        return await response.json();
+    }
+    catch {
+        throwIfCanceled(input);
+        throw bridgeError("PROTOCOL_MISMATCH", `IIIS returned invalid ${description} JSON.`);
+    }
+}
+async function* sseEvents(response) {
+    if (response.body === null)
+        throw new TransportFailure("missing SSE body");
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffered = "";
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            buffered += decoder.decode(value, { stream: !done }).replace(/\r\n/g, "\n");
+            let boundary;
+            while ((boundary = buffered.indexOf("\n\n")) >= 0) {
+                const block = buffered.slice(0, boundary);
+                buffered = buffered.slice(boundary + 2);
+                if (block.startsWith(":"))
+                    continue;
+                const data = block.split("\n")
+                    .filter((line) => line.startsWith("data:"))
+                    .map((line) => line.slice(5).trimStart())
+                    .join("\n");
+                if (data.length === 0)
+                    continue;
+                let parsed;
+                try {
+                    parsed = JSON.parse(data);
+                }
+                catch {
+                    throw bridgeError("INVALID_SSE_EVENT", "IIIS returned an invalid progress event.");
+                }
+                if (!isRecord(parsed)) {
+                    throw bridgeError("INVALID_SSE_EVENT", "IIIS returned an invalid progress event.");
+                }
+                yield parsed;
+            }
+            if (done) {
+                if (buffered.trim().length !== 0)
+                    throw new TransportFailure("truncated SSE event");
+                break;
+            }
+        }
+    }
+    catch (error) {
+        if (error instanceof OmniBridgeError || error instanceof TransportFailure)
+            throw error;
+        throw new TransportFailure("SSE disconnected");
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+export class IiisClient {
+    #fetch;
+    #pollIntervalMs;
+    #maxPolls;
+    constructor(options = {}) {
+        this.#fetch = options.fetchImpl ?? fetch;
+        this.#pollIntervalMs = Math.max(0, options.pollIntervalMs ?? 250);
+        this.#maxPolls = Math.max(1, options.maxPolls ?? 240);
+    }
+    async uploadAndWait(input) {
+        const progress = monotonicProgress(input.progress ?? NOOP_PROGRESS);
+        try {
+            return await this.#uploadOnce(input, progress);
+        }
+        catch (error) {
+            if (error instanceof OmniBridgeError) {
+                if (error.fileUploaded
+                    && error.retryable
+                    && RECOVERABLE_SETTLEMENT_ERRORS.has(error.code)) {
+                    throwIfCanceled(input);
+                    return this.#recover(input, false, progress, recoveryFacts(error));
+                }
+                throw error;
+            }
+            throwIfCanceled(input);
+            return this.#recover(input, true, progress);
+        }
+    }
+    async downloadResult(input) {
+        throwIfCanceled(input);
+        const confirmedFacts = recoveryFacts({
+            fileUploaded: true,
+            billed: true,
+            contentReleased: true,
+        });
+        try {
+            await input.retention.reset();
+        }
+        catch (error) {
+            try {
+                await input.retention.abort();
+            }
+            catch {
+                // Preserve the primary reset failure and its confirmed release facts.
+            }
+            if (input.signal?.aborted) {
+                throw errorWithRecoveryFacts(canceledAfterUpload(), confirmedFacts);
+            }
+            if (error instanceof OmniBridgeError) {
+                throw errorWithRecoveryFacts(error, confirmedFacts);
+            }
+            throw resultStorageUnavailable(confirmedFacts);
+        }
+        let response;
+        try {
+            response = await this.#fetch(operationUrl(input, "/result"), {
+                headers: operationHeaders(input),
+                signal: input.signal,
+            });
+        }
+        catch {
+            if (input.signal?.aborted) {
+                throw errorWithRecoveryFacts(canceledAfterUpload(), confirmedFacts);
+            }
+            throw bridgeError("IIIS_UNAVAILABLE", "IIIS result recovery failed.", {
+                ...confirmedFacts,
+                retryable: true,
+            });
+        }
+        if (!response.ok) {
+            throw errorWithRecoveryFacts(await errorFromResponse(response, input), confirmedFacts);
+        }
+        const declared = Number(response.headers.get("content-length"));
+        if (!safeInteger(declared)) {
+            throw bridgeError("RESULT_INTEGRITY_FAILED", "The recovered result length is invalid.", {
+                ...confirmedFacts,
+            });
+        }
+        const start = {
+            operationId: input.operationId,
+            resultBytes: declared,
+            mediaType: response.headers.get("content-type") ?? "application/octet-stream",
+            source: "recovery",
+        };
+        const hash = createHash("sha256");
+        let received = 0;
+        let completed = false;
+        try {
+            await input.retention.begin(start);
+            if (response.body === null) {
+                if (declared !== 0)
+                    throw new TransportFailure("missing result body");
+            }
+            else {
+                const reader = response.body.getReader();
+                try {
+                    while (true) {
+                        const { done, value } = await reader.read();
+                        if (done)
+                            break;
+                        throwIfCanceled(input);
+                        received += value.byteLength;
+                        if (received > declared) {
+                            throw bridgeError("RESULT_INTEGRITY_FAILED", "The recovered result exceeded its declared length.", {
+                                ...confirmedFacts,
+                            });
+                        }
+                        hash.update(value);
+                        await input.retention.write(value);
+                        throwIfCanceled(input);
+                    }
+                }
+                finally {
+                    reader.releaseLock();
+                }
+            }
+            if (received !== declared) {
+                throw bridgeError("RESULT_INTEGRITY_FAILED", "The recovered result length is invalid.", {
+                    ...confirmedFacts,
+                });
+            }
+            const metadata = {
+                ...start,
+                resultDigest: `sha256:${hash.digest("hex")}`,
+            };
+            await input.retention.complete(metadata);
+            throwIfCanceled(input);
+            completed = true;
+            return metadata;
+        }
+        catch (error) {
+            if (!completed) {
+                try {
+                    await input.retention.abort();
+                }
+                catch {
+                    // Preserve the primary recovery failure and its confirmed release facts.
+                }
+            }
+            if (input.signal?.aborted) {
+                throw errorWithRecoveryFacts(canceledAfterUpload(), confirmedFacts);
+            }
+            if (error instanceof OmniBridgeError) {
+                throw errorWithRecoveryFacts(error, confirmedFacts);
+            }
+            throw resultStorageUnavailable(confirmedFacts);
+        }
+    }
+    async ack(input) {
+        throwIfCanceled(input);
+        let response;
+        try {
+            response = await this.#fetch(operationUrl(input, "/ack"), {
+                method: "POST",
+                headers: operationHeaders(input),
+                signal: input.signal,
+            });
+        }
+        catch {
+            throwIfCanceled(input);
+            throw bridgeError("IIIS_UNAVAILABLE", "IIIS could not acknowledge the retained result.", {
+                fileUploaded: true,
+                billed: true,
+                contentReleased: true,
+                retryable: true,
+            });
+        }
+        if (response.status !== 204)
+            throw await errorFromResponse(response, input);
+    }
+    async #uploadOnce(input, progress) {
+        const body = createMultipartBody(input.openedFile, {
+            signal: input.signal,
+            onProgress: async (bytes) => {
+                const scaled = input.openedFile.size === 0
+                    ? 40
+                    : Math.floor(bytes * 40 / input.openedFile.size);
+                await progress.report(scaled, 100, `Uploading ${bytes}/${input.openedFile.size} bytes`);
+            },
+        });
+        let response;
+        try {
+            response = await this.#fetch(input.uploadUrl, {
+                method: "POST",
+                headers: {
+                    authorization: `Bearer ${input.parseGrant}`,
+                    "content-type": body.contentType,
+                    "content-length": String(body.contentLength),
+                },
+                body: body.stream,
+                signal: input.signal,
+                duplex: "half",
+            });
+        }
+        catch (error) {
+            if (error instanceof OmniBridgeError)
+                throw error;
+            if (input.signal?.aborted) {
+                throw bridgeError("CANCELED_BEFORE_UPLOAD_COMPLETE", "The upload was canceled.");
+            }
+            throw new TransportFailure("upload transport failed");
+        }
+        if (!response.ok)
+            throw await errorFromResponse(response, input);
+        return this.#consumeReleasedSse(input, response, progress);
+    }
+    async #consumeReleasedSse(input, response, progress) {
+        let released;
+        let completedMetadata;
+        let offset = 0;
+        let complete = false;
+        let streamFacts = recoveryFacts();
+        const hash = createHash("sha256");
+        try {
+            for await (const event of sseEvents(response)) {
+                throwIfCanceled(input);
+                if (complete) {
+                    const code = event.type === "result_chunk" ? "INVALID_RESULT_CHUNK" : "INVALID_RESULT_EVENT_ORDER";
+                    throw bridgeError(code, "IIIS sent an event after result completion.", {
+                        fileUploaded: true,
+                        billed: true,
+                        contentReleased: true,
+                    });
+                }
+                if (event.type === "progress") {
+                    const parsed = progressValue(event);
+                    const scaled = parsed.total > 0
+                        ? 40 + Math.floor(Math.min(parsed.done / parsed.total, 1) * 60)
+                        : 40;
+                    await progress.report(scaled, 100, parsed.message);
+                    continue;
+                }
+                if (event.type === "error") {
+                    throw bridgeError(String(event.code ?? "IIIS_PARSE_FAILED"), String(event.message ?? "IIIS parsing failed."), {
+                        fileUploaded: event.file_uploaded === true,
+                        billed: event.billed === true,
+                        contentReleased: event.content_released === true,
+                        retryable: event.retryable === true,
+                    });
+                }
+                if (event.type === "released") {
+                    validateProtocol(event);
+                    if (released !== undefined
+                        || event.operation_id !== input.operationId
+                        || event.billed !== true
+                        || event.content_released !== true
+                        || !safeInteger(event.result_bytes)
+                        || typeof event.media_type !== "string"
+                        || event.media_type.length === 0
+                        || typeof event.result_digest !== "string"
+                        || !SHA256_PATTERN.test(event.result_digest)) {
+                        throw bridgeError("INVALID_RELEASE_EVENT", "IIIS returned an invalid release event.");
+                    }
+                    released = {
+                        resultBytes: event.result_bytes,
+                        mediaType: event.media_type,
+                        resultDigest: event.result_digest,
+                    };
+                    streamFacts = recoveryFacts({
+                        fileUploaded: true,
+                        billed: true,
+                        contentReleased: true,
+                    });
+                    await input.retention.begin({
+                        operationId: input.operationId,
+                        resultBytes: released.resultBytes,
+                        mediaType: released.mediaType,
+                        source: "sse",
+                    });
+                    continue;
+                }
+                if (event.type === "result_chunk") {
+                    validateProtocol(event);
+                    if (released === undefined) {
+                        throw bridgeError("RESULT_BEFORE_RELEASE", "IIIS sent result bytes before billing release.");
+                    }
+                    const encoded = event.data;
+                    if (event.operation_id !== input.operationId
+                        || !safeInteger(event.offset)
+                        || !safeInteger(event.decoded_bytes, 1)
+                        || event.decoded_bytes > RESULT_CHUNK_MAX_BYTES
+                        || typeof encoded !== "string"
+                        || !BASE64URL_PATTERN.test(encoded)) {
+                        if (safeInteger(event.decoded_bytes, 1) && event.decoded_bytes > RESULT_CHUNK_MAX_BYTES) {
+                            throw bridgeError("RESULT_CHUNK_TOO_LARGE", "IIIS returned an oversized result chunk.");
+                        }
+                        throw bridgeError("INVALID_RESULT_CHUNK", "IIIS returned an invalid result chunk.");
+                    }
+                    const decoded = Buffer.from(encoded, "base64url");
+                    if (decoded.toString("base64url") !== encoded
+                        || event.offset !== offset
+                        || event.decoded_bytes !== decoded.length
+                        || offset + decoded.length > released.resultBytes) {
+                        throw bridgeError("INVALID_RESULT_CHUNK", "IIIS returned an invalid result chunk.");
+                    }
+                    hash.update(decoded);
+                    await input.retention.write(decoded);
+                    offset += decoded.length;
+                    continue;
+                }
+                if (event.type === "result_complete") {
+                    validateProtocol(event);
+                    if (released === undefined
+                        || event.operation_id !== input.operationId
+                        || !safeInteger(event.result_bytes)
+                        || event.result_bytes !== released.resultBytes
+                        || typeof event.result_digest !== "string"
+                        || event.result_digest !== released.resultDigest
+                        || offset !== released.resultBytes) {
+                        throw bridgeError("RESULT_INTEGRITY_FAILED", "IIIS result metadata did not match.");
+                    }
+                    const computedDigest = `sha256:${hash.digest("hex")}`;
+                    if (computedDigest !== released.resultDigest) {
+                        throw bridgeError("RESULT_INTEGRITY_FAILED", "IIIS result verification failed.");
+                    }
+                    const metadata = {
+                        operationId: input.operationId,
+                        resultBytes: released.resultBytes,
+                        mediaType: released.mediaType,
+                        resultDigest: released.resultDigest,
+                        source: "sse",
+                    };
+                    await input.retention.complete(metadata);
+                    throwIfCanceled(input);
+                    completedMetadata = metadata;
+                    complete = true;
+                    continue;
+                }
+                throw bridgeError("INVALID_SSE_EVENT", "IIIS returned an unsupported progress event.");
+            }
+            if (completedMetadata !== undefined)
+                return completedMetadata;
+            throw new TransportFailure("SSE ended before completion");
+        }
+        catch (error) {
+            const facts = error instanceof OmniBridgeError
+                ? mergeRecoveryFacts(streamFacts, recoveryFacts(error))
+                : streamFacts;
+            try {
+                await input.retention.abort();
+            }
+            catch {
+                // Preserve the primary delivery failure and its confirmed release facts.
+            }
+            if (input.signal?.aborted) {
+                throw errorWithRecoveryFacts(canceledAfterUpload(), facts);
+            }
+            if (error instanceof OmniBridgeError) {
+                throw errorWithRecoveryFacts(error, facts);
+            }
+            if (facts.contentReleased) {
+                throw resultStorageUnavailable(facts);
+            }
+            throw error;
+        }
+    }
+    async #status(input) {
+        throwIfCanceled(input);
+        let response;
+        try {
+            response = await this.#fetch(operationUrl(input), {
+                headers: operationHeaders(input),
+                signal: input.signal,
+            });
+        }
+        catch {
+            throwIfCanceled(input);
+            throw bridgeError("IIIS_UNAVAILABLE", "IIIS operation status is unavailable.", { retryable: true });
+        }
+        if (!response.ok)
+            throw await errorFromResponse(response, input);
+        const value = await protocolJson(response, input, "operation status");
+        if (!isRecord(value)
+            || value.protocol_version !== GRANTED_STREAM_PROTOCOL_VERSION
+            || value.operation_id !== input.operationId
+            || typeof value.status !== "string"
+            || typeof value.parser_started !== "boolean"
+            || typeof value.file_uploaded !== "boolean"
+            || typeof value.billed !== "boolean"
+            || typeof value.content_released !== "boolean"
+            || typeof value.retryable !== "boolean"
+            || !(value.expires_at === null || typeof value.expires_at === "string")) {
+            throw bridgeError("PROTOCOL_MISMATCH", "IIIS returned an invalid operation status.");
+        }
+        return value;
+    }
+    async #events(input, afterSequence) {
+        throwIfCanceled(input);
+        let response;
+        try {
+            response = await this.#fetch(operationUrl(input, `/events?after_sequence=${afterSequence}`), { headers: operationHeaders(input), signal: input.signal });
+        }
+        catch {
+            throwIfCanceled(input);
+            throw bridgeError("IIIS_UNAVAILABLE", "IIIS operation events are unavailable.", { retryable: true });
+        }
+        if (!response.ok)
+            throw await errorFromResponse(response, input);
+        const value = await protocolJson(response, input, "operation events");
+        if (!isRecord(value)
+            || value.protocol_version !== GRANTED_STREAM_PROTOCOL_VERSION
+            || value.operation_id !== input.operationId
+            || typeof value.status !== "string"
+            || value.after_sequence !== afterSequence
+            || !safeInteger(value.next_sequence)
+            || value.next_sequence < afterSequence
+            || !Array.isArray(value.events)) {
+            throw bridgeError("PROTOCOL_MISMATCH", "IIIS returned an invalid operation event page.");
+        }
+        let expected = afterSequence + 1;
+        const events = [];
+        for (const raw of value.events) {
+            if (!isRecord(raw) || raw.sequence !== expected || raw.type !== "progress") {
+                throw bridgeError("EVENT_CURSOR_EXPIRED", "IIIS returned a non-contiguous operation event page.");
+            }
+            progressValue(raw);
+            events.push(raw);
+            expected += 1;
+        }
+        const expectedNext = events.length === 0 ? afterSequence : expected - 1;
+        if (value.next_sequence !== expectedNext) {
+            throw bridgeError("EVENT_CURSOR_EXPIRED", "IIIS returned an invalid operation event cursor.");
+        }
+        return { status: value.status, nextSequence: value.next_sequence, events };
+    }
+    async #recover(input, mayRetryUpload, progress, initialFacts = recoveryFacts()) {
+        let eventCursor = 0;
+        let parserStartedReported = false;
+        let facts = initialFacts;
+        for (let poll = 0; poll < this.#maxPolls; poll += 1) {
+            try {
+                throwIfCanceled(input);
+                const status = await this.#status(input);
+                facts = mergeRecoveryFacts(facts, {
+                    fileUploaded: status.file_uploaded,
+                    billed: status.billed,
+                    contentReleased: status.content_released,
+                });
+                if (status.parser_started && !parserStartedReported) {
+                    await progress.report(45, 100, "Parser started");
+                    parserStartedReported = true;
+                }
+                if (status.status === "ISSUED" && mayRetryUpload && Date.parse(input.expiresAt) > Date.now()) {
+                    try {
+                        return await this.#uploadOnce(input, progress);
+                    }
+                    catch (error) {
+                        if (error instanceof OmniBridgeError)
+                            throw error;
+                        throwIfCanceled(input);
+                        mayRetryUpload = false;
+                    }
+                }
+                else if (status.status === "RELEASED") {
+                    return await this.downloadResult(input);
+                }
+                else if (ACTIVE_STATUSES.has(status.status)) {
+                    const page = await this.#events(input, eventCursor);
+                    for (const event of page.events) {
+                        const parsed = progressValue(event);
+                        const scaled = parsed.total > 0
+                            ? 40 + Math.floor(Math.min(parsed.done / parsed.total, 1) * 60)
+                            : 40;
+                        await progress.report(scaled, 100, parsed.message);
+                    }
+                    eventCursor = page.nextSequence;
+                }
+                else if (TERMINAL_STATUSES.has(status.status)) {
+                    throw bridgeError(status.status, `The IIIS operation ended with status ${status.status}.`, {
+                        fileUploaded: status.file_uploaded,
+                        billed: status.billed,
+                        contentReleased: status.content_released,
+                        retryable: status.retryable,
+                    });
+                }
+                else if (status.status !== "ISSUED") {
+                    throw bridgeError("PROTOCOL_MISMATCH", "IIIS returned an unsupported operation status.");
+                }
+                if (this.#pollIntervalMs > 0) {
+                    await new Promise((resolve) => setTimeout(resolve, this.#pollIntervalMs));
+                }
+            }
+            catch (error) {
+                if (error instanceof OmniBridgeError)
+                    throw errorWithRecoveryFacts(error, facts);
+                if (input.signal?.aborted) {
+                    throw errorWithRecoveryFacts(canceledAfterUpload(), facts);
+                }
+                if (facts.contentReleased) {
+                    throw resultStorageUnavailable(facts);
+                }
+                throw error;
+            }
+        }
+        if (input.signal?.aborted) {
+            throw errorWithRecoveryFacts(canceledAfterUpload(), facts);
+        }
+        throw bridgeError("OPERATION_RECOVERY_TIMEOUT", "Timed out while recovering the IIIS operation.", {
+            ...facts,
+            retryable: true,
+        });
+    }
+}