@duckmind/dm-windows-x64 0.63.0 → 0.63.6

package/extensions/dm-web-access/data-uri-sanitize.js

@@ -0,0 +1,312 @@
+import { Buffer } from "node:buffer";
+import { createHash } from "node:crypto";
+const MAX_DATA_URI_HEADER_CHARS = 1024;
+const MAX_MIME_CHARS = 127;
+const MAX_MARKER_SOURCE_CHARS = 180;
+function sha256Bytes(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function asciiLowerCode(code) {
+  return code >= 65 && code <= 90 ? code + 32 : code;
+}
+function matchesDataScheme(text, index) {
+  return index + 5 <= text.length && asciiLowerCode(text.charCodeAt(index)) === 100 && asciiLowerCode(text.charCodeAt(index + 1)) === 97 && asciiLowerCode(text.charCodeAt(index + 2)) === 116 && asciiLowerCode(text.charCodeAt(index + 3)) === 97 && text.charCodeAt(index + 4) === 58;
+}
+function isSchemeBoundary(text, index) {
+  if (index === 0)
+    return true;
+  const code = text.charCodeAt(index - 1);
+  const alphaNumeric = code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122;
+  return !alphaNumeric && code !== 43 && code !== 45 && code !== 46;
+}
+function findNextDataScheme(text, from) {
+  for (let i = from;i + 5 <= text.length; i++) {
+    if (matchesDataScheme(text, i) && isSchemeBoundary(text, i))
+      return i;
+  }
+  return -1;
+}
+function dataUriEnclosure(text, start) {
+  if (start === 0)
+    return null;
+  const immediateIndex = start - 1;
+  const immediate = text[immediateIndex];
+  if (immediate === '"' || immediate === "'" || immediate === "`") {
+    const beforeQuote = immediateIndex > 0 ? text[immediateIndex - 1] : "";
+    const likelyOpeningQuote = immediateIndex === 0 || beforeQuote === "=" || beforeQuote === "(" || beforeQuote === "[" || beforeQuote === "{" || beforeQuote === ":" || beforeQuote === "," || /\s/.test(beforeQuote);
+    if (likelyOpeningQuote)
+      return { kind: "quote", close: immediate };
+  }
+  let openerIndex = immediateIndex;
+  while (openerIndex >= 0 && (text[openerIndex] === " " || text[openerIndex] === "\t"))
+    openerIndex--;
+  const opener = text[openerIndex];
+  if (opener === "(")
+    return { kind: "parentheses" };
+  if (opener === "<")
+    return { kind: "angle" };
+  return null;
+}
+function isBareDataUriTerminator(ch) {
+  const code = ch.charCodeAt(0);
+  return code <= 32 || code === 127 || ch === '"' || ch === "`" || ch === "<" || ch === ">";
+}
+function scanDataUriCandidate(text, start) {
+  const enclosure = dataUriEnclosure(text, start);
+  let comma = -1;
+  let depth = enclosure?.kind === "parentheses" ? 1 : 0;
+  let index = start + 5;
+  for (;index < text.length; index++) {
+    const ch = text[index];
+    if (enclosure?.kind === "quote") {
+      if (ch === enclosure.close)
+        break;
+    } else if (enclosure?.kind === "parentheses") {
+      if (ch === "(") {
+        depth++;
+      } else if (ch === ")") {
+        depth--;
+        if (depth === 0)
+          break;
+      }
+    } else if (enclosure?.kind === "angle") {
+      if (ch === ">")
+        break;
+    } else if (isBareDataUriTerminator(ch)) {
+      break;
+    }
+    if (comma < 0 && ch === ",")
+      comma = index;
+  }
+  return { end: index, comma, enclosure };
+}
+function headerEndsWithBase64(text, headerStart, comma) {
+  let end = comma;
+  while (end > headerStart && (text[end - 1] === " " || text[end - 1] === "\t"))
+    end--;
+  const token = "base64";
+  if (end - headerStart < token.length + 1)
+    return false;
+  const tokenStart = end - token.length;
+  for (let i = 0;i < token.length; i++) {
+    if (asciiLowerCode(text.charCodeAt(tokenStart + i)) !== token.charCodeAt(i))
+      return false;
+  }
+  return tokenStart > headerStart && text[tokenStart - 1] === ";";
+}
+function isMimeTokenChar(code) {
+  if (code < 33 || code > 126)
+    return false;
+  switch (code) {
+    case 34:
+    case 40:
+    case 41:
+    case 44:
+    case 47:
+    case 58:
+    case 59:
+    case 60:
+    case 61:
+    case 62:
+    case 63:
+    case 64:
+    case 91:
+    case 92:
+    case 93:
+      return false;
+    default:
+      return true;
+  }
+}
+function normalizeMimeType(text, headerStart, comma) {
+  let end = headerStart;
+  while (end < comma && text[end] !== ";")
+    end++;
+  if (end === headerStart)
+    return "text/plain";
+  if (end - headerStart > MAX_MIME_CHARS)
+    return "application/octet-stream";
+  let slashCount = 0;
+  for (let i = headerStart;i < end; i++) {
+    const code = text.charCodeAt(i);
+    if (code === 47) {
+      slashCount++;
+      if (i === headerStart || i === end - 1)
+        return "application/octet-stream";
+      continue;
+    }
+    if (!isMimeTokenChar(code))
+      return "application/octet-stream";
+  }
+  if (slashCount !== 1)
+    return "application/octet-stream";
+  return text.slice(headerStart, end).toLowerCase();
+}
+function hexValue(code) {
+  if (code >= 48 && code <= 57)
+    return code - 48;
+  if (code >= 65 && code <= 70)
+    return code - 55;
+  if (code >= 97 && code <= 102)
+    return code - 87;
+  return -1;
+}
+function decodePercentEncoded(payload) {
+  const output = Buffer.allocUnsafe(Buffer.byteLength(payload, "utf8"));
+  let outputOffset = 0;
+  let cursor = 0;
+  while (cursor < payload.length) {
+    const percent = payload.indexOf("%", cursor);
+    const runEnd = percent < 0 ? payload.length : percent;
+    if (runEnd > cursor) {
+      const run = Buffer.from(payload.slice(cursor, runEnd), "utf8");
+      run.copy(output, outputOffset);
+      outputOffset += run.length;
+    }
+    if (percent < 0)
+      break;
+    if (percent + 2 >= payload.length)
+      return { error: "invalid-percent-escape" };
+    const high = hexValue(payload.charCodeAt(percent + 1));
+    const low = hexValue(payload.charCodeAt(percent + 2));
+    if (high < 0 || low < 0)
+      return { error: "invalid-percent-escape" };
+    output[outputOffset++] = high << 4 | low;
+    cursor = percent + 3;
+  }
+  return { bytes: output.subarray(0, outputOffset) };
+}
+function isBase64AlphabetByte(byte) {
+  return byte >= 65 && byte <= 90 || byte >= 97 && byte <= 122 || byte >= 48 && byte <= 57 || byte === 43 || byte === 47;
+}
+function decodeBase64Payload(payload) {
+  const percentDecoded = decodePercentEncoded(payload);
+  if ("error" in percentDecoded)
+    return percentDecoded;
+  const encoded = percentDecoded.bytes;
+  let paddingStart = encoded.length;
+  let paddingCount = 0;
+  for (let i = 0;i < encoded.length; i++) {
+    const byte = encoded[i];
+    if (byte > 127)
+      return { error: "non-ascii-base64" };
+    if (byte === 61) {
+      if (paddingStart === encoded.length)
+        paddingStart = i;
+      paddingCount++;
+      continue;
+    }
+    if (paddingStart !== encoded.length)
+      return { error: "invalid-base64-padding" };
+    if (!isBase64AlphabetByte(byte))
+      return { error: "invalid-base64-character" };
+  }
+  if (paddingCount > 2)
+    return { error: "invalid-base64-padding" };
+  if (paddingCount > 0 && encoded.length % 4 !== 0)
+    return { error: "invalid-base64-padding" };
+  if (paddingCount === 0 && encoded.length % 4 === 1)
+    return { error: "invalid-base64-length" };
+  if (paddingCount === 1 && paddingStart % 4 !== 3)
+    return { error: "invalid-base64-padding" };
+  if (paddingCount === 2 && paddingStart % 4 !== 2)
+    return { error: "invalid-base64-padding" };
+  return { bytes: Buffer.from(encoded.toString("ascii"), "base64") };
+}
+function safeMarkerSource(sourcePath) {
+  const source = sourcePath || "value";
+  let safe = "";
+  for (const ch of source) {
+    const code = ch.charCodeAt(0);
+    const allowed = code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || ch === "." || ch === "_" || ch === "-" || ch === "[" || ch === "]" || ch === "*" || ch === "$";
+    safe += allowed ? ch : "_";
+  }
+  if (safe.length <= MAX_MARKER_SOURCE_CHARS)
+    return safe;
+  const suffix = sha256Bytes(source).slice(0, 12);
+  return `${safe.slice(0, MAX_MARKER_SOURCE_CHARS - suffix.length - 1)}~${suffix}`;
+}
+function buildDataUriMarker(omission) {
+  const decoded = omission.decodedBytes === null ? "unknown" : String(omission.decodedBytes);
+  const decodeError = omission.decodeError ? `; decodeError=${omission.decodeError}` : "";
+  return `[dm-web-access inline data URI omitted; ordinal=${omission.ordinal}; source=${omission.sourcePath}; mime=${omission.mimeType}; encoding=${omission.encoding}; encodedBytes=${omission.encodedBytes}; decodedBytes=${decoded}${decodeError}; sha256=${omission.sha256}; digestBasis=${omission.digestBasis}; retrieval=not-retained]`;
+}
+function sanitizeTextInternal(text, sourcePath, state) {
+  let scanFrom = 0;
+  let retainedFrom = 0;
+  let outputLength = 0;
+  const pieces = [];
+  while (scanFrom < text.length) {
+    const start = findNextDataScheme(text, scanFrom);
+    if (start < 0)
+      break;
+    const candidate = scanDataUriCandidate(text, start);
+    const end = candidate.end;
+    const headerStart = start + 5;
+    const missingComma = candidate.comma < 0;
+    if (missingComma && end === headerStart && candidate.enclosure === null) {
+      scanFrom = end;
+      continue;
+    }
+    const headerEnd = missingComma ? end : candidate.comma;
+    const headerLength = headerEnd - headerStart;
+    const encoding = headerEndsWithBase64(text, headerStart, headerEnd) ? "base64" : "percent-encoded";
+    const mimeType = normalizeMimeType(text, headerStart, headerEnd);
+    const payload = missingComma ? text.slice(headerStart, end) : text.slice(candidate.comma + 1, end);
+    const encodedBytes = Buffer.byteLength(payload, "utf8");
+    let decodedBytes = null;
+    let decodeError;
+    let digestBasis = "encoded";
+    let digest = "";
+    if (missingComma) {
+      decodeError = "missing-comma";
+      digest = sha256Bytes(payload);
+    } else if (headerLength > MAX_DATA_URI_HEADER_CHARS) {
+      decodeError = "header-too-long";
+      digest = sha256Bytes(payload);
+    } else {
+      const decoded = encoding === "base64" ? decodeBase64Payload(payload) : decodePercentEncoded(payload);
+      if ("error" in decoded) {
+        decodeError = decoded.error;
+        digest = sha256Bytes(payload);
+      } else {
+        decodedBytes = decoded.bytes.length;
+        digestBasis = "decoded";
+        digest = sha256Bytes(decoded.bytes);
+      }
+    }
+    const omission = {
+      ordinal: state.nextOrdinal++,
+      sourcePath: safeMarkerSource(sourcePath),
+      mimeType,
+      encoding,
+      encodedBytes,
+      decodedBytes,
+      ...decodeError ? { decodeError } : {},
+      sha256: digest,
+      digestBasis,
+      retrieval: "not-retained"
+    };
+    const marker = buildDataUriMarker(omission);
+    const prefix = text.slice(retainedFrom, start);
+    pieces.push(prefix, marker);
+    outputLength += prefix.length;
+    const markerStart = outputLength;
+    outputLength += marker.length;
+    state.omissions.push({ ...omission, markerStart, markerEnd: outputLength });
+    retainedFrom = end;
+    scanFrom = end;
+  }
+  if (state.omissions.length === 0 && retainedFrom === 0)
+    return text;
+  pieces.push(text.slice(retainedFrom));
+  return pieces.join("");
+}
+export function sanitizeInlineDataUris(text, sourcePath) {
+  const state = { nextOrdinal: 1, omissions: [] };
+  const sanitized = sanitizeTextInternal(text, sourcePath, state);
+  return {
+    text: sanitized,
+    omissions: state.omissions.map(({ markerStart: _start, markerEnd: _end, ...omission }) => omission)
+  };
+}

package/extensions/dm-web-access/datalab-pdf-extract.js

@@ -0,0 +1,346 @@
+import { existsSync, readFileSync } from "node:fs";
+import {
+  hasCredentialSource,
+  resolveCredential,
+  redactCredential
+} from "./credential-source.js";
+import { getWebSearchConfigPath } from "./utils.js";
+const DEFAULT_API_HOST = "https://www.datalab.to";
+const API_PREFIX = "/api/v1";
+const DEFAULT_TIMEOUT_MS = 120000;
+const DEFAULT_POLL_INTERVAL_MS = 1500;
+const MAX_RESPONSE_BYTES = 4 * 1024 * 1024;
+const MAX_ERROR_BODY_BYTES = 300;
+const CLEANUP_TIMEOUT_MS = 5000;
+const CONFIG_PATH = getWebSearchConfigPath();
+export const DATALAB_MODE_VALUES = new Set([
+  "fast",
+  "balanced",
+  "accurate"
+]);
+export const DATALAB_LOCATION_VALUES = new Set([
+  "eu",
+  "us"
+]);
+export const DEFAULT_DATALAB_MODE = "balanced";
+export const DEFAULT_PROCESSING_LOCATION = "us";
+export const DEFAULT_DATALAB_TIMEOUT_MS = DEFAULT_TIMEOUT_MS;
+let cachedConfig = null;
+function loadConfig() {
+  if (cachedConfig)
+    return cachedConfig;
+  if (!existsSync(CONFIG_PATH)) {
+    cachedConfig = {};
+    return cachedConfig;
+  }
+  const rawText = readFileSync(CONFIG_PATH, "utf-8");
+  try {
+    cachedConfig = JSON.parse(rawText);
+    return cachedConfig;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to parse ${CONFIG_PATH}: ${message}`);
+  }
+}
+function normalizeString(value) {
+  if (typeof value !== "string")
+    return null;
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : null;
+}
+function normalizeFileId(value) {
+  if (typeof value === "number" && Number.isFinite(value))
+    return String(value);
+  return normalizeString(value);
+}
+export function isDatalabApiAvailable() {
+  return hasCredentialSource({
+    provider: "Datalab",
+    configuredValue: loadConfig().datalabApiKey,
+    environmentValue: process.env.DATALAB_API_KEY
+  });
+}
+export async function getDatalabApiKey(signal) {
+  return resolveCredential({
+    provider: "Datalab",
+    configuredValue: loadConfig().datalabApiKey,
+    environmentValue: process.env.DATALAB_API_KEY,
+    signal
+  });
+}
+export function getDatalabApiBase() {
+  const normalized = normalizeString(process.env.DATALAB_API_BASE)?.replace(/\/+$/, "");
+  return normalized || `${DEFAULT_API_HOST}${API_PREFIX}`;
+}
+export function getDatalabProcessingLocation() {
+  const value = normalizeString(process.env.DATALAB_PROCESSING_LOCATION) ?? DEFAULT_PROCESSING_LOCATION;
+  const normalized = value.toLowerCase();
+  if (!DATALAB_LOCATION_VALUES.has(normalized)) {
+    throw new Error(`Failed to parse DATALAB_PROCESSING_LOCATION: expected "eu" or "us", got "${value}"`);
+  }
+  return normalized;
+}
+export function normalizeDatalabMode(value) {
+  const raw = normalizeString(value);
+  if (!raw)
+    return DEFAULT_DATALAB_MODE;
+  const normalized = raw.toLowerCase();
+  if (DATALAB_MODE_VALUES.has(normalized))
+    return normalized;
+  throw new Error(`Failed to parse datalab mode: expected "fast", "balanced", or "accurate", got "${value}"`);
+}
+export async function extractPDFViaDatalab(buffer, options) {
+  options.signal?.throwIfAborted();
+  const apiKey = await getDatalabApiKey(options.signal);
+  options.signal?.throwIfAborted();
+  if (!apiKey) {
+    throw new Error("Datalab PDF conversion requires a configured Datalab API key");
+  }
+  const mode = options.mode ?? normalizeDatalabMode(process.env.DATALAB_MODE);
+  const processingLocation = options.processingLocation ?? getDatalabProcessingLocation();
+  const timeoutMs = typeof options.timeoutMs === "number" && Number.isFinite(options.timeoutMs) && options.timeoutMs > 0 ? Math.floor(options.timeoutMs) : DEFAULT_TIMEOUT_MS;
+  const deadline = Date.now() + timeoutMs;
+  const upload = await requestUploadUrl({
+    apiKey,
+    title: options.title,
+    processingLocation,
+    signal: options.signal,
+    deadline
+  });
+  if (typeof upload.upload_url !== "string" || !upload.upload_url) {
+    throw new Error("Datalab PDF conversion failed: missing upload_url");
+  }
+  const uploadFileId = normalizeFileId(upload.file_id);
+  if (!uploadFileId) {
+    throw new Error("Datalab PDF conversion failed: missing file_id");
+  }
+  let fileId = uploadFileId;
+  let reference = normalizeString(upload.reference);
+  try {
+    const put = await fetchDatalab(upload.upload_url, {
+      method: "PUT",
+      headers: { "content-type": "application/pdf" },
+      body: new Blob([buffer], { type: "application/pdf" }),
+      signal: withTimeout(options.signal, remaining(deadline))
+    }, apiKey);
+    if (!put.ok) {
+      throw new Error(`Datalab PDF upload failed: HTTP ${put.status} ${put.statusText}`);
+    }
+    const confirmed = await confirmUpload(apiKey, String(fileId), options.signal, deadline);
+    fileId = normalizeFileId(confirmed.file_id) ?? fileId;
+    reference = normalizeString(confirmed.reference) ?? reference;
+    if (!reference) {
+      throw new Error("Datalab PDF conversion failed: missing file reference");
+    }
+    const form = new FormData;
+    form.append("file_url", reference);
+    form.append("output_format", "markdown");
+    form.append("mode", mode);
+    form.append("max_pages", String(options.maxPages));
+    form.append("paginate", "true");
+    const submit = await fetchDatalab(`${getDatalabApiBase()}/convert`, {
+      method: "POST",
+      headers: { "x-api-key": apiKey },
+      body: form,
+      signal: withTimeout(options.signal, remaining(deadline))
+    }, apiKey);
+    const state = await readJsonResponse(submit, apiKey);
+    if (state.status === "complete")
+      return toResult(state);
+    if (state.status === "failed") {
+      throw new Error(`Datalab PDF conversion failed: ${state.error ?? "unknown error"}`);
+    }
+    const checkUrl = normalizeCheckUrl(state.request_check_url);
+    while (Date.now() < deadline) {
+      await sleep(Math.min(DEFAULT_POLL_INTERVAL_MS, remaining(deadline)), options.signal);
+      if (Date.now() >= deadline)
+        break;
+      const poll = await fetchDatalab(checkUrl, {
+        method: "GET",
+        headers: { "x-api-key": apiKey },
+        signal: withTimeout(options.signal, remaining(deadline))
+      }, apiKey);
+      const next = await readJsonResponse(poll, apiKey);
+      if (next.status === "complete")
+        return toResult(next);
+      if (next.status === "failed") {
+        throw new Error(`Datalab PDF conversion failed: ${next.error ?? "unknown error"}`);
+      }
+    }
+    throw new Error("Datalab PDF conversion timed out");
+  } finally {
+    deleteDatalabFile(apiKey, fileId);
+  }
+}
+async function requestUploadUrl(options) {
+  const { apiKey, title, processingLocation, signal, deadline } = options;
+  const response = await fetchDatalab(`${getDatalabApiBase()}/files/upload`, {
+    method: "POST",
+    headers: {
+      "x-api-key": apiKey,
+      "content-type": "application/json"
+    },
+    body: JSON.stringify({
+      filename: `${datalabFilename(title)}.pdf`,
+      content_type: "application/pdf",
+      processing_location: processingLocation
+    }),
+    signal: withTimeout(signal, remaining(deadline))
+  }, apiKey);
+  return readJsonResponse(response, apiKey);
+}
+async function confirmUpload(apiKey, fileId, signal, deadline) {
+  const response = await fetchDatalab(`${getDatalabApiBase()}/files/${encodeURIComponent(fileId)}/confirm`, {
+    method: "GET",
+    headers: { "x-api-key": apiKey },
+    signal: withTimeout(signal, remaining(deadline))
+  }, apiKey);
+  return readJsonResponse(response, apiKey);
+}
+async function deleteDatalabFile(apiKey, fileId) {
+  try {
+    await fetchDatalab(`${getDatalabApiBase()}/files/${encodeURIComponent(fileId)}`, {
+      method: "DELETE",
+      headers: { "x-api-key": apiKey },
+      signal: AbortSignal.timeout(CLEANUP_TIMEOUT_MS)
+    }, apiKey);
+  } catch {}
+}
+function toResult(state) {
+  const markdown = normalizeString(state.markdown);
+  if (!markdown) {
+    throw new Error("Datalab PDF conversion returned empty markdown");
+  }
+  const quality = state.parse_quality_score;
+  return {
+    markdown,
+    pages: numericField(state.page_count) ?? countPageMarkers(markdown),
+    ...typeof quality === "number" && Number.isFinite(quality) ? { parseQualityScore: quality } : {}
+  };
+}
+function numericField(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : null;
+}
+function countPageMarkers(markdown) {
+  return [...markdown.matchAll(/^<!-- Page (\d+) -->$/gm)].length;
+}
+function normalizeCheckUrl(value) {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error("Datalab PDF conversion failed: missing request_check_url");
+  }
+  const apiBase = getDatalabApiUrl();
+  let checkUrl;
+  try {
+    checkUrl = new URL(value.trim(), apiBase);
+  } catch {
+    throw new Error("Datalab PDF conversion failed: invalid request_check_url");
+  }
+  if (checkUrl.origin !== apiBase.origin) {
+    throw new Error("Datalab PDF conversion failed: request_check_url has an unexpected origin");
+  }
+  return checkUrl.toString();
+}
+function getDatalabApiUrl() {
+  try {
+    return new URL(getDatalabApiBase());
+  } catch {
+    throw new Error("Failed to parse DATALAB_API_BASE: expected an absolute URL");
+  }
+}
+function remaining(deadline) {
+  return Math.max(1, deadline - Date.now());
+}
+function withTimeout(signal, timeoutMs) {
+  const timeout = AbortSignal.timeout(timeoutMs);
+  return signal ? AbortSignal.any([signal, timeout]) : timeout;
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    let timer;
+    const cleanup = () => signal?.removeEventListener("abort", onAbort);
+    const onTimeout = () => {
+      cleanup();
+      resolve();
+    };
+    const onAbort = () => {
+      clearTimeout(timer);
+      cleanup();
+      reject(signal?.reason);
+    };
+    if (signal?.aborted) {
+      onAbort();
+      return;
+    }
+    timer = setTimeout(onTimeout, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function fetchDatalab(url, init, apiKey) {
+  try {
+    return await fetch(url, { ...init, redirect: init.redirect ?? "error" });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const redacted = redactCredential(message, apiKey);
+    if (redacted === message)
+      throw error;
+    const redactedError = new Error(redacted);
+    if (error instanceof Error)
+      redactedError.name = error.name;
+    throw redactedError;
+  }
+}
+async function readJsonResponse(response, apiKey) {
+  const text = await readResponseText(response);
+  if (!response.ok) {
+    const detail = text.trim().slice(0, MAX_ERROR_BODY_BYTES);
+    const message = detail ? `Datalab PDF conversion failed: HTTP ${response.status} ${response.statusText}: ${detail}` : `Datalab PDF conversion failed: HTTP ${response.status} ${response.statusText}`;
+    throw new Error(redactCredential(message, apiKey));
+  }
+  return parseJsonRecord(text);
+}
+function parseJsonRecord(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (error) {
+    throw new Error("Datalab PDF conversion returned invalid JSON", { cause: error });
+  }
+  if (Object.prototype.toString.call(parsed) !== "[object Object]") {
+    throw new Error("Datalab PDF conversion returned invalid JSON object");
+  }
+  return parsed;
+}
+async function readResponseText(response) {
+  const contentLength = Number(response.headers.get("content-length"));
+  if (Number.isFinite(contentLength) && contentLength > MAX_RESPONSE_BYTES) {
+    throw new Error("Datalab PDF conversion response too large");
+  }
+  if (!response.body)
+    return "";
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder;
+  const chunks = [];
+  let bytesRead = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      bytesRead += value.byteLength;
+      if (bytesRead > MAX_RESPONSE_BYTES) {
+        try {
+          await reader.cancel();
+        } catch {}
+        throw new Error("Datalab PDF conversion response too large");
+      }
+      chunks.push(decoder.decode(value, { stream: true }));
+    }
+    chunks.push(decoder.decode());
+    return chunks.join("");
+  } finally {
+    reader.releaseLock();
+  }
+}
+function datalabFilename(title) {
+  return title.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 60) || "document";
+}