document-ocr 0.0.0-stage → 3.1.3

package/dist/index.cjs

@@ -0,0 +1,659 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DocumentOCR: () => DocumentOCR,
+  HttpError: () => HttpError,
+  InputValidationError: () => InputValidationError,
+  LocalServer: () => LocalServer,
+  PassportOCR: () => PassportOCR,
+  getLocalServer: () => getLocalServer
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var HttpError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "HttpError";
+  }
+  status;
+  get retryable() {
+    return this.status === 408 || this.status === 429 || this.status >= 500;
+  }
+};
+var InputValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InputValidationError";
+  }
+};
+
+// src/image.ts
+function isHttpUrl(input) {
+  return /^https?:\/\//i.test(input);
+}
+async function fetchImage(url, signal) {
+  const res = await fetch(url, { signal });
+  if (!res.ok) {
+    await res.body?.cancel();
+    throw new HttpError(res.status, `Failed to fetch image from URL: ${res.status}`);
+  }
+  return res;
+}
+async function normalizeToBase64(input, signal) {
+  if (typeof input === "string" && !isHttpUrl(input)) {
+    validateBase64(input);
+    return input;
+  }
+  if (typeof input === "string" && isHttpUrl(input)) {
+    const res = await fetchImage(input, signal);
+    const buf = await res.arrayBuffer();
+    return arrayBufferToBase64(buf);
+  }
+  if (typeof Buffer !== "undefined" && Buffer.isBuffer(input)) {
+    return input.toString("base64");
+  }
+  if (input instanceof ArrayBuffer) {
+    return arrayBufferToBase64(input);
+  }
+  if (typeof Blob !== "undefined" && input instanceof Blob) {
+    const buf = await input.arrayBuffer();
+    return arrayBufferToBase64(buf);
+  }
+  throw new InputValidationError("Unsupported image input type");
+}
+async function normalizeToBlob(input, signal) {
+  if (typeof Blob !== "undefined" && input instanceof Blob) {
+    if (input.type.startsWith("image/") || input.type === "application/pdf") return input;
+    const header = new Uint8Array(await input.slice(0, 16).arrayBuffer());
+    return new Blob([input], { type: mediaType(header) });
+  }
+  if (typeof Buffer !== "undefined" && Buffer.isBuffer(input)) {
+    const copy = new Uint8Array(input);
+    return new Blob([copy], { type: mediaType(copy) });
+  }
+  if (input instanceof ArrayBuffer) {
+    return new Blob([input], { type: mediaType(new Uint8Array(input)) });
+  }
+  if (typeof input === "string" && isHttpUrl(input)) {
+    const res = await fetchImage(input, signal);
+    return normalizeToBlob(await res.blob(), signal);
+  }
+  if (typeof input === "string") {
+    validateBase64(input);
+    const binary = atob(input);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+      bytes[i] = binary.charCodeAt(i);
+    }
+    return new Blob([bytes], { type: mediaType(bytes) });
+  }
+  throw new InputValidationError("Unsupported image input type");
+}
+function validateBase64(value) {
+  if (!value || !/^[A-Za-z0-9+/]*={0,2}$/.test(value) || value.length % 4 === 1 || value.includes("=") && value.length % 4 !== 0) {
+    throw new InputValidationError("Image string must be base64 or an HTTP(S) URL");
+  }
+}
+function mediaType(bytes) {
+  const header = String.fromCharCode(...bytes.subarray(0, 16));
+  if (header.startsWith("%PDF-")) return "application/pdf";
+  if (header.startsWith("\x89PNG\r\n\n")) return "image/png";
+  if (header.startsWith("GIF87a") || header.startsWith("GIF89a")) return "image/gif";
+  if (header.startsWith("II*\0") || header.startsWith("MM\0*")) return "image/tiff";
+  if (header.startsWith("RIFF") && header.slice(8, 12) === "WEBP") return "image/webp";
+  if (header.startsWith("BM")) return "image/bmp";
+  if (header.slice(4, 8) === "ftyp") return header.slice(8, 12) === "avif" ? "image/avif" : "image/heif";
+  return "image/jpeg";
+}
+function arrayBufferToBase64(buffer) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(buffer).toString("base64");
+  }
+  const bytes = new Uint8Array(buffer);
+  let binary = "";
+  for (let i = 0; i < bytes.byteLength; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+}
+
+// src/retry.ts
+function validateRetryOptions({ retries, timeoutMs }) {
+  if (!Number.isInteger(retries) || retries < 0) {
+    throw new RangeError("retries must be a non-negative integer");
+  }
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0 || timeoutMs > 2147483647) {
+    throw new RangeError("timeoutMs must be between 0 and 2147483647 milliseconds (exclusive of 0)");
+  }
+}
+async function withRetry(fn, options) {
+  validateRetryOptions(options);
+  const { retries, timeoutMs } = options;
+  let lastError;
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    const controller = new AbortController();
+    let timeout;
+    const deadline = new Promise((_, reject) => {
+      timeout = setTimeout(() => {
+        const error = new Error(`OCR request timed out after ${timeoutMs}ms`);
+        error.name = "TimeoutError";
+        reject(error);
+        controller.abort(error);
+      }, timeoutMs);
+    });
+    try {
+      return await Promise.race([fn(controller.signal), deadline]);
+    } catch (err) {
+      lastError = err instanceof Error ? err : new Error(String(err));
+      if (lastError instanceof InputValidationError || lastError instanceof HttpError && !lastError.retryable) {
+        throw lastError;
+      }
+    } finally {
+      clearTimeout(timeout);
+    }
+    if (attempt < retries) {
+      const delay2 = Math.min(500 * Math.pow(2, attempt), 5e3);
+      await new Promise((r) => setTimeout(r, delay2));
+    }
+  }
+  throw lastError ?? new Error("All retries exhausted");
+}
+
+// src/local-server.ts
+var import_node_child_process = require("child_process");
+var import_node_net = require("net");
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var import_node_url = require("url");
+var import_promises = require("timers/promises");
+var import_meta = {};
+function resolvePackageDir() {
+  try {
+    if (typeof import_meta?.url === "string") {
+      return (0, import_node_path.join)((0, import_node_path.dirname)((0, import_node_url.fileURLToPath)(import_meta.url)), "..");
+    }
+  } catch {
+  }
+  if (typeof __dirname === "string") {
+    return (0, import_node_path.join)(__dirname, "..");
+  }
+  throw new Error("Cannot resolve document-ocr package directory");
+}
+var HEALTH_POLL_INTERVAL_MS = 500;
+var HEALTH_TIMEOUT_MS = 12e4;
+function findFreePort() {
+  return new Promise((resolve, reject) => {
+    const srv = (0, import_node_net.createServer)();
+    srv.listen(0, "127.0.0.1", () => {
+      const addr = srv.address();
+      if (addr && typeof addr === "object") {
+        const port = addr.port;
+        srv.close(() => resolve(port));
+      } else {
+        srv.close(() => reject(new Error("Could not determine free port")));
+      }
+    });
+    srv.on("error", reject);
+  });
+}
+var LocalServer = class {
+  process = null;
+  ready = null;
+  startupAbort = null;
+  cleanupHandler = null;
+  /**
+   * Ensure the local Python server is running and return its endpoint URL.
+   */
+  async ensureRunning() {
+    if (this.ready) {
+      return this.ready;
+    }
+    const controller = new AbortController();
+    this.startupAbort = controller;
+    const ready = this._start(controller);
+    this.ready = ready;
+    ready.catch(() => {
+      if (this.ready === ready) this.ready = null;
+    });
+    return ready;
+  }
+  async _start(controller) {
+    const packageDir = resolvePackageDir();
+    const pythonDir = (0, import_node_path.join)(packageDir, "python");
+    const venvDir = (0, import_node_path.join)(packageDir, ".venv");
+    const markerFile = (0, import_node_path.join)(venvDir, ".setup-complete");
+    if (!(0, import_node_fs.existsSync)(markerFile)) {
+      throw new Error(
+        'document-ocr: Python environment not set up. Run "npm rebuild document-ocr" or ensure Python 3.14 and uv are installed. Check that the postinstall script ran successfully.'
+      );
+    }
+    const isWindows = process.platform === "win32";
+    const pythonExe = isWindows ? (0, import_node_path.join)(venvDir, "Scripts", "python.exe") : (0, import_node_path.join)(venvDir, "bin", "python");
+    if (!(0, import_node_fs.existsSync)(pythonExe)) {
+      throw new Error(
+        `document-ocr: Python executable not found at ${pythonExe}. Run "npm rebuild document-ocr" to re-create the virtual environment.`
+      );
+    }
+    const port = await findFreePort();
+    controller.signal.throwIfAborted();
+    const endpoint = `http://127.0.0.1:${port}`;
+    const args = [
+      "-m",
+      "uvicorn",
+      "server:app",
+      "--host",
+      "127.0.0.1",
+      "--port",
+      String(port),
+      "--log-level",
+      "warning"
+    ];
+    const child = (0, import_node_child_process.spawn)(pythonExe, args, {
+      cwd: pythonDir,
+      env: {
+        ...process.env,
+        PYTHONPATH: pythonDir,
+        PADDLE_PDX_DISABLE_MODEL_SOURCE_CHECK: "True",
+        // Suppress paddle logging noise
+        GLOG_minloglevel: "2"
+      },
+      stdio: ["ignore", "pipe", "pipe"],
+      // Detach on Windows to avoid blocking
+      detached: isWindows
+    });
+    this.process = child;
+    let processLogs = "";
+    const appendLogs = (chunk) => {
+      processLogs += chunk.toString();
+      if (processLogs.length > 4096) {
+        processLogs = processLogs.slice(-4096);
+      }
+    };
+    child.stdout?.on("data", appendLogs);
+    child.stderr?.on("data", appendLogs);
+    const cleanup = () => child.kill("SIGTERM");
+    this.cleanupHandler = cleanup;
+    process.once("exit", cleanup);
+    const exitPromise = new Promise((_, reject) => {
+      const failed = (error) => {
+        process.removeListener("exit", cleanup);
+        if (this.cleanupHandler === cleanup) this.cleanupHandler = null;
+        if (this.process === child) {
+          this.ready = null;
+          this.process = null;
+        }
+        controller.abort(error);
+        reject(error);
+      };
+      child.once("error", failed);
+      child.once("exit", (code, signal) => failed(new Error(
+        `document-ocr: Python server exited (code=${code}, signal=${signal}).
+${processLogs}`
+      )));
+    });
+    try {
+      return await Promise.race([this._waitForReady(endpoint, controller.signal), exitPromise]);
+    } catch (error) {
+      if (this.process === child) await this.stop();
+      throw error;
+    } finally {
+      if (controller.signal.aborted) process.removeListener("exit", cleanup);
+    }
+  }
+  async _waitForReady(endpoint, signal) {
+    const readinessUrl = `${endpoint}/ready`;
+    const startTime = Date.now();
+    while (Date.now() - startTime < HEALTH_TIMEOUT_MS) {
+      signal?.throwIfAborted();
+      let terminalFailure = null;
+      const probeController = new AbortController();
+      const cancelProbe = () => probeController.abort(signal?.reason);
+      signal?.addEventListener("abort", cancelProbe, { once: true });
+      const timeout = setTimeout(() => probeController.abort(), 2e3);
+      try {
+        const res = await fetch(readinessUrl, {
+          signal: probeController.signal
+        });
+        const body = await res.json().catch(() => null);
+        signal?.throwIfAborted();
+        if (res.ok && body?.status === "ready") {
+          return endpoint;
+        }
+        if (body?.status === "model_init_failed") {
+          const detail = typeof body.error === "string" ? body.error.replace(/\s+/g, " ").slice(0, 500) : "configured OCR model initialization failed";
+          terminalFailure = detail;
+        }
+      } catch {
+        signal?.throwIfAborted();
+      } finally {
+        clearTimeout(timeout);
+        signal?.removeEventListener("abort", cancelProbe);
+      }
+      if (terminalFailure) {
+        throw new Error(
+          `document-ocr: OCR model initialization failed: ${terminalFailure}`
+        );
+      }
+      await (0, import_promises.setTimeout)(HEALTH_POLL_INTERVAL_MS, void 0, { signal });
+    }
+    throw new Error(
+      `document-ocr: Python server did not become ready within ${HEALTH_TIMEOUT_MS / 1e3}s. This might happen on first run while models are being downloaded.`
+    );
+  }
+  /**
+   * Stop the local Python server if running.
+   */
+  async stop() {
+    if (this.cleanupHandler) {
+      process.removeListener("exit", this.cleanupHandler);
+      this.cleanupHandler = null;
+    }
+    this.startupAbort?.abort(new Error("document-ocr: local server stopped"));
+    this.startupAbort = null;
+    this.ready = null;
+    if (this.process) {
+      const proc = this.process;
+      this.process = null;
+      if (proc.exitCode !== null || proc.signalCode !== null) return;
+      await new Promise((resolve) => {
+        const done = () => {
+          clearTimeout(forceKill);
+          clearTimeout(deadline);
+          proc.removeListener("exit", done);
+          proc.removeListener("error", done);
+          resolve();
+        };
+        const forceKill = setTimeout(() => {
+          try {
+            proc.kill("SIGKILL");
+          } catch {
+            done();
+          }
+        }, 5e3);
+        const deadline = setTimeout(done, 6e3);
+        proc.once("exit", done);
+        proc.once("error", done);
+        try {
+          if (!proc.kill("SIGTERM")) done();
+        } catch {
+          done();
+        }
+      });
+    }
+  }
+};
+var _instance = null;
+function getLocalServer() {
+  if (!_instance) {
+    _instance = new LocalServer();
+  }
+  return _instance;
+}
+
+// src/client.ts
+var MAX_LAMBDA_PAYLOAD_BYTES = 6 * 1024 * 1024;
+var DocumentOCR = class {
+  mode;
+  endpoint;
+  functionName;
+  timeoutMs;
+  retries;
+  apiKey;
+  authHeaders;
+  constructor(options = {}) {
+    this.mode = options.mode ?? "local";
+    this.endpoint = options.endpoint;
+    this.functionName = options.functionName;
+    this.timeoutMs = options.timeoutMs ?? 3e4;
+    this.retries = options.retries ?? 2;
+    this.apiKey = options.apiKey;
+    this.authHeaders = options.authHeaders;
+    validateRetryOptions({ retries: this.retries, timeoutMs: this.timeoutMs });
+    if (this.mode === "http" && !this.endpoint) throw new Error("endpoint is required for http mode");
+    if (this.mode === "lambda" && !this.functionName) throw new Error("functionName is required for lambda mode");
+    if (this.mode === "local" && this.endpoint) {
+      console.warn('document-ocr: endpoint is ignored in local mode. Use mode: "http" if you want to connect to an external server.');
+    }
+  }
+  async scan(image, options = {}) {
+    const parameters = scanParameters(options);
+    return this.retry(async (signal) => {
+      if (this.mode === "lambda") {
+        const base64 = await normalizeToBase64(image, signal);
+        return this.invokeLambda({ image_base64: base64, ...parameters }, signal);
+      }
+      const form = new FormData();
+      form.append("image", await normalizeToBlob(image, signal), "document");
+      appendParameters(form, parameters);
+      const { status, data } = await this.request("/scan", signal, { method: "POST", body: form });
+      return parseScanResponse(status, data);
+    });
+  }
+  async scanBatch(images, options = {}) {
+    return this.uploadMany("/scan/batch", images, options);
+  }
+  async scanDocument(images, options = {}) {
+    return this.uploadMany("/scan/document", images, options);
+  }
+  async uploadMany(path, images, options) {
+    this.requireHttp(path === "/scan/batch" ? "scanBatch" : "scanDocument");
+    if (!Array.isArray(images) || images.length === 0) throw new InputValidationError("scanBatch requires at least one image");
+    const parameters = scanParameters(options);
+    return this.retry(async (signal) => {
+      const form = new FormData();
+      for (const [index, image] of images.entries()) {
+        form.append("images", await normalizeToBlob(image, signal), `document-${index}`);
+      }
+      appendParameters(form, parameters);
+      const { status, data } = await this.request(path, signal, { method: "POST", body: form });
+      const body = asObject(data);
+      const valid = body !== null && ["success", "partial", "failure"].includes(String(body.status)) && Array.isArray(body.results) && body.results.every(isScanResult) && Array.isArray(body.errors);
+      checkStatus(status, data, status === 422 && valid);
+      if (!valid) throw new Error("Invalid OCR response: expected a batch scan result");
+      if (path === "/scan/document" && (!asObject(body.documentFields) || !Array.isArray(body.conflicts))) {
+        throw new Error("Invalid OCR response: expected grouped document fields and conflicts");
+      }
+      return data;
+    });
+  }
+  async documents() {
+    this.requireHttp("documents");
+    return this.retry(async (signal) => {
+      const { status, data } = await this.request("/documents", signal);
+      checkStatus(status, data);
+      const body = asObject(data);
+      if (!body || typeof body.schemaVersion !== "number" || !Array.isArray(body.documents) || !asObject(body.capabilities)) {
+        throw new Error("Invalid OCR response: expected a document catalog");
+      }
+      return data;
+    });
+  }
+  async enqueueJob(images, options = {}) {
+    this.requireHttp("enqueueJob");
+    if (!Array.isArray(images) || images.length === 0) throw new InputValidationError("enqueueJob requires at least one image");
+    const parameters = scanParameters(options);
+    for (const key of ["grouped", "notify"]) {
+      if (options[key] !== void 0) {
+        if (typeof options[key] !== "boolean") throw new InputValidationError(`${key} must be boolean`);
+        parameters[key] = options[key];
+      }
+    }
+    return withRetry(async (signal) => {
+      const form = new FormData();
+      for (const [index, image] of images.entries()) form.append("images", await normalizeToBlob(image, signal), `document-${index}`);
+      appendParameters(form, parameters);
+      const { status, data } = await this.request("/jobs", signal, { method: "POST", body: form });
+      checkStatus(status, data);
+      return parseJob(data);
+    }, { retries: 0, timeoutMs: this.timeoutMs });
+  }
+  async job(id) {
+    this.requireHttp("job");
+    const path = jobPath(id);
+    return this.retry(async (signal) => {
+      const { status, data } = await this.request(path, signal);
+      checkStatus(status, data);
+      return parseJob(data);
+    });
+  }
+  async deleteJob(id) {
+    this.requireHttp("deleteJob");
+    const path = jobPath(id);
+    return this.retry(async (signal) => {
+      const { status, data } = await this.request(path, signal, { method: "DELETE" });
+      checkStatus(status, data);
+      if (asObject(data)?.deleted !== true) throw new Error("Invalid OCR response: expected deletion confirmation");
+      return { deleted: true };
+    });
+  }
+  async scanS3(image, options = {}) {
+    if (this.mode !== "lambda") throw new InputValidationError("scanS3 is available only in lambda mode");
+    if (!image || typeof image.bucket !== "string" || !image.bucket.trim() || typeof image.key !== "string" || !image.key.trim() || image.versionId !== void 0 && (typeof image.versionId !== "string" || !image.versionId)) {
+      throw new InputValidationError("scanS3 requires bucket, key, and an optional non-empty versionId");
+    }
+    const parameters = scanParameters(options);
+    const s3 = { bucket: image.bucket, key: image.key, ...image.versionId === void 0 ? {} : { version_id: image.versionId } };
+    return this.retry((signal) => this.invokeLambda({ s3, ...parameters }, signal));
+  }
+  async stop() {
+    if (this.mode === "local") await getLocalServer().stop();
+  }
+  requireHttp(method) {
+    if (this.mode === "lambda") throw new InputValidationError(`${method} requires local or http mode`);
+  }
+  retry(operation) {
+    return withRetry(operation, { retries: this.retries, timeoutMs: this.timeoutMs });
+  }
+  async request(path, signal, init = {}) {
+    const endpoint = this.mode === "local" ? await getLocalServer().ensureRunning() : this.endpoint;
+    const url = `${endpoint.replace(/\/+$/, "")}${path}`;
+    signal.throwIfAborted();
+    const headers = new Headers(this.apiKey ? { Authorization: `Bearer ${this.apiKey}` } : {});
+    if (this.authHeaders) {
+      new Headers(await this.authHeaders(url, signal)).forEach((value, key) => headers.set(key, value));
+    }
+    signal.throwIfAborted();
+    const response = await fetch(url, { ...init, headers, signal });
+    const data = await response.json().catch(() => null);
+    return { status: response.status, data };
+  }
+  async invokeLambda(event, signal) {
+    const payload = JSON.stringify(event);
+    if (new TextEncoder().encode(payload).byteLength > MAX_LAMBDA_PAYLOAD_BYTES) {
+      throw new InputValidationError("Lambda payload exceeds 6 MiB; upload the image to S3 and use scanS3()");
+    }
+    signal.throwIfAborted();
+    const { LambdaClient, InvokeCommand } = await import("@aws-sdk/client-lambda");
+    signal.throwIfAborted();
+    const client = new LambdaClient({});
+    const command = new InvokeCommand({ FunctionName: this.functionName, Payload: payload });
+    try {
+      const response = await client.send(command, { abortSignal: signal });
+      if (response.FunctionError) throw new Error(`Lambda invocation failed: ${response.FunctionError}`);
+      const result = JSON.parse(new TextDecoder().decode(response.Payload));
+      if (typeof result?.statusCode === "number") {
+        let body = result.body;
+        if (typeof body === "string") {
+          try {
+            body = JSON.parse(body);
+          } catch {
+            body = null;
+          }
+        }
+        return parseScanResponse(result.statusCode, body);
+      }
+      return parseScanResponse(200, result);
+    } finally {
+      client.destroy();
+    }
+  }
+};
+function scanParameters(options) {
+  if (!options || typeof options !== "object") throw new InputValidationError("scan options must be an object");
+  const result = {};
+  for (const [key, wireKey] of [["documentType", "document_type"], ["country", "country"]]) {
+    const value = options[key];
+    if (value !== void 0) {
+      if (typeof value !== "string" || !value.trim()) throw new InputValidationError(`${key} must be a non-empty string`);
+      result[wireKey] = value;
+    }
+  }
+  if (options.includeEvidence !== void 0) {
+    if (typeof options.includeEvidence !== "boolean") throw new InputValidationError("includeEvidence must be boolean");
+    result.include_evidence = options.includeEvidence;
+  }
+  return result;
+}
+function appendParameters(form, parameters) {
+  for (const [key, value] of Object.entries(parameters)) form.append(key, String(value));
+}
+function jobPath(id) {
+  if (typeof id !== "string" || !/^[A-Za-z0-9_-]+$/.test(id)) throw new InputValidationError("job id must contain letters, digits, hyphens, or underscores");
+  return `/jobs/${encodeURIComponent(id)}`;
+}
+function parseJob(data) {
+  const body = asObject(data);
+  if (!body || typeof body.id !== "string" || !["queued", "running", "succeeded", "failed"].includes(String(body.status)) || typeof body.createdAt !== "number" || typeof body.expiresAt !== "number" || typeof body.attempts !== "number" || body.error !== null && typeof body.error !== "string") throw new Error("Invalid OCR response: expected a job");
+  return data;
+}
+function asObject(data) {
+  return data !== null && typeof data === "object" && !Array.isArray(data) ? data : null;
+}
+function isScanResult(data) {
+  const body = asObject(data);
+  return body !== null && ["success", "failure", "unsupported_page"].includes(String(body.status)) && typeof body.documentType === "string" && typeof body.pageType === "string" && Array.isArray(body.errors);
+}
+function checkStatus(status, data, allow422 = false) {
+  if (status >= 200 && status < 300 || allow422) return;
+  const body = asObject(data);
+  const message = typeof body?.error === "string" ? body.error : typeof body?.detail === "string" ? body.detail : `OCR request failed: ${status}`;
+  throw new HttpError(status, message);
+}
+function parseScanResponse(status, data) {
+  const valid = isScanResult(data);
+  checkStatus(status, data, status === 422 && valid);
+  if (!valid) throw new Error("Invalid OCR response: expected a document scan result");
+  return data;
+}
+var PassportOCR = DocumentOCR;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DocumentOCR,
+  HttpError,
+  InputValidationError,
+  LocalServer,
+  PassportOCR,
+  getLocalServer
+});
+//# sourceMappingURL=index.cjs.map