@firedrill-tools/unstructured 0.1.4

package/firedrill/tools/unstructured/lib/partition/text.mjs

@@ -0,0 +1,53 @@
+// Plain-text partitioning: form feeds separate pages, blank lines separate blocks, blocks are classified by rule.
+import { classifyBlock, stripListMarker } from "./elements.mjs";
+
+export const MAX_BLOCKS = 100000;
+
+/** Splits text into blocks on blank lines (any whitespace-only line). Returns null when the block bound is exceeded. */
+export function blocksOf(text) {
+  const blocks = [];
+  let current = [];
+  for (const rawLine of text.split("\n")) {
+    const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+    if (line.trim().length === 0) {
+      if (current.length > 0) {
+        blocks.push(current.join("\n"));
+        current = [];
+        if (blocks.length > MAX_BLOCKS) return null;
+      }
+    } else current.push(line);
+  }
+  if (current.length > 0) blocks.push(current.join("\n"));
+  return blocks.length > MAX_BLOCKS ? null : blocks;
+}
+
+/** Emits the elements of one page of plain text into the builder; returns false when the block bound is exceeded. */
+export function emitPlainBlocks(builder, text) {
+  const blocks = blocksOf(text);
+  if (blocks === null) return false;
+  for (const block of blocks) {
+    // Once the builder has overflowed (element or byte bound) nothing more can be added; stop instead of classifying the rest.
+    if (builder.overflow) return true;
+    const type = classifyBlock(block);
+    if (type === "ListItem") {
+      for (const line of block.split("\n")) {
+        if (builder.overflow) return true;
+        builder.add("ListItem", stripListMarker(line).trim());
+      }
+    } else if (type === "Title") builder.add("Title", block.trim(), { category_depth: 0 });
+    else if (type === "Address") builder.add("Address", block.split("\n").map((l) => l.trim()).join("\n"));
+    else builder.add(type, block.split("\n").map((l) => l.trim()).join("\n"));
+  }
+  return true;
+}
+
+/** Whole plain-text document: pages separated by U+000C. */
+export function partitionText(builder, text) {
+  const pages = text.split("\f");
+  for (let index = 0; index < pages.length; index += 1) {
+    if (builder.overflow) return { ok: true };
+    if (index > 0) builder.pageBreak();
+    if (!emitPlainBlocks(builder, pages[index])) return { ok: false, message: "File has too many text blocks" };
+  }
+  return { ok: true };
+}

package/firedrill/tools/unstructured/lib/sha256.mjs

@@ -0,0 +1,161 @@
+// Pure SHA-256 over UTF-8 text (hex digest). Used for deterministic element ids, so it runs once per element: the message is
+// encoded straight into a reused byte buffer (lone surrogates become U+FFFD), the schedule and state live in reused typed
+// arrays, and the digest is formatted through a lookup table. No allocation per block.
+
+const K = new Int32Array([
+  0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
+  0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+  0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
+  0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+  0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
+  0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+]);
+const HEX = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+const W = new Int32Array(64);
+const H = new Int32Array(8);
+let buffer = new Uint8Array(1024);
+
+/** Writes the UTF-8 bytes of the concatenated `parts` plus SHA-256 padding into `buffer`; returns the padded length (a multiple of 64). */
+function encode(parts) {
+  let chars = 0;
+  for (let p = 0; p < parts.length; p += 1) chars += parts[p].length;
+  const need = chars * 3 + 72;
+  if (buffer.length < need) buffer = new Uint8Array(Math.max(need, buffer.length * 2));
+  const out = buffer;
+  let n = 0;
+  for (let p = 0; p < parts.length; p += 1) {
+    const text = parts[p];
+    for (let i = 0; i < text.length; i += 1) {
+      let code = text.charCodeAt(i);
+      if (code < 0x80) {
+        out[n++] = code;
+        continue;
+      }
+      if (code >= 0xd800 && code <= 0xdbff && i + 1 < text.length) {
+        const low = text.charCodeAt(i + 1);
+        if (low >= 0xdc00 && low <= 0xdfff) {
+          code = 0x10000 + ((code - 0xd800) << 10) + (low - 0xdc00);
+          i += 1;
+        } else code = 0xfffd;
+      } else if (code >= 0xd800 && code <= 0xdfff) code = 0xfffd;
+      if (code < 0x800) {
+        out[n++] = 0xc0 | (code >> 6);
+        out[n++] = 0x80 | (code & 0x3f);
+      } else if (code < 0x10000) {
+        out[n++] = 0xe0 | (code >> 12);
+        out[n++] = 0x80 | ((code >> 6) & 0x3f);
+        out[n++] = 0x80 | (code & 0x3f);
+      } else {
+        out[n++] = 0xf0 | (code >> 18);
+        out[n++] = 0x80 | ((code >> 12) & 0x3f);
+        out[n++] = 0x80 | ((code >> 6) & 0x3f);
+        out[n++] = 0x80 | (code & 0x3f);
+      }
+    }
+  }
+  const bitLength = n * 8;
+  out[n++] = 0x80;
+  while (n % 64 !== 56) out[n++] = 0;
+  const high = Math.floor(bitLength / 0x100000000);
+  const low = bitLength >>> 0;
+  out[n++] = (high >>> 24) & 255;
+  out[n++] = (high >>> 16) & 255;
+  out[n++] = (high >>> 8) & 255;
+  out[n++] = high & 255;
+  out[n++] = (low >>> 24) & 255;
+  out[n++] = (low >>> 16) & 255;
+  out[n++] = (low >>> 8) & 255;
+  out[n++] = low & 255;
+  return n;
+}
+
+/**
+ * Hex SHA-256 of the UTF-8 encoding of `parts` joined (without building the joined string). A surrogate pair must not be split
+ * across two parts; callers separate parts with ASCII.
+ */
+export function sha256Hex(...parts) {
+  digest(parts);
+  return hexOf(8);
+}
+
+/** The first 32 hex characters of `sha256Hex(a, NUL, b, NUL, c, NUL, d)` (element and chunk ids), without a rest array. */
+export function sha256Id(a, b, c, d) {
+  ID_PARTS[0] = a;
+  ID_PARTS[2] = b;
+  ID_PARTS[4] = c;
+  ID_PARTS[6] = d;
+  digest(ID_PARTS);
+  ID_PARTS[0] = ID_PARTS[2] = ID_PARTS[4] = ID_PARTS[6] = "";
+  return hexOf(4);
+}
+
+const NUL = String.fromCharCode(0);
+const ID_PARTS = ["", NUL, "", NUL, "", NUL, ""];
+
+function hexOf(words) {
+  let hex = "";
+  for (let i = 0; i < words; i += 1) {
+    const word = H[i];
+    hex += HEX[(word >>> 24) & 255] + HEX[(word >>> 16) & 255] + HEX[(word >>> 8) & 255] + HEX[word & 255];
+  }
+  return hex;
+}
+
+/** Runs SHA-256 over the encoded `parts`, leaving the state words in `H`. */
+function digest(parts) {
+  const length = encode(parts);
+  const bytes = buffer;
+  const w = W;
+  const h = H;
+  h[0] = 0x6a09e667;
+  h[1] = 0xbb67ae85;
+  h[2] = 0x3c6ef372;
+  h[3] = 0xa54ff53a;
+  h[4] = 0x510e527f;
+  h[5] = 0x9b05688c;
+  h[6] = 0x1f83d9ab;
+  h[7] = 0x5be0cd19;
+  for (let offset = 0; offset < length; offset += 64) {
+    for (let i = 0; i < 16; i += 1) {
+      const j = offset + (i << 2);
+      w[i] = (bytes[j] << 24) | (bytes[j + 1] << 16) | (bytes[j + 2] << 8) | bytes[j + 3];
+    }
+    for (let i = 16; i < 64; i += 1) {
+      const x = w[i - 15];
+      const y = w[i - 2];
+      const s0 = ((x >>> 7) | (x << 25)) ^ ((x >>> 18) | (x << 14)) ^ (x >>> 3);
+      const s1 = ((y >>> 17) | (y << 15)) ^ ((y >>> 19) | (y << 13)) ^ (y >>> 10);
+      w[i] = (w[i - 16] + s0 + w[i - 7] + s1) | 0;
+    }
+    let a = h[0];
+    let b = h[1];
+    let c = h[2];
+    let d = h[3];
+    let e = h[4];
+    let f = h[5];
+    let g = h[6];
+    let hh = h[7];
+    for (let i = 0; i < 64; i += 1) {
+      const s1 = ((e >>> 6) | (e << 26)) ^ ((e >>> 11) | (e << 21)) ^ ((e >>> 25) | (e << 7));
+      const t1 = (hh + s1 + ((e & f) ^ (~e & g)) + K[i] + w[i]) | 0;
+      const s0 = ((a >>> 2) | (a << 30)) ^ ((a >>> 13) | (a << 19)) ^ ((a >>> 22) | (a << 10));
+      const t2 = (s0 + ((a & b) ^ (a & c) ^ (b & c))) | 0;
+      hh = g;
+      g = f;
+      f = e;
+      e = (d + t1) | 0;
+      d = c;
+      c = b;
+      b = a;
+      a = (t1 + t2) | 0;
+    }
+    h[0] = (h[0] + a) | 0;
+    h[1] = (h[1] + b) | 0;
+    h[2] = (h[2] + c) | 0;
+    h[3] = (h[3] + d) | 0;
+    h[4] = (h[4] + e) | 0;
+    h[5] = (h[5] + f) | 0;
+    h[6] = (h[6] + g) | 0;
+    h[7] = (h[7] + hh) | 0;
+  }
+}

package/firedrill/tools/unstructured/lib/store.mjs

@@ -0,0 +1,33 @@
+// Bounded state scans: a namespace larger than its bound fails loudly instead of returning a truncated view.
+import { boundExceeded } from "./errors.mjs";
+
+/** Every row of `namespace` (values only, in row-id order); fails INTERNAL_ERROR past `bound` rows. */
+export function scanAll(context, namespace, bound) {
+  const out = [];
+  let after;
+  for (;;) {
+    const batch = context.state.scan(namespace, after === undefined ? { limit: 1000 } : { afterRowId: after, limit: 1000 });
+    for (const record of batch) {
+      out.push(record.value);
+      if (out.length > bound) boundExceeded(context, namespace, bound);
+    }
+    if (batch.length < 1000) return out;
+    after = batch[batch.length - 1].rowId;
+  }
+}
+
+/** Rows of a namespace whose row ids start with `prefix` (children keyed `<parent>:<child>`), bounded. */
+export function scanPrefix(context, namespace, prefix, bound) {
+  const out = [];
+  let after = prefix;
+  for (;;) {
+    const batch = context.state.scan(namespace, { afterRowId: after, limit: 1000 });
+    for (const record of batch) {
+      if (!record.rowId.startsWith(prefix)) return out;
+      out.push(record.value);
+      if (out.length > bound) boundExceeded(context, namespace, bound);
+    }
+    if (batch.length < 1000) return out;
+    after = batch[batch.length - 1].rowId;
+  }
+}

package/firedrill/tools/unstructured/lib/util.mjs

@@ -0,0 +1,149 @@
+// Small deterministic helpers shared by every module. No Node built-ins, no wall clock, no randomness.
+
+/** Clips caller text quoted in messages and outputs. */
+export function clip(value, max = 200) {
+  const text = typeof value === "string" ? value : String(value);
+  return text.length <= max ? text : `${text.slice(0, max)}…`;
+}
+
+export const isPlainObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+export const isInt = (value) => typeof value === "number" && Number.isInteger(value);
+export const isNonEmptyString = (value, max = Infinity) => typeof value === "string" && value.length > 0 && value.length <= max;
+
+/** UTF-8 byte length computed from code points (never Buffer). */
+export function utf8Length(text) {
+  let bytes = 0;
+  for (let i = 0; i < text.length; i += 1) {
+    const code = text.charCodeAt(i);
+    if (code < 0x80) bytes += 1;
+    else if (code < 0x800) bytes += 2;
+    else if (code >= 0xd800 && code <= 0xdbff) {
+      bytes += 4;
+      i += 1;
+    } else bytes += 3;
+  }
+  return bytes;
+}
+
+/** UTF-8 bytes of a string as a plain array of 0..255 numbers. Lone surrogates become U+FFFD. */
+export function utf8Bytes(text) {
+  const out = [];
+  for (let i = 0; i < text.length; i += 1) {
+    let code = text.charCodeAt(i);
+    if (code >= 0xd800 && code <= 0xdbff && i + 1 < text.length) {
+      const low = text.charCodeAt(i + 1);
+      if (low >= 0xdc00 && low <= 0xdfff) {
+        code = 0x10000 + ((code - 0xd800) << 10) + (low - 0xdc00);
+        i += 1;
+      } else code = 0xfffd;
+    } else if (code >= 0xd800 && code <= 0xdfff) code = 0xfffd;
+    if (code < 0x80) out.push(code);
+    else if (code < 0x800) out.push(0xc0 | (code >> 6), 0x80 | (code & 0x3f));
+    else if (code < 0x10000) out.push(0xe0 | (code >> 12), 0x80 | ((code >> 6) & 0x3f), 0x80 | (code & 0x3f));
+    else out.push(0xf0 | (code >> 18), 0x80 | ((code >> 12) & 0x3f), 0x80 | ((code >> 6) & 0x3f), 0x80 | (code & 0x3f));
+  }
+  return out;
+}
+
+/** Strict UTF-8 decoder over a byte array; returns null on any invalid sequence. */
+export function utf8Decode(bytes) {
+  let out = "";
+  for (let i = 0; i < bytes.length; ) {
+    const b0 = bytes[i];
+    let code;
+    let need;
+    if (b0 < 0x80) {
+      code = b0;
+      need = 0;
+    } else if (b0 >= 0xc2 && b0 <= 0xdf) {
+      code = b0 & 0x1f;
+      need = 1;
+    } else if (b0 >= 0xe0 && b0 <= 0xef) {
+      code = b0 & 0x0f;
+      need = 2;
+    } else if (b0 >= 0xf0 && b0 <= 0xf4) {
+      code = b0 & 0x07;
+      need = 3;
+    } else return null;
+    for (let k = 1; k <= need; k += 1) {
+      const b = bytes[i + k];
+      if (b === undefined || (b & 0xc0) !== 0x80) return null;
+      code = (code << 6) | (b & 0x3f);
+    }
+    if (need === 2 && code < 0x800) return null;
+    if (need === 3 && (code < 0x10000 || code > 0x10ffff)) return null;
+    if (code >= 0xd800 && code <= 0xdfff) return null;
+    out += String.fromCodePoint(code);
+    i += need + 1;
+  }
+  return out;
+}
+
+const B64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+export function base64Encode(bytes) {
+  let out = "";
+  for (let i = 0; i < bytes.length; i += 3) {
+    const a = bytes[i];
+    const b = i + 1 < bytes.length ? bytes[i + 1] : 0;
+    const c = i + 2 < bytes.length ? bytes[i + 2] : 0;
+    out += B64[a >> 2] + B64[((a & 3) << 4) | (b >> 4)];
+    out += i + 1 < bytes.length ? B64[((b & 15) << 2) | (c >> 6)] : "=";
+    out += i + 2 < bytes.length ? B64[c & 63] : "=";
+  }
+  return out;
+}
+
+/** Strict base64 decode (standard alphabet, correct padding, no whitespace); returns null when malformed. */
+export function base64Decode(text) {
+  if (typeof text !== "string" || text.length % 4 !== 0) return null;
+  const out = [];
+  for (let i = 0; i < text.length; i += 4) {
+    const chunk = text.slice(i, i + 4);
+    const pad = chunk.endsWith("==") ? 2 : chunk.endsWith("=") ? 1 : 0;
+    if (pad > 0 && i + 4 !== text.length) return null;
+    const values = [];
+    for (let k = 0; k < 4 - pad; k += 1) {
+      const idx = B64.indexOf(chunk[k]);
+      if (idx < 0) return null;
+      values.push(idx);
+    }
+    while (values.length < 4) values.push(0);
+    const n = (values[0] << 18) | (values[1] << 12) | (values[2] << 6) | values[3];
+    out.push((n >> 16) & 255);
+    if (pad < 2) out.push((n >> 8) & 255);
+    if (pad < 1) out.push(n & 255);
+  }
+  return out;
+}
+
+/** Virtual microseconds -> ISO 8601 UTC string with milliseconds. */
+export function isoFromUs(us) {
+  return new Date(Math.floor(us / 1000)).toISOString();
+}
+
+/** ISO 8601 UTC string (must end with Z or an explicit offset) -> microseconds, or null. */
+export function usFromIso(text) {
+  if (typeof text !== "string" || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{1,6})?(Z|[+-]\d{2}:\d{2})$/.test(text)) return null;
+  const ms = Date.parse(text);
+  return Number.isFinite(ms) ? ms * 1000 : null;
+}
+
+/** ISO 8601 duration for a non-negative number of whole seconds (PT1M13S). */
+export function isoDuration(seconds) {
+  const s = Math.max(0, Math.floor(seconds));
+  const h = Math.floor(s / 3600);
+  const m = Math.floor((s % 3600) / 60);
+  const r = s % 60;
+  let out = "PT";
+  if (h > 0) out += `${h}H`;
+  if (m > 0) out += `${m}M`;
+  if (r > 0 || out === "PT") out += `${r}S`;
+  return out;
+}
+
+export const ordered = (object, keys) => {
+  const out = {};
+  for (const key of keys) if (Object.hasOwn(object, key)) out[key] = object[key];
+  return out;
+};

package/firedrill/tools/unstructured/lib/validate.mjs

@@ -0,0 +1,115 @@
+// Pydantic-flavoured parsers for caller values that may arrive as strings (multipart, query) or typed JSON.
+import { clip } from "./util.mjs";
+
+const TRUE = new Set(["true", "1", "yes", "on", "t", "y"]);
+const FALSE = new Set(["false", "0", "no", "off", "f", "n"]);
+
+export function parseBool(value, loc, issues, fallback) {
+  if (value === undefined || value === null || value === "") return fallback;
+  if (typeof value === "boolean") return value;
+  if (typeof value === "string") {
+    const lower = value.trim().toLowerCase();
+    if (TRUE.has(lower)) return true;
+    if (FALSE.has(lower)) return false;
+  }
+  if (value === 1) return true;
+  if (value === 0) return false;
+  issues.add(loc, "Input should be a valid boolean, unable to interpret input");
+  return fallback;
+}
+
+export function parseInteger(value, loc, issues, fallback, { min = -Infinity, max = Infinity } = {}) {
+  if (value === undefined || value === null || value === "") return fallback;
+  let number = value;
+  if (typeof value === "string") {
+    if (!/^\s*-?\d{1,15}\s*$/.test(value)) {
+      issues.add(loc, "Input should be a valid integer, unable to parse string as an integer");
+      return fallback;
+    }
+    number = Number(value.trim());
+  }
+  if (typeof number !== "number" || !Number.isInteger(number)) {
+    issues.add(loc, "Input should be a valid integer");
+    return fallback;
+  }
+  if (number < min) {
+    issues.add(loc, `Input should be greater than or equal to ${min}`);
+    return fallback;
+  }
+  if (number > max) {
+    issues.add(loc, `Input should be less than or equal to ${max}`);
+    return fallback;
+  }
+  return number;
+}
+
+const quoteList = (allowed) => {
+  const quoted = allowed.map((item) => `'${item}'`);
+  return quoted.length <= 1 ? quoted.join("") : `${quoted.slice(0, -1).join(", ")} or ${quoted[quoted.length - 1]}`;
+};
+
+export function parseEnum(value, loc, issues, allowed, fallback) {
+  if (value === undefined || value === null || value === "") return fallback;
+  if (typeof value === "string" && allowed.includes(value)) return value;
+  issues.add(loc, `Input should be ${quoteList(allowed)}`);
+  return fallback;
+}
+
+export function parseString(value, loc, issues, { required = false, min = 0, max = 200 } = {}) {
+  if (value === undefined || value === null) {
+    if (required) issues.add(loc, "Field required");
+    return null;
+  }
+  if (typeof value !== "string") {
+    issues.add(loc, "Input should be a valid string");
+    return null;
+  }
+  if (value.length < min) {
+    issues.add(loc, `String should have at least ${min} character${min === 1 ? "" : "s"}`);
+    return null;
+  }
+  if (value.length > max) {
+    issues.add(loc, `String should have at most ${max} characters`);
+    return null;
+  }
+  return value;
+}
+
+/** Strings must not carry U+FFFD (a mangled percent-encoding) when used as identifiers or filters. */
+export const mangled = (value) => typeof value === "string" && value.includes("�");
+
+export const describe = (value) => clip(typeof value === "string" ? value : JSON.stringify(value) ?? String(value), 100);
+
+export const MAX_LANGUAGES = 20;
+export const MAX_LANGUAGE_LENGTH = 20;
+
+/**
+ * The `languages` parameter: an array of strings or one comma-separated string. More than MAX_LANGUAGES entries, an
+ * entry longer than MAX_LANGUAGE_LENGTH or a non-string entry is a validation issue; the list is never shortened.
+ * Returns the list (empty when absent) or null (issue added).
+ */
+export function parseLanguages(value, loc, issues) {
+  if (value === undefined || value === null || value === "") return [];
+  let list;
+  if (Array.isArray(value)) list = value;
+  else if (typeof value === "string") list = value.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+  else {
+    issues.add(loc, "Input should be a valid list");
+    return null;
+  }
+  if (list.length > MAX_LANGUAGES) {
+    issues.add(loc, `List should have at most ${MAX_LANGUAGES} items after validation, not ${list.length}`);
+    return null;
+  }
+  let ok = true;
+  for (const [index, item] of list.entries()) {
+    if (typeof item !== "string") {
+      issues.add(`${loc}.${index}`, "Input should be a valid string");
+      ok = false;
+    } else if (item.length > MAX_LANGUAGE_LENGTH) {
+      issues.add(`${loc}.${index}`, `String should have at most ${MAX_LANGUAGE_LENGTH} characters`);
+      ok = false;
+    }
+  }
+  return ok ? list : null;
+}

package/firedrill/tools/unstructured/lib/wire-multipart.mjs

@@ -0,0 +1,78 @@
+// Decoders for the two multipart routes (`POST /general/v0/general`, `POST /api/v1/workflows/{id}/run`).
+// The framework hands `text` bodies as strict UTF-8 strings, so only text documents can arrive here.
+import { isMultipart, parseMultipart } from "./multipart.mjs";
+import { base64Decode, clip, utf8Decode } from "./util.mjs";
+import { RESERVED, headerOf } from "./wire.mjs";
+
+const MAX_FILES = 32;
+const LIST_FIELDS = new Set(["languages", "ocr_languages", "skip_infer_table_types", "extract_image_block_types"]);
+const MAX_FIELDS = 64;
+
+function fileOf(part) {
+  const file = {
+    filename: typeof part.filename === "string" ? clip(part.filename, 500) : "",
+    content_type: part.contentType !== null && part.contentType !== "application/octet-stream" ? clip(part.contentType, 200) : null,
+    content: part.body,
+  };
+  if (part.lastModified !== null) file.last_modified = clip(part.lastModified, 100);
+  if (part.transferEncoding === "base64") {
+    const bytes = base64Decode(part.body.replace(/[\r\n]/g, ""));
+    const text = bytes === null ? null : utf8Decode(bytes);
+    if (text === null) file.bad_transfer = true;
+    else file.content = text;
+  } else if (part.transferEncoding !== null && part.transferEncoding !== "binary" && part.transferEncoding !== "8bit" && part.transferEncoding !== "7bit") {
+    file.bad_transfer = true;
+  }
+  return file;
+}
+
+/** Folds multipart parts into arguments: `fileField` parts -> array of files, other parts -> text or string-array fields. */
+function foldParts(parts, fileField, refuse) {
+  const args = {};
+  const files = [];
+  let fieldCount = 0;
+  for (const part of parts) {
+    if (part.name === fileField || part.name === `${fileField}[]`) {
+      if (files.length >= MAX_FILES) return refuse(`422:loc=body.${fileField}: At most ${MAX_FILES} files per request`);
+      files.push(fileOf(part));
+      continue;
+    }
+    const name = part.name.endsWith("[]") ? part.name.slice(0, -2) : part.name;
+    if (name.length === 0 || name === RESERVED || name === "__proto__" || name === "constructor" || name === "prototype") return refuse(`422:loc=body: Invalid form field name "${clip(part.name, 60)}"`);
+    if (part.filename !== null) return refuse(`422:loc=body.${clip(name, 100)}: Unexpected file upload; only "${fileField}" parts may carry a file`);
+    fieldCount += 1;
+    if (fieldCount > MAX_FIELDS) return refuse("422:loc=body: Too many form fields");
+    if (LIST_FIELDS.has(name)) {
+      if (!Object.hasOwn(args, name)) args[name] = [];
+      if (args[name].length < 64) args[name].push(part.body);
+    } else if (!Object.hasOwn(args, name)) args[name] = part.body;
+  }
+  if (files.length > 0) args[fileField] = files;
+  return args;
+}
+
+function multipartArgs(request, fileField, allowEmpty) {
+  const refuse = (message) => ({ [RESERVED]: clip(message, 300) });
+  const contentType = headerOf(request, "content-type");
+  const body = request.body.kind === "text" ? request.body.value : request.body.kind === "form" ? "form" : "";
+  if (request.body.kind === "json") return refuse("422:loc=body: Expected multipart/form-data");
+  if (request.body.kind === "form") return refuse("422:loc=body: Expected multipart/form-data, not application/x-www-form-urlencoded");
+  if (body.length === 0 && allowEmpty && (contentType === null || !isMultipart(contentType))) return {};
+  if (!isMultipart(contentType)) return refuse("422:loc=body: Expected multipart/form-data");
+  const parsed = parseMultipart(contentType, body);
+  if (parsed.error !== undefined) return refuse(`400:${parsed.error}`);
+  return foldParts(parsed.parts, fileField, refuse);
+}
+
+export function decodePartition(request) {
+  return { arguments: multipartArgs(request, "files", false) };
+}
+
+export function decodeRun(request) {
+  const args = { workflow_id: typeof request.path.workflow_id === "string" ? request.path.workflow_id : "" };
+  Object.assign(args, multipartArgs(request, "input_files", true));
+  const out = { arguments: args };
+  const key = headerOf(request, "idempotency-key");
+  if (typeof key === "string" && key.length > 0 && key.length <= 255) out.idempotencyKey = key;
+  return out;
+}