docxodus 12.6.4 → 13.0.0

package/dist/worker-proxy.js

@@ -33,6 +33,24 @@ export class WorkerOperationError extends Error {
 function workerError(message, code) {
     return new WorkerOperationError(message || "Unknown error", code);
 }
+/**
+ * Read a success response's payload, rejecting with `missing_result` when the worker reported
+ * success without it rather than handing the caller `undefined` typed as a value.
+ */
+function requireField(response, field) {
+    const value = response[field];
+    if (value === undefined || value === null) {
+        throw workerError(`The worker's "${response.type ?? "unknown"}" response reported success without its ${String(field)}`, "missing_result");
+    }
+    return value;
+}
+/** A positive, finite timeout in milliseconds, or undefined; anything else is a caller error. */
+function checkTimeout(timeoutMs, name) {
+    if (timeoutMs !== undefined && !(Number.isFinite(timeoutMs) && timeoutMs > 0)) {
+        throw new RangeError(`${name} must be a positive, finite number of milliseconds; got ${timeoutMs}`);
+    }
+    return timeoutMs;
+}
 /** Reads a worker failure's machine-readable cause, or undefined for any other error. */
 export function workerErrorCode(error) {
     return error instanceof WorkerOperationError ? error.code : undefined;
@@ -97,6 +115,7 @@ export async function createWorkerDocxodus(options) {
     if (options?.signal?.aborted) {
         throw new Error("Worker creation aborted");
     }
+    const requestTimeoutMs = checkTimeout(options?.requestTimeoutMs, "requestTimeoutMs");
     // Determine WASM base path
     const wasmBasePath = options?.wasmBasePath ?? deriveWasmBasePath();
     // The worker bundle is packaged beside this module.
@@ -154,16 +173,58 @@ export async function createWorkerDocxodus(options) {
     worker.onerror = (error) => {
         stopWorker(`Worker error: ${error.message}`);
     };
+    // A response that cannot be deserialized arrives without its request id, so the request it
+    // answered cannot be identified. Rather than leave that request pending forever, reject every
+    // request in flight; the worker itself is unaffected and stays usable.
+    worker.onmessageerror = () => {
+        for (const pending of [...pendingRequests.values()]) {
+            pending.reject(workerError("A worker response could not be deserialized, so every request in flight was rejected", "message_error"));
+        }
+    };
     /**
-     * Send a request to the worker and wait for response.
+     * Send a request to the worker and wait for its response. Every way a request ends (a
+     * response, a timeout, an abort, the worker stopping, or a failed post) goes through the
+     * pending entry's resolve/reject, which clear its timer and abort listener exactly once.
      */
-    function sendRequest(request, transfer) {
+    function sendRequest(request, transfer, requestOptions) {
         return new Promise((resolve, reject) => {
             if (!isWorkerActive) {
                 reject(new Error("Worker has been terminated"));
                 return;
             }
-            pendingRequests.set(request.id, { resolve, reject });
+            const signal = requestOptions?.signal;
+            if (signal?.aborted) {
+                reject(workerError(`The worker request "${request.type}" was aborted before it was sent`, "aborted"));
+                return;
+            }
+            const timeoutMs = requestOptions?.timeoutMs ?? requestTimeoutMs;
+            let timer;
+            let onAbort;
+            const finish = () => {
+                pendingRequests.delete(request.id);
+                if (timer !== undefined)
+                    clearTimeout(timer);
+                if (onAbort)
+                    signal?.removeEventListener("abort", onAbort);
+            };
+            pendingRequests.set(request.id, {
+                resolve: (value) => {
+                    finish();
+                    resolve(value);
+                },
+                reject: (error) => {
+                    finish();
+                    reject(error);
+                },
+            });
+            const fail = (error) => pendingRequests.get(request.id)?.reject(error);
+            if (timeoutMs !== undefined) {
+                timer = setTimeout(() => fail(workerError(`The worker request "${request.type}" timed out after ${timeoutMs} ms`, "timeout")), timeoutMs);
+            }
+            if (signal) {
+                onAbort = () => fail(workerError(`The worker request "${request.type}" was aborted`, "aborted"));
+                signal.addEventListener("abort", onAbort, { once: true });
+            }
             try {
                 if (transfer && transfer.length > 0) {
                     worker.postMessage(request, transfer);
@@ -173,8 +234,7 @@ export async function createWorkerDocxodus(options) {
                 }
             }
             catch (error) {
-                pendingRequests.delete(request.id);
-                reject(error instanceof Error ? error : new Error(String(error)));
+                fail(error instanceof Error ? error : new Error(String(error)));
             }
         });
     }
@@ -190,342 +250,300 @@ export async function createWorkerDocxodus(options) {
         stopWorker("Worker initialization failed");
         throw error;
     }
-    // Return the WorkerDocxodus instance
-    return {
-        async generatePackageManifest(document, limits) {
-            const bytes = await toBytes(document);
-            const response = await sendRequest({
-                id: generateId(),
-                type: "generatePackageManifest",
-                documentBytes: bytes,
-                limits,
-                representation: "object",
-            }, [bytes.buffer]);
-            return response.manifest;
-        },
-        async verifyDeliverable(document, baseline, request) {
-            const bytes = await toBytes(document);
-            const baselineBytes = baseline === undefined ? undefined : await toBytes(baseline);
-            const transfer = [bytes.buffer];
-            if (baselineBytes !== undefined)
-                transfer.push(baselineBytes.buffer);
-            const response = await sendRequest({
-                id: generateId(),
-                type: "verifyDeliverable",
-                documentBytes: bytes,
-                baselineBytes,
-                requestJson: request === undefined ? undefined : serializeVerificationRequest(request),
-            }, transfer);
-            if (!response.success || !response.verification) {
-                throw new Error(response.error ?? "verifyDeliverable failed");
-            }
-            return response.verification;
-        },
-        async proveRedlineReversibility(baseline, intendedFinal, redline) {
-            const baselineBytes = await toBytes(baseline);
-            const intendedFinalBytes = await toBytes(intendedFinal);
-            const redlineBytes = await toBytes(redline);
-            const response = await sendRequest({
-                id: generateId(),
-                type: "proveRedlineReversibility",
-                baselineBytes,
-                intendedFinalBytes,
-                redlineBytes,
-            }, [baselineBytes.buffer, intendedFinalBytes.buffer, redlineBytes.buffer]);
-            if (!response.success || !response.proof) {
-                throw new Error(response.error ?? "proveRedlineReversibility failed");
-            }
-            return response.proof;
-        },
-        async getSemanticChanges(left, right, settings) {
-            const leftBytes = await toBytes(left);
-            const rightBytes = await toBytes(right);
-            const response = await sendRequest({
-                id: generateId(),
-                type: "getSemanticChanges",
-                leftBytes,
-                rightBytes,
-                settings,
-            }, [leftBytes.buffer, rightBytes.buffer]);
-            return response.semanticChanges;
-        },
-        async createExternalAnnotationSet(document, documentId) {
-            const bytes = await toBytes(document);
-            const response = await sendRequest({ id: generateId(), type: "createExternalAnnotationSet", documentBytes: bytes, documentId }, [bytes.buffer]);
-            if (!response.success || !response.annotationSet) {
-                throw new Error(response.error ?? "createExternalAnnotationSet failed");
-            }
-            return response.annotationSet;
-        },
-        async validateExternalAnnotations(document, annotationSet) {
-            const bytes = await toBytes(document);
-            const response = await sendRequest({ id: generateId(), type: "validateExternalAnnotations", documentBytes: bytes, annotationSet }, [bytes.buffer]);
-            if (!response.success || !response.validation) {
-                throw new Error(response.error ?? "validateExternalAnnotations failed");
-            }
-            return response.validation;
-        },
-        async projectAnnotationsOntoHtml(html, annotationSet, projectionOptions) {
-            const response = await sendRequest({
-                id: generateId(),
-                type: "projectAnnotationsOntoHtml",
-                html,
-                annotationSet,
-                projectionOptions,
-            });
-            if (!response.success || response.html === undefined) {
-                throw new Error(response.error ?? "projectAnnotationsOntoHtml failed");
-            }
-            return response.html;
-        },
-        async convertDocxToHtmlWithExternalAnnotations(document, annotationSet, conversionOptions, projectionOptions) {
-            const bytes = await toBytes(document);
-            const response = await sendRequest({
-                id: generateId(),
-                type: "convertDocxToHtmlWithExternalAnnotations",
-                documentBytes: bytes,
-                annotationSet,
-                conversionOptions,
-                projectionOptions,
-            }, [bytes.buffer]);
-            if (!response.success || response.html === undefined) {
-                throw new Error(response.error ?? "convertDocxToHtmlWithExternalAnnotations failed");
-            }
-            return response.html;
-        },
-        async exportToOpenContract(document) {
-            const bytes = await toBytes(document);
-            const response = await sendRequest({ id: generateId(), type: "exportToOpenContract", documentBytes: bytes }, [bytes.buffer]);
-            if (!response.success || !response.export) {
-                throw new Error(response.error ?? "exportToOpenContract failed");
-            }
-            return response.export;
-        },
-        async generatePackageManifestJson(document, limits) {
-            const bytes = await toBytes(document);
-            const response = await sendRequest({
-                id: generateId(),
-                type: "generatePackageManifest",
-                documentBytes: bytes,
-                limits,
-                representation: "json",
-            }, [bytes.buffer]);
-            if (response.manifestJson === undefined) {
-                throw new Error("Package manifest worker response omitted canonical JSON");
-            }
-            return response.manifestJson;
-        },
-        async projectReviewProfile(document, profile, maximumOutputBytes) {
-            const bytes = await toBytes(document);
-            const response = await sendRequest({
-                id: generateId(),
-                type: "projectReviewProfile",
-                documentBytes: bytes,
-                profile,
-                maximumOutputBytes,
-            }, [bytes.buffer]);
-            if (!response.documentBytes || response.documentBytes.byteLength === 0) {
-                throw new Error(`Failed to derive the ${profile} review profile`);
-            }
-            return response.documentBytes;
-        },
-        async convertDocxToHtml(document, options, maximumOutputBytes) {
-            const bytes = await toBytes(document);
-            const response = await sendRequest({
-                id: generateId(),
-                type: "convertDocxToHtml",
-                documentBytes: bytes,
-                options,
-                maximumOutputBytes,
-            }, [bytes.buffer]);
-            return response.html;
-        },
-        async compareDocuments(original, modified, options) {
-            const originalBytes = await toBytes(original);
-            const modifiedBytes = await toBytes(modified);
-            const response = await sendRequest({
-                id: generateId(),
-                type: "compareDocuments",
-                originalBytes,
-                modifiedBytes,
-                options,
-            }, [originalBytes.buffer, modifiedBytes.buffer]);
-            return response.documentBytes;
-        },
-        async compareDocumentsToHtml(original, modified, options) {
-            const originalBytes = await toBytes(original);
-            const modifiedBytes = await toBytes(modified);
-            const response = await sendRequest({
-                id: generateId(),
-                type: "compareDocumentsToHtml",
-                originalBytes,
-                modifiedBytes,
-                options,
-            }, [originalBytes.buffer, modifiedBytes.buffer]);
-            return response.html;
-        },
-        async getRevisions(document) {
-            const bytes = await toBytes(document);
-            const response = await sendRequest({
-                id: generateId(),
-                type: "getRevisions",
-                documentBytes: bytes,
-            }, [bytes.buffer]);
-            return response.revisions;
-        },
-        async getComments(document) {
-            const bytes = await toBytes(document);
-            const response = await sendRequest({ id: generateId(), type: "getComments", documentBytes: bytes }, [bytes.buffer]);
-            return response.comments;
-        },
-        async getDocumentMetadata(document) {
-            const bytes = await toBytes(document);
-            const response = await sendRequest({
-                id: generateId(),
-                type: "getDocumentMetadata",
-                documentBytes: bytes,
-            }, [bytes.buffer]);
-            return response.metadata;
-        },
-        async getVersion() {
-            const response = await sendRequest({
-                id: generateId(),
-                type: "getVersion",
-            });
-            return response.version;
-        },
-        prepare() {
-            // Idempotent: hand back the existing warmup if one is in flight or done.
-            if (preparePromise) {
+    // The instance, and any withRequestOptions views of it, share this worker; each view's
+    // requests carry its options.
+    const createApi = (requestOptions) => {
+        const send = (request, transfer) => sendRequest(request, transfer, requestOptions);
+        return {
+            async generatePackageManifest(document, limits) {
+                const bytes = await toBytes(document);
+                const response = await send({
+                    id: generateId(),
+                    type: "generatePackageManifest",
+                    documentBytes: bytes,
+                    limits,
+                    representation: "object",
+                }, [bytes.buffer]);
+                return requireField(response, "manifest");
+            },
+            async verifyDeliverable(document, baseline, request) {
+                const bytes = await toBytes(document);
+                const baselineBytes = baseline === undefined ? undefined : await toBytes(baseline);
+                const transfer = [bytes.buffer];
+                if (baselineBytes !== undefined)
+                    transfer.push(baselineBytes.buffer);
+                const response = await send({
+                    id: generateId(),
+                    type: "verifyDeliverable",
+                    documentBytes: bytes,
+                    baselineBytes,
+                    requestJson: request === undefined ? undefined : serializeVerificationRequest(request),
+                }, transfer);
+                return requireField(response, "verification");
+            },
+            async proveRedlineReversibility(baseline, intendedFinal, redline) {
+                const baselineBytes = await toBytes(baseline);
+                const intendedFinalBytes = await toBytes(intendedFinal);
+                const redlineBytes = await toBytes(redline);
+                const response = await send({
+                    id: generateId(),
+                    type: "proveRedlineReversibility",
+                    baselineBytes,
+                    intendedFinalBytes,
+                    redlineBytes,
+                }, [baselineBytes.buffer, intendedFinalBytes.buffer, redlineBytes.buffer]);
+                return requireField(response, "proof");
+            },
+            async getSemanticChanges(left, right, settings) {
+                const leftBytes = await toBytes(left);
+                const rightBytes = await toBytes(right);
+                const response = await send({
+                    id: generateId(),
+                    type: "getSemanticChanges",
+                    leftBytes,
+                    rightBytes,
+                    settings,
+                }, [leftBytes.buffer, rightBytes.buffer]);
+                return requireField(response, "semanticChanges");
+            },
+            async createExternalAnnotationSet(document, documentId) {
+                const bytes = await toBytes(document);
+                const response = await send({ id: generateId(), type: "createExternalAnnotationSet", documentBytes: bytes, documentId }, [bytes.buffer]);
+                return requireField(response, "annotationSet");
+            },
+            async validateExternalAnnotations(document, annotationSet) {
+                const bytes = await toBytes(document);
+                const response = await send({ id: generateId(), type: "validateExternalAnnotations", documentBytes: bytes, annotationSet }, [bytes.buffer]);
+                return requireField(response, "validation");
+            },
+            async projectAnnotationsOntoHtml(html, annotationSet, projectionOptions) {
+                const response = await send({
+                    id: generateId(),
+                    type: "projectAnnotationsOntoHtml",
+                    html,
+                    annotationSet,
+                    projectionOptions,
+                });
+                return requireField(response, "html");
+            },
+            async convertDocxToHtmlWithExternalAnnotations(document, annotationSet, conversionOptions, projectionOptions) {
+                const bytes = await toBytes(document);
+                const response = await send({
+                    id: generateId(),
+                    type: "convertDocxToHtmlWithExternalAnnotations",
+                    documentBytes: bytes,
+                    annotationSet,
+                    conversionOptions,
+                    projectionOptions,
+                }, [bytes.buffer]);
+                return requireField(response, "html");
+            },
+            async exportToOpenContract(document) {
+                const bytes = await toBytes(document);
+                const response = await send({ id: generateId(), type: "exportToOpenContract", documentBytes: bytes }, [bytes.buffer]);
+                return requireField(response, "export");
+            },
+            async generatePackageManifestJson(document, limits) {
+                const bytes = await toBytes(document);
+                const response = await send({
+                    id: generateId(),
+                    type: "generatePackageManifest",
+                    documentBytes: bytes,
+                    limits,
+                    representation: "json",
+                }, [bytes.buffer]);
+                return requireField(response, "manifestJson");
+            },
+            async projectReviewProfile(document, profile, maximumOutputBytes) {
+                const bytes = await toBytes(document);
+                const response = await send({
+                    id: generateId(),
+                    type: "projectReviewProfile",
+                    documentBytes: bytes,
+                    profile,
+                    maximumOutputBytes,
+                }, [bytes.buffer]);
+                if (!response.documentBytes || response.documentBytes.byteLength === 0) {
+                    throw new Error(`Failed to derive the ${profile} review profile`);
+                }
+                return response.documentBytes;
+            },
+            async convertDocxToHtml(document, options, maximumOutputBytes) {
+                const bytes = await toBytes(document);
+                const response = await send({
+                    id: generateId(),
+                    type: "convertDocxToHtml",
+                    documentBytes: bytes,
+                    options,
+                    maximumOutputBytes,
+                }, [bytes.buffer]);
+                return requireField(response, "html");
+            },
+            async compareDocuments(original, modified, options) {
+                const originalBytes = await toBytes(original);
+                const modifiedBytes = await toBytes(modified);
+                const response = await send({
+                    id: generateId(),
+                    type: "compareDocuments",
+                    originalBytes,
+                    modifiedBytes,
+                    options,
+                }, [originalBytes.buffer, modifiedBytes.buffer]);
+                return requireField(response, "documentBytes");
+            },
+            async compareDocumentsToHtml(original, modified, options) {
+                const originalBytes = await toBytes(original);
+                const modifiedBytes = await toBytes(modified);
+                const response = await send({
+                    id: generateId(),
+                    type: "compareDocumentsToHtml",
+                    originalBytes,
+                    modifiedBytes,
+                    options,
+                }, [originalBytes.buffer, modifiedBytes.buffer]);
+                return requireField(response, "html");
+            },
+            async getRevisions(document) {
+                const bytes = await toBytes(document);
+                const response = await send({
+                    id: generateId(),
+                    type: "getRevisions",
+                    documentBytes: bytes,
+                }, [bytes.buffer]);
+                return requireField(response, "revisions");
+            },
+            async getComments(document) {
+                const bytes = await toBytes(document);
+                const response = await send({ id: generateId(), type: "getComments", documentBytes: bytes }, [bytes.buffer]);
+                return requireField(response, "comments");
+            },
+            async getDocumentMetadata(document) {
+                const bytes = await toBytes(document);
+                const response = await send({
+                    id: generateId(),
+                    type: "getDocumentMetadata",
+                    documentBytes: bytes,
+                }, [bytes.buffer]);
+                return requireField(response, "metadata");
+            },
+            async getVersion() {
+                const response = await send({
+                    id: generateId(),
+                    type: "getVersion",
+                });
+                return requireField(response, "version");
+            },
+            prepare() {
+                // Idempotent: hand back the existing warmup if one is in flight or done.
+                if (preparePromise) {
+                    return preparePromise;
+                }
+                preparePromise = send({
+                    id: generateId(),
+                    type: "prepare",
+                }).then(() => undefined);
+                // On failure, clear the cache so a subsequent prepare() can retry.
+                preparePromise.catch(() => {
+                    preparePromise = null;
+                });
                 return preparePromise;
-            }
-            preparePromise = sendRequest({
-                id: generateId(),
-                type: "prepare",
-            }).then(() => undefined);
-            // On failure, clear the cache so a subsequent prepare() can retry.
-            preparePromise.catch(() => {
-                preparePromise = null;
-            });
-            return preparePromise;
-        },
-        async openDocxSession(document, settings) {
-            const bytes = await toBytes(document);
-            const settingsJson = settings ? JSON.stringify(settings) : "";
-            const openResponse = await sendRequest({
-                id: generateId(),
-                type: "sessionOpen",
-                documentBytes: bytes,
-                settingsJson,
-            }, [bytes.buffer]);
-            if (!openResponse.success || openResponse.handle === undefined) {
-                throw new Error(`Failed to open worker DocxSession: ${openResponse.error ?? "unknown error"}`);
-            }
-            const handle = openResponse.handle;
-            return {
-                async getPackageManifest() {
-                    const res = await sendRequest({
-                        id: generateId(),
-                        type: "sessionGetPackageManifest",
-                        handle,
-                    });
-                    if (!res.success || !res.manifest) {
-                        throw new Error(res.error ?? "sessionGetPackageManifest failed");
-                    }
-                    return res.manifest;
-                },
-                async getSemanticChanges() {
-                    const res = await sendRequest({
-                        id: generateId(),
-                        type: "sessionGetSemanticChanges",
-                        handle,
-                    });
-                    if (!res.success || !res.semanticChanges) {
-                        throw new Error(res.error ?? "sessionGetSemanticChanges failed");
-                    }
-                    return res.semanticChanges;
-                },
-                async verifyDeliverable(request) {
-                    const res = await sendRequest({
-                        id: generateId(),
-                        type: "sessionVerifyDeliverable",
-                        handle,
-                        requestJson: request === undefined ? undefined : serializeVerificationRequest(request),
-                    });
-                    if (!res.success || !res.verification) {
-                        throw new Error(res.error ?? "sessionVerifyDeliverable failed");
-                    }
-                    return res.verification;
-                },
-                async addAnnotation(anchorId, span, annotation) {
-                    const res = await sendRequest({
-                        id: generateId(),
-                        type: "sessionAddAnnotation",
-                        handle,
-                        anchorId,
-                        spanJson: span ? JSON.stringify(span) : "",
-                        annotationJson: JSON.stringify(annotation),
-                    });
-                    if (!res.success) {
-                        throw new Error(res.error ?? "sessionAddAnnotation failed");
-                    }
-                    return res.result;
-                },
-                async removeAnnotation(annotationId) {
-                    const res = await sendRequest({
-                        id: generateId(),
-                        type: "sessionRemoveAnnotation",
-                        handle,
-                        annotationId,
-                    });
-                    if (!res.success) {
-                        throw new Error(res.error ?? "sessionRemoveAnnotation failed");
-                    }
-                    return res.result;
-                },
-                async updateAnnotation(annotationId, update) {
-                    const res = await sendRequest({
-                        id: generateId(),
-                        type: "sessionUpdateAnnotation",
-                        handle,
-                        annotationId,
-                        updateJson: JSON.stringify(update),
-                    });
-                    if (!res.success) {
-                        throw new Error(res.error ?? "sessionUpdateAnnotation failed");
-                    }
-                    return res.result;
-                },
-                async moveAnnotation(annotationId, newAnchorId, newSpan) {
-                    const res = await sendRequest({
-                        id: generateId(),
-                        type: "sessionMoveAnnotation",
-                        handle,
-                        annotationId,
-                        newAnchorId,
-                        newSpanJson: newSpan ? JSON.stringify(newSpan) : "",
-                    });
-                    if (!res.success) {
-                        throw new Error(res.error ?? "sessionMoveAnnotation failed");
-                    }
-                    return res.result;
-                },
-                async close() {
-                    await sendRequest({
-                        id: generateId(),
-                        type: "sessionClose",
-                        handle,
-                    });
-                },
-            };
-        },
-        terminate() {
-            stopWorker("Worker terminated");
-        },
-        isActive() {
-            return isWorkerActive;
-        },
+            },
+            async openDocxSession(document, settings) {
+                const bytes = await toBytes(document);
+                const settingsJson = settings ? JSON.stringify(settings) : "";
+                const openResponse = await send({
+                    id: generateId(),
+                    type: "sessionOpen",
+                    documentBytes: bytes,
+                    settingsJson,
+                }, [bytes.buffer]);
+                const handle = requireField(openResponse, "handle");
+                return {
+                    async getPackageManifest() {
+                        const res = await send({
+                            id: generateId(),
+                            type: "sessionGetPackageManifest",
+                            handle,
+                        });
+                        return requireField(res, "manifest");
+                    },
+                    async getSemanticChanges() {
+                        const res = await send({
+                            id: generateId(),
+                            type: "sessionGetSemanticChanges",
+                            handle,
+                        });
+                        return requireField(res, "semanticChanges");
+                    },
+                    async verifyDeliverable(request) {
+                        const res = await send({
+                            id: generateId(),
+                            type: "sessionVerifyDeliverable",
+                            handle,
+                            requestJson: request === undefined ? undefined : serializeVerificationRequest(request),
+                        });
+                        return requireField(res, "verification");
+                    },
+                    async addAnnotation(anchorId, span, annotation) {
+                        const res = await send({
+                            id: generateId(),
+                            type: "sessionAddAnnotation",
+                            handle,
+                            anchorId,
+                            spanJson: span ? JSON.stringify(span) : "",
+                            annotationJson: JSON.stringify(annotation),
+                        });
+                        return requireField(res, "result");
+                    },
+                    async removeAnnotation(annotationId) {
+                        const res = await send({
+                            id: generateId(),
+                            type: "sessionRemoveAnnotation",
+                            handle,
+                            annotationId,
+                        });
+                        return requireField(res, "result");
+                    },
+                    async updateAnnotation(annotationId, update) {
+                        const res = await send({
+                            id: generateId(),
+                            type: "sessionUpdateAnnotation",
+                            handle,
+                            annotationId,
+                            updateJson: JSON.stringify(update),
+                        });
+                        return requireField(res, "result");
+                    },
+                    async moveAnnotation(annotationId, newAnchorId, newSpan) {
+                        const res = await send({
+                            id: generateId(),
+                            type: "sessionMoveAnnotation",
+                            handle,
+                            annotationId,
+                            newAnchorId,
+                            newSpanJson: newSpan ? JSON.stringify(newSpan) : "",
+                        });
+                        return requireField(res, "result");
+                    },
+                    async close() {
+                        // Not abortable: an aborted view must still release the in-worker session handle.
+                        await sendRequest({ id: generateId(), type: "sessionClose", handle }, undefined, { timeoutMs: requestOptions?.timeoutMs });
+                    },
+                };
+            },
+            terminate() {
+                stopWorker("Worker terminated");
+            },
+            withRequestOptions(more) {
+                checkTimeout(more.timeoutMs, "timeoutMs");
+                return createApi({ ...requestOptions, ...more });
+            },
+            isActive() {
+                return isWorkerActive;
+            },
+        };
     };
+    return createApi();
 }
 /**
  * Check if Web Workers are supported in the current environment.