@dynamic-entity/server 2.5.0 → 3.0.0-rc.1

package/express.js

@@ -2,941 +2,20 @@
 
 var core = require('@dynamic-entity/core');
 var express = require('express');
-var Busboy = require('busboy');
-var ExcelJS = require('exceljs');
-var stream = require('stream');
-var zlib = require('zlib');
+var node = require('sheet-to-schema/node');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var express__default = /*#__PURE__*/_interopDefault(express);
-var Busboy__default = /*#__PURE__*/_interopDefault(Busboy);
-var ExcelJS__default = /*#__PURE__*/_interopDefault(ExcelJS);
-var zlib__default = /*#__PURE__*/_interopDefault(zlib);
 
 // src/express.ts
-
-// src/errors.ts
-var STATUS = {
-  NO_FILE: 400,
-  TOO_MANY_FILES: 400,
-  TOO_LARGE: 413,
-  UNSUPPORTED_FORMAT: 415,
-  MALFORMED_FILE: 400,
-  ARCHIVE_REFUSED: 400,
-  SHEET_TOO_LARGE: 413,
-  UNKNOWN_ENTITY: 404,
-  INVALID_PLAN: 400,
-  TIMEOUT: 408,
-  IMPORT_FAILED: 500,
-  INTERNAL: 500
-};
-var ImportError = class extends Error {
-  code;
-  status;
-  details;
-  constructor(code, message, options = {}) {
-    super(message);
-    this.name = "ImportError";
-    this.code = code;
-    this.status = STATUS[code] ?? 500;
-    this.details = options.details;
-    if (options.cause !== void 0) this.cause = options.cause;
-  }
-};
-function toErrorBody(error) {
-  if (error instanceof ImportError) {
-    return {
-      status: error.status,
-      body: {
-        error: {
-          code: error.code,
-          message: error.message,
-          ...error.details === void 0 ? {} : { details: error.details }
-        }
-      }
-    };
-  }
-  return {
-    status: 500,
-    body: { error: { code: "INTERNAL", message: "The import could not be completed." } }
-  };
-}
-
-// src/bytes.ts
-async function* toByteStream(source) {
-  if (source instanceof Uint8Array) {
-    yield source;
-    return;
-  }
-  if (Symbol.asyncIterator in source) {
-    for await (const chunk of source) yield asBytes(chunk);
-    return;
-  }
-  for (const chunk of source) yield asBytes(chunk);
-}
-function asBytes(chunk) {
-  return typeof chunk === "string" ? Buffer.from(chunk, "utf8") : chunk;
-}
-async function* limitBytes(source, maxBytes) {
-  let seen = 0;
-  for await (const chunk of source) {
-    seen += chunk.byteLength;
-    if (seen > maxBytes) {
-      throw new ImportError("TOO_LARGE", `The file is larger than the ${maxBytes} byte limit.`);
-    }
-    yield chunk;
-  }
-}
-async function peek(source, n) {
-  const iterator = source[Symbol.asyncIterator]();
-  const taken = [];
-  let size = 0;
-  while (size < n) {
-    const next = await iterator.next();
-    if (next.done) break;
-    taken.push(next.value);
-    size += next.value.byteLength;
-  }
-  const head = Buffer.concat(taken.map((c) => Buffer.from(c.buffer, c.byteOffset, c.byteLength)));
-  async function* replay() {
-    for (const chunk of taken) yield chunk;
-    for (let next = await iterator.next(); !next.done; next = await iterator.next()) {
-      yield next.value;
-    }
-  }
-  return { head: head.subarray(0, n), stream: replay() };
-}
-function destroySource(source) {
-  const candidate = source;
-  try {
-    if (typeof candidate?.destroy === "function") candidate.destroy();
-    else if (typeof candidate?.return === "function") candidate.return();
-  } catch {
-  }
-}
-
-// src/limits.ts
-var DEFAULT_LIMITS = {
-  maxBytes: 10 * 1024 * 1024,
-  maxFields: 16,
-  maxFieldBytes: 1024 * 1024,
-  maxFieldNameBytes: 200,
-  maxFiles: 1,
-  maxRows: 2e5,
-  maxColumns: 512,
-  maxCellLength: 32768,
-  maxUncompressedBytes: 200 * 1024 * 1024,
-  maxCompressionRatio: 200,
-  maxZipEntries: 512,
-  batchSize: 500,
-  maxReportedErrors: 200,
-  sampleRows: 5,
-  idleTimeoutMs: 3e4,
-  totalTimeoutMs: 10 * 6e4
-};
-function resolveLimits(overrides) {
-  const out = { ...DEFAULT_LIMITS };
-  if (!overrides) return out;
-  for (const key of Object.keys(DEFAULT_LIMITS)) {
-    const value = overrides[key];
-    if (typeof value === "number" && Number.isFinite(value) && value > 0) {
-      out[key] = Math.floor(value);
-    }
-  }
-  return out;
-}
-function receiveUpload(request, limits) {
-  return new Promise((resolve, reject) => {
-    let settled = false;
-    let file = null;
-    const fail = (error) => {
-      if (settled) {
-        file?.destroy(error);
-        return;
-      }
-      settled = true;
-      request.unpipe(parser);
-      reject(error);
-    };
-    let parser;
-    try {
-      parser = Busboy__default.default({
-        headers: request.headers,
-        limits: {
-          fileSize: limits.maxBytes,
-          files: limits.maxFiles,
-          fields: limits.maxFields,
-          fieldSize: limits.maxFieldBytes,
-          fieldNameSize: limits.maxFieldNameBytes,
-          // A part that is neither a field nor a file still costs a parse.
-          parts: limits.maxFields + limits.maxFiles
-        }
-      });
-    } catch (cause) {
-      reject(new ImportError("MALFORMED_FILE", "This is not a multipart upload.", { cause }));
-      return;
-    }
-    const fields = {};
-    let sawFile = false;
-    parser.on("field", (name, value, info) => {
-      if (info.nameTruncated || info.valueTruncated) {
-        fail(new ImportError("TOO_LARGE", `The "${safeFieldName(name)}" field is too long.`));
-        return;
-      }
-      if (Object.prototype.hasOwnProperty.call(fields, name)) {
-        fail(new ImportError("MALFORMED_FILE", `The upload repeats the "${safeFieldName(name)}" field.`));
-        return;
-      }
-      fields[name] = value;
-    });
-    parser.on("file", (_name, stream, info) => {
-      if (sawFile) {
-        stream.resume();
-        fail(new ImportError("TOO_MANY_FILES", "Send one file at a time."));
-        return;
-      }
-      sawFile = true;
-      file = stream;
-      stream.on("error", () => void 0);
-      stream.on("limit", () => {
-        stream.destroy(
-          new ImportError("TOO_LARGE", `The file is larger than the ${limits.maxBytes} byte limit.`)
-        );
-      });
-      if (settled) {
-        stream.resume();
-        return;
-      }
-      settled = true;
-      resolve({ fields, filename: String(info.filename ?? ""), stream });
-    });
-    parser.on("filesLimit", () => fail(new ImportError("TOO_MANY_FILES", "Send one file at a time.")));
-    parser.on("fieldsLimit", () => fail(new ImportError("TOO_LARGE", "The upload has too many fields.")));
-    parser.on("partsLimit", () => fail(new ImportError("TOO_LARGE", "The upload has too many parts.")));
-    parser.on(
-      "error",
-      (cause) => fail(new ImportError("MALFORMED_FILE", "The upload could not be read.", { cause }))
-    );
-    parser.on("close", () => {
-      if (!sawFile) fail(new ImportError("NO_FILE", "No file was uploaded."));
-    });
-    request.on("close", () => {
-      if (!request.complete) fail(new ImportError("TIMEOUT", "The upload did not finish."));
-    });
-    request.pipe(parser);
-  });
-}
-function safeFieldName(name) {
-  return String(name).replace(/[^\w.-]/g, "").slice(0, 40) || "unnamed";
-}
-function readPlanField(fields) {
-  const raw = fields["plan"];
-  if (raw === void 0) {
-    throw new ImportError(
-      "INVALID_PLAN",
-      'No mapping plan was sent. The "plan" field must come before the file part.'
-    );
-  }
-  try {
-    return JSON.parse(raw);
-  } catch (cause) {
-    throw new ImportError("INVALID_PLAN", "The mapping plan is not valid JSON.", { cause });
-  }
-}
-var LOCAL_HEADER = 67324752;
-var CENTRAL_HEADER = 33639248;
-var END_OF_CENTRAL = 101010256;
-var DATA_DESCRIPTOR = 134695760;
-var HEADER_SIZE = 30;
-var HAS_DATA_DESCRIPTOR = 8;
-var ZIP64_SENTINEL = 4294967295;
-var SLICE = 64 * 1024;
-var STORED = 0;
-var DEFLATED = 8;
-var ZIP32_MAX = 4294967295;
-var WANTED = [
-  "[Content_Types].xml",
-  "_rels/.rels",
-  "xl/_rels/workbook.xml.rels",
-  "xl/workbook.xml",
-  "xl/styles.xml",
-  "xl/sharedStrings.xml"
-];
-var WORKSHEET = /^xl\/worksheets\/sheet(\d+)\.xml$/;
-function sheetNumber(name) {
-  const match = WORKSHEET.exec(name);
-  return match ? Number(match[1]) : null;
-}
-var refuse = (message) => {
-  throw new ImportError("ARCHIVE_REFUSED", message);
-};
-var CRC_TABLE = (() => {
-  const table = new Int32Array(256);
-  for (let i = 0; i < 256; i++) {
-    let c = i;
-    for (let k = 0; k < 8; k++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
-    table[i] = c;
-  }
-  return table;
-})();
-function crc32(current, bytes) {
-  let c = ~current;
-  for (let i = 0; i < bytes.length; i++) c = CRC_TABLE[(c ^ bytes[i]) & 255] ^ c >>> 8;
-  return ~c >>> 0;
-}
-var ZipScanner = class {
-  constructor(iterator) {
-    this.iterator = iterator;
-  }
-  iterator;
-  buffer = Buffer.alloc(0);
-  eof = false;
-  get available() {
-    return this.buffer.length;
-  }
-  /** Pull until at least `n` bytes are buffered. False means the stream ended first. */
-  async need(n) {
-    while (this.buffer.length < n && !this.eof) {
-      const next = await this.iterator.next();
-      if (next.done) {
-        this.eof = true;
-        break;
-      }
-      const chunk = Buffer.from(next.value.buffer, next.value.byteOffset, next.value.byteLength);
-      this.buffer = this.buffer.length ? Buffer.concat([this.buffer, chunk]) : chunk;
-    }
-    return this.buffer.length >= n;
-  }
-  peek(n) {
-    return this.buffer.subarray(0, Math.min(n, this.buffer.length));
-  }
-  take(n) {
-    const chunk = this.buffer.subarray(0, n);
-    this.buffer = this.buffer.subarray(n);
-    return chunk;
-  }
-  pushBack(bytes) {
-    if (bytes.length) this.buffer = Buffer.concat([bytes, this.buffer]);
-  }
-};
-function writeChunk(inflater, chunk) {
-  return new Promise((resolve, reject) => {
-    const onError = (error) => {
-      inflater.removeListener("error", onError);
-      reject(error);
-    };
-    inflater.once("error", onError);
-    inflater.write(chunk, (error) => {
-      inflater.removeListener("error", onError);
-      if (error) reject(error);
-      else resolve();
-    });
-  });
-}
-var settle = () => new Promise((resolve) => setImmediate(resolve));
-async function readDeflated(scanner, budget, limits, name, declared, keep) {
-  const retain = (slice) => {
-    budget.retained += slice.length;
-    if (budget.retained > limits.maxBytes) {
-      refuse(`The workbook is larger than the ${limits.maxBytes} byte limit.`);
-    }
-  };
-  const inflater = zlib__default.default.createInflateRaw();
-  const kept = [];
-  let produced = 0;
-  let consumed = 0;
-  let crc = 0;
-  let ended = false;
-  let failure = null;
-  let breach = null;
-  const check = () => {
-    if (produced > limits.maxUncompressedBytes || budget.total + produced > limits.maxUncompressedBytes) {
-      return new ImportError(
-        "ARCHIVE_REFUSED",
-        `The workbook inflates to more than the ${limits.maxUncompressedBytes} byte limit.`
-      );
-    }
-    if (produced > 64 * 1024 && produced / Math.max(consumed, 1) > limits.maxCompressionRatio) {
-      return new ImportError(
-        "ARCHIVE_REFUSED",
-        `An entry in the workbook inflates more than ${limits.maxCompressionRatio} times \u2014 refusing it.`
-      );
-    }
-    return null;
-  };
-  inflater.on("data", (chunk) => {
-    produced += chunk.length;
-    crc = crc32(crc, chunk);
-    if (!breach) breach = check();
-  });
-  inflater.on("end", () => {
-    ended = true;
-  });
-  inflater.on("error", (error) => {
-    failure = error;
-  });
-  try {
-    for (; ; ) {
-      const remaining = declared === null ? Number.POSITIVE_INFINITY : declared - consumed;
-      if (remaining <= 0) break;
-      if (ended || failure || breach) break;
-      if (!await scanner.need(1)) refuse(`The workbook ends part-way through "${name}".`);
-      const slice = Buffer.from(scanner.take(Math.min(SLICE, remaining, scanner.available)));
-      consumed += slice.length;
-      await writeChunk(inflater, slice);
-      if (keep) {
-        retain(slice);
-        kept.push(slice);
-      }
-      await settle();
-      if (ended && declared === null) {
-        const overshoot = consumed - inflater.bytesWritten;
-        if (overshoot > 0) {
-          scanner.pushBack(slice.subarray(slice.length - overshoot));
-          consumed -= overshoot;
-          if (keep) {
-            kept[kept.length - 1] = slice.subarray(0, slice.length - overshoot);
-            budget.retained -= overshoot;
-          }
-        }
-      }
-    }
-    while (declared !== null && consumed < declared && !breach) {
-      if (!await scanner.need(1)) refuse(`The workbook ends part-way through "${name}".`);
-      const slice = Buffer.from(scanner.take(Math.min(declared - consumed, SLICE, scanner.available)));
-      consumed += slice.length;
-      if (keep) {
-        retain(slice);
-        kept.push(slice);
-      }
-    }
-  } catch (error) {
-    if (error instanceof ImportError) throw error;
-    throw new ImportError("MALFORMED_FILE", "The workbook could not be read.", { cause: error });
-  } finally {
-    inflater.destroy();
-  }
-  if (breach) throw breach;
-  if (failure) {
-    throw new ImportError("MALFORMED_FILE", "The workbook could not be read.", { cause: failure });
-  }
-  budget.total += produced;
-  return { data: keep ? Buffer.concat(kept) : Buffer.alloc(0), inflated: produced, crc };
-}
-async function readStored(scanner, budget, limits, name, size, keep) {
-  const kept = [];
-  let crc = 0;
-  let left = size;
-  while (left > 0) {
-    if (!await scanner.need(1)) refuse(`The workbook ends part-way through "${name}".`);
-    const slice = Buffer.from(scanner.take(Math.min(left, SLICE, scanner.available)));
-    crc = crc32(crc, slice);
-    if (keep) {
-      budget.retained += slice.length;
-      if (budget.retained > limits.maxBytes) {
-        refuse(`The workbook is larger than the ${limits.maxBytes} byte limit.`);
-      }
-      kept.push(slice);
-    }
-    left -= slice.length;
-    budget.total += slice.length;
-    if (budget.total > limits.maxUncompressedBytes) {
-      refuse(`The workbook inflates to more than the ${limits.maxUncompressedBytes} byte limit.`);
-    }
-  }
-  return { data: keep ? Buffer.concat(kept) : Buffer.alloc(0), inflated: size, crc };
-}
-async function skipDescriptor(scanner) {
-  if (!await scanner.need(4)) return;
-  const signed = scanner.peek(4).readUInt32LE(0) === DATA_DESCRIPTOR;
-  const base = signed ? 4 : 0;
-  for (const width of [base + 12, base + 20]) {
-    if (!await scanner.need(width + 4)) break;
-    const next = scanner.peek(width + 4).readUInt32LE(width);
-    if (next === LOCAL_HEADER || next === CENTRAL_HEADER) {
-      scanner.take(width);
-      return;
-    }
-  }
-  if (await scanner.need(base + 12)) scanner.take(base + 12);
-}
-function repack(entries) {
-  const parts = [];
-  const directory = [];
-  let offset = 0;
-  for (const entry of entries) {
-    const name = Buffer.from(entry.name, "utf8");
-    const local = Buffer.alloc(HEADER_SIZE);
-    local.writeUInt32LE(LOCAL_HEADER, 0);
-    local.writeUInt16LE(20, 4);
-    local.writeUInt16LE(0, 6);
-    local.writeUInt16LE(entry.method, 8);
-    local.writeUInt32LE(entry.crc, 14);
-    local.writeUInt32LE(entry.data.length, 18);
-    local.writeUInt32LE(entry.inflated, 22);
-    local.writeUInt16LE(name.length, 26);
-    parts.push(local, name, entry.data);
-    const central = Buffer.alloc(46);
-    central.writeUInt32LE(CENTRAL_HEADER, 0);
-    central.writeUInt16LE(20, 4);
-    central.writeUInt16LE(20, 6);
-    central.writeUInt16LE(entry.method, 10);
-    central.writeUInt32LE(entry.crc, 16);
-    central.writeUInt32LE(entry.data.length, 20);
-    central.writeUInt32LE(entry.inflated, 24);
-    central.writeUInt16LE(name.length, 28);
-    central.writeUInt32LE(offset, 42);
-    directory.push(central, name);
-    offset += local.length + name.length + entry.data.length;
-  }
-  const directoryBytes = Buffer.concat(directory);
-  const end = Buffer.alloc(22);
-  end.writeUInt32LE(END_OF_CENTRAL, 0);
-  end.writeUInt16LE(entries.length, 8);
-  end.writeUInt16LE(entries.length, 10);
-  end.writeUInt32LE(directoryBytes.length, 12);
-  end.writeUInt32LE(offset, 16);
-  return Buffer.concat([...parts, directoryBytes, end]);
-}
-async function guardZip(source, limits) {
-  const scanner = new ZipScanner(source[Symbol.asyncIterator]());
-  const budget = { total: 0, retained: 0, entries: 0 };
-  const kept = /* @__PURE__ */ new Map();
-  let sheet = null;
-  for (; ; ) {
-    if (!await scanner.need(4)) break;
-    if (scanner.peek(4).readUInt32LE(0) !== LOCAL_HEADER) break;
-    if (!await scanner.need(HEADER_SIZE)) {
-      refuse("The workbook ends part-way through an entry header.");
-    }
-    const header = Buffer.from(scanner.peek(HEADER_SIZE));
-    const flags = header.readUInt16LE(6);
-    const method = header.readUInt16LE(8);
-    const declaredCompressed = header.readUInt32LE(18);
-    const nameLength = header.readUInt16LE(26);
-    const extraLength = header.readUInt16LE(28);
-    if (++budget.entries > limits.maxZipEntries) {
-      refuse(`The workbook has more than ${limits.maxZipEntries} entries.`);
-    }
-    if (!await scanner.need(HEADER_SIZE + nameLength + extraLength)) {
-      refuse("The workbook ends part-way through an entry header.");
-    }
-    const name = scanner.peek(HEADER_SIZE + nameLength).subarray(HEADER_SIZE).toString("utf8");
-    scanner.take(HEADER_SIZE + nameLength + extraLength);
-    const number = sheetNumber(name);
-    const keep = number === null ? WANTED.includes(name) && !kept.has(name) : sheet === null || number < sheet.number;
-    if (keep && number !== null && sheet) {
-      budget.retained -= kept.get(sheet.name)?.data.length ?? 0;
-      kept.delete(sheet.name);
-      sheet = null;
-    }
-    const streamed = (flags & HAS_DATA_DESCRIPTOR) !== 0 || declaredCompressed === ZIP64_SENTINEL;
-    let read;
-    if (method === STORED) {
-      if (streamed) {
-        refuse(`Entry "${name}" is stored without a declared size.`);
-      }
-      read = await readStored(scanner, budget, limits, name, declaredCompressed, keep);
-    } else if (method === DEFLATED) {
-      read = await readDeflated(
-        scanner,
-        budget,
-        limits,
-        name,
-        streamed ? null : declaredCompressed,
-        keep
-      );
-      if (streamed) await skipDescriptor(scanner);
-    } else {
-      return refuse(`Entry "${name}" uses compression method ${method}, which is not supported.`);
-    }
-    if (keep) {
-      if (read.data.length > ZIP32_MAX || read.inflated > ZIP32_MAX) {
-        refuse(`Entry "${name}" is too large to repack without zip64.`);
-      }
-      kept.set(name, { name, method, data: read.data, inflated: read.inflated, crc: read.crc });
-      if (number !== null) sheet = { name, number };
-    }
-  }
-  if (!sheet) {
-    if (!kept.has("xl/workbook.xml")) {
-      throw new ImportError(
-        "UNSUPPORTED_FORMAT",
-        "This is a zip archive that is not an Excel workbook. Upload an .xlsx or .csv file."
-      );
-    }
-    throw new ImportError("MALFORMED_FILE", "This workbook has no worksheet.");
-  }
-  const ordered = [...WANTED, sheet.name].map((wanted) => kept.get(wanted)).filter((entry) => entry !== void 0);
-  return repack(ordered);
+function suggestionFor(headers, config, lang) {
+  const arrayBound = core.arrayBoundFor(headers, config, null, lang);
+  const { columns } = core.deriveImportColumns(config, { lang, maxArrayRows: arrayBound });
+  return { suggestion: core.suggestMapping(headers, columns, config?.entity ?? ""), arrayBound };
 }
-
-// src/xlsx-source.ts
-function cellValue(raw) {
-  if (raw === null || raw === void 0) return "";
-  if (raw instanceof Date) return raw;
-  if (typeof raw !== "object") return raw;
-  const cell = raw;
-  if (Array.isArray(cell["richText"])) {
-    return cell["richText"].map((part) => String(part?.text ?? "")).join("");
-  }
-  if ("formula" in cell || "sharedFormula" in cell) return cellValue(cell["result"]);
-  if ("error" in cell) return String(cell["error"]);
-  if ("text" in cell) return String(cell["text"]);
-  return "";
-}
-function rowCells(values) {
-  if (!Array.isArray(values)) return [];
-  const out = [];
-  for (let i = 1; i < values.length; i++) out.push(cellValue(values[i]));
-  return out;
-}
-async function* xlsxRows(source, limits) {
-  const archive = await guardZip(source, limits);
-  const guarded = stream.Readable.from([archive]);
-  const reader = new ExcelJS__default.default.stream.xlsx.WorkbookReader(guarded, {
-    // Nothing decorative is parsed. Each of these is XML this import has no use for, and
-    // every part not parsed is a part that cannot be hostile.
-    entries: "ignore",
-    hyperlinks: "ignore",
-    // Cached because a string cell is a reference into this table and an unresolved reference
-    // is not a value. See the note at the top about what that costs.
-    sharedStrings: "cache",
-    // Cached because it is what tells a numeric cell it is a date.
-    styles: "cache",
-    worksheets: "emit"
-  });
-  let expected = 1;
-  let yielded = false;
-  try {
-    for await (const worksheet of reader) {
-      for await (const row of worksheet) {
-        const number = typeof row.number === "number" ? row.number : expected;
-        if (number - 1 > limits.maxRows) {
-          throw new ImportError("SHEET_TOO_LARGE", `The sheet has more than ${limits.maxRows} rows.`);
-        }
-        while (expected < number) {
-          yield [];
-          expected++;
-        }
-        yield rowCells(row.values);
-        yielded = true;
-        expected = number + 1;
-      }
-      break;
-    }
-    if (!yielded) {
-      throw new ImportError("MALFORMED_FILE", "This workbook has no readable rows.");
-    }
-  } catch (error) {
-    if (error instanceof ImportError) throw error;
-    throw new ImportError("MALFORMED_FILE", "This is not a readable workbook.", { cause: error });
-  } finally {
-    guarded.destroy();
-  }
-}
-
-// src/read-sheet.ts
-var MAGIC_BYTES = 8;
-var ZIP = [80, 75];
-var OLE2 = [208, 207, 17, 224];
-var UTF16_LE = [255, 254];
-var UTF16_BE = [254, 255];
-var startsWith = (bytes, signature) => signature.every((byte, i) => bytes[i] === byte);
-function detectFormat(head) {
-  if (startsWith(head, ZIP)) return "xlsx";
-  if (startsWith(head, OLE2)) {
-    throw new ImportError(
-      "UNSUPPORTED_FORMAT",
-      "This is a pre-2007 Excel file (.xls). Save it as .xlsx or .csv and try again."
-    );
-  }
-  if (startsWith(head, UTF16_LE) || startsWith(head, UTF16_BE)) {
-    throw new ImportError(
-      "UNSUPPORTED_FORMAT",
-      "This file is UTF-16 encoded. Save it as UTF-8 CSV and try again."
-    );
-  }
-  return "csv";
-}
-async function* csvRows(stream, limits, found, forced) {
-  const decoder = new TextDecoder("utf-8");
-  const maxHeader = limits.maxCellLength * limits.maxColumns + limits.maxColumns;
-  let held = "";
-  let reader = null;
-  const open = (headerLine) => {
-    found.delimiter = forced ?? core.detectDelimiter(headerLine);
-    return core.createCsvReader({ delimiter: found.delimiter });
-  };
-  for await (const chunk of stream) {
-    const text = decoder.decode(chunk, { stream: true });
-    if (!reader) {
-      held += text;
-      const line = core.completeFirstLine(held);
-      if (line === null) {
-        if (held.length > maxHeader) {
-          throw new ImportError("SHEET_TOO_LARGE", "The header row is longer than any row may be.");
-        }
-        continue;
-      }
-      reader = open(line);
-      for (const row of reader.push(held)) yield row;
-      held = "";
-      continue;
-    }
-    for (const row of reader.push(text)) yield row;
-  }
-  const rest = held + decoder.decode();
-  reader ??= open(core.completeFirstLine(rest) ?? rest);
-  for (const row of reader.push(rest)) yield row;
-  for (const row of reader.end()) yield row;
-}
-async function* guardRows(rows, width, limits) {
-  let seen = 0;
-  for await (const row of rows) {
-    if (++seen > limits.maxRows) {
-      throw new ImportError(
-        "SHEET_TOO_LARGE",
-        `The sheet has more than ${limits.maxRows} rows.`
-      );
-    }
-    if (row.length > limits.maxColumns) {
-      throw new ImportError(
-        "SHEET_TOO_LARGE",
-        `Row ${seen + 1} has more than ${limits.maxColumns} columns.`
-      );
-    }
-    for (const cell of row) {
-      if (typeof cell === "string" && cell.length > limits.maxCellLength) {
-        throw new ImportError(
-          "SHEET_TOO_LARGE",
-          `A cell in row ${seen + 1} is longer than ${limits.maxCellLength} characters.`
-        );
-      }
-    }
-    yield core.padRow(row, width);
-  }
-}
-async function readSheet(options) {
-  const limits = resolveLimits(options.limits);
-  try {
-    const counted = limitBytes(toByteStream(options.stream), limits.maxBytes);
-    const { head, stream } = await peek(counted, MAGIC_BYTES);
-    const format = detectFormat(head);
-    const found = {};
-    const forced = /\.tsv$/i.test(options.filename ?? "") ? "	" : void 0;
-    const rows = format === "xlsx" ? xlsxRows(stream, limits) : csvRows(stream, limits, found, forced);
-    const iterator = rows[Symbol.asyncIterator]();
-    const first = await iterator.next();
-    const headers = first.done ? [] : first.value.map(core.cellText);
-    if (headers.length > limits.maxColumns) {
-      throw new ImportError(
-        "SHEET_TOO_LARGE",
-        `The sheet has more than ${limits.maxColumns} columns.`
-      );
-    }
-    const remaining = drain(iterator);
-    return {
-      format,
-      headers,
-      rows: closing(guardRows(remaining, headers.length, limits), options.stream),
-      ...found.delimiter ? { delimiter: found.delimiter } : {}
-    };
-  } catch (error) {
-    destroySource(options.stream);
-    throw error;
-  }
-}
-async function* drain(iterator) {
-  for (let next = await iterator.next(); !next.done; next = await iterator.next()) {
-    yield next.value;
-  }
-}
-async function* closing(rows, source) {
-  let drained = false;
-  try {
-    yield* rows;
-    drained = true;
-  } finally {
-    if (!drained) destroySource(source);
-  }
-}
-
-// src/run-import.ts
-function checkPlan(plan, config, lang) {
-  return core.validateMappingPlan(plan, config, {
-    lang,
-    // The same derivation `applyMapping` uses, or the two would disagree about which refs
-    // exist and the pre-flight would pass a plan the run then rejects.
-    includeReadonly: true,
-    includeSystemDefault: true
-  });
-}
-async function runImport(options) {
-  const limits = resolveLimits(options.limits);
-  const { plan, config, onBatch } = options;
-  const planProblems = checkPlan(plan, config, options.lang);
-  if (planProblems.some((problem) => problem.level === "error")) {
-    destroySource(options.stream);
-    return {
-      imported: 0,
-      skipped: 0,
-      failed: 0,
-      errors: [],
-      errorCount: 0,
-      truncated: false,
-      planProblems,
-      rowsRead: 0
-    };
-  }
-  const sheet = await readSheet({
-    stream: options.stream,
-    filename: options.filename,
-    limits
-  });
-  const decimal = options.decimal ?? core.decimalMarkFor(sheet.delimiter);
-  const errors = [];
-  let errorCount = 0;
-  let imported = 0;
-  let skipped = 0;
-  let failed = 0;
-  let rowsRead = 0;
-  let batchIndex = 0;
-  let batch = [];
-  let firstRow = 2;
-  const flush = async () => {
-    if (!batch.length) return;
-    const rows = batch;
-    batch = [];
-    const result = core.applyMapping(rows, plan, config, {
-      lang: options.lang,
-      decimal,
-      dateOrder: options.dateOrder,
-      rules: options.rules,
-      lookups: options.lookups,
-      firstRowNumber: firstRow
-    });
-    skipped += result.skipped;
-    errorCount += result.errors.length;
-    failed += new Set(result.errors.map((error) => error.row)).size;
-    for (const error of result.errors) {
-      if (errors.length >= limits.maxReportedErrors) break;
-      errors.push(error);
-    }
-    if (result.records.length && onBatch) {
-      const info = { index: batchIndex, firstRow, imported };
-      try {
-        await onBatch(result.records, info);
-      } catch (cause) {
-        throw new ImportError(
-          "IMPORT_FAILED",
-          "The import stopped partway through. Rows before the failure may already have been written \u2014 this import is not transactional.",
-          { cause }
-        );
-      }
-    }
-    imported += result.records.length;
-    firstRow += rows.length;
-    batchIndex++;
-  };
-  try {
-    for await (const row of sheet.rows) {
-      rowsRead++;
-      batch.push(row);
-      if (batch.length >= limits.batchSize) await flush();
-    }
-    await flush();
-  } catch (error) {
-    destroySource(options.stream);
-    throw error;
-  }
-  return {
-    imported,
-    skipped,
-    failed,
-    errors,
-    errorCount,
-    truncated: errorCount > errors.length,
-    planProblems,
-    rowsRead,
-    format: sheet.format
-  };
-}
-async function previewSheet(options) {
-  const limits = resolveLimits(options.limits);
-  const sheet = await readSheet({
-    stream: options.stream,
-    filename: options.filename,
-    limits
-  });
-  const sample = [];
-  let rowCount = 0;
-  try {
-    for await (const row of sheet.rows) {
-      rowCount++;
-      if (sample.length < limits.sampleRows) sample.push(row.map(core.cellText));
-    }
-  } catch (error) {
-    destroySource(options.stream);
-    throw error;
-  }
-  const arrayBound = core.arrayBoundFor(sheet.headers, options.config, null, options.lang);
-  const { columns } = core.deriveImportColumns(options.config, { lang: options.lang, maxArrayRows: arrayBound });
-  return {
-    headers: sheet.headers,
-    sample,
-    rowCount,
-    suggestion: core.suggestMapping(sheet.headers, columns, options.config?.entity ?? ""),
-    format: sheet.format,
-    ...sheet.delimiter ? { delimiter: sheet.delimiter } : {},
-    arrayBound
-  };
-}
-var TEMPLATE_EXTENSION = { csv: "csv", xlsx: "xlsx" };
-var TEMPLATE_MEDIA_TYPE = {
-  csv: "text/csv; charset=utf-8",
-  xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
-};
-async function writeTemplate(options) {
-  const limits = resolveLimits(options.limits);
-  const columns = options.spec.columns;
-  if (columns.length > limits.maxColumns) {
-    throw new ImportError(
-      "SHEET_TOO_LARGE",
-      `A template of ${columns.length} columns is past the ${limits.maxColumns} column limit.`
-    );
-  }
-  if (options.format === "csv") {
-    await writeCsv(options.spec, options.out);
-    return;
-  }
-  await writeXlsx(options.spec, options.out);
-}
-function writeCsv(spec, out) {
-  const csv = core.toCsv(spec.columns.map((column) => column.header));
-  return new Promise((resolve, reject) => {
-    out.end(csv, () => resolve());
-    out.on("error", reject);
-  });
-}
-async function writeXlsx(spec, out) {
-  const workbook = new ExcelJS__default.default.stream.xlsx.WorkbookWriter({ stream: out, useStyles: true });
-  const sheet = workbook.addWorksheet(sheetName(spec.sheetName));
-  const { columns, notes } = spec;
-  const row = sheet.addRow(columns.map((column) => core.escapeFormula(column.header)));
-  row.eachCell((cell, index) => {
-    cell.font = { bold: true };
-    const note = notes[index - 1];
-    if (note) cell.note = note;
-  });
-  row.commit();
-  sheet.commit();
-  await workbook.commit();
-}
-function sheetName(name) {
-  const cleaned = String(name).replace(/[[\]:*?/\\]/g, " ").trim();
-  return (cleaned || "Import").slice(0, 31);
+function templateSheetOf(spec) {
+  return { sheetName: spec.sheetName, headers: spec.columns.map((column) => column.header), notes: spec.notes };
 }
 
 // src/express.ts
@@ -962,161 +41,48 @@ Pass them as \`lookups\` to createImportRouter. Without them those columns would
 function ownValue(map, key) {
   return Object.hasOwn(map, key) ? map[key] : void 0;
 }
-function readFormat(value) {
-  if (value === void 0 || value === "csv") return "csv";
-  if (value === "xlsx") return "xlsx";
-  throw new ImportError("UNSUPPORTED_FORMAT", "Supported template formats are csv and xlsx.");
-}
-function readFields(value) {
-  const raw = value === void 0 ? [] : Array.isArray(value) ? value : [value];
-  const fields = raw.flatMap((item) => String(item).split(",")).map((item) => item.trim()).filter(Boolean);
-  return fields.length ? fields : void 0;
-}
-function templateFilename(entity, format) {
-  const safe = String(entity).replace(/[^A-Za-z0-9._-]/g, "-").replace(/^[-.]+/, "").slice(0, 64);
-  return `${safe || "import"}-template.${TEMPLATE_EXTENSION[format]}`;
-}
-function applyTimeouts(request, response, limits) {
-  const abandon = (message) => () => {
-    request.destroy(new ImportError("TIMEOUT", message));
-  };
-  const socket = request.socket;
-  const previous = socket?.timeout;
-  request.setTimeout(limits.idleTimeoutMs, abandon("The upload stalled."));
-  const total = setTimeout(abandon("The upload took too long."), limits.totalTimeoutMs);
-  total.unref?.();
-  response.on("close", () => {
-    clearTimeout(total);
-    if (socket && !socket.destroyed) socket.setTimeout(previous ?? 0);
-  });
-}
-function sendFailure(response, error) {
-  if (response.headersSent) {
-    response.destroy();
-    return;
-  }
-  for (const header of ["Content-Type", "Content-Disposition", "Content-Length"]) {
-    response.removeHeader(header);
-  }
-  const { status, body } = toErrorBody(error);
-  response.status(status).json(body);
-}
+var templateFilename = node.templateFilename;
+var sendFailure = node.sendFailure;
 function createImportRouter(options) {
-  const limits = resolveLimits(options.limits);
-  const router = express__default.default.Router();
   if (typeof options.configs !== "function") {
     for (const [entity, config] of Object.entries(options.configs)) {
       checkLookups(entity, config, options.lookups);
     }
   }
   const languageOf = (request) => typeof options.lang === "function" ? options.lang(request) : options.lang ?? "en";
-  const configFor = async (request) => {
-    const entity = String(request.params["entity"] ?? "");
+  const bindingFor = async (entity, request) => {
     const config = typeof options.configs === "function" ? await options.configs(entity, request) : ownValue(options.configs, entity);
-    if (!config) throw new ImportError("UNKNOWN_ENTITY", "No import is configured for that entity.");
+    if (!config) throw new node.ImportError("UNKNOWN_ENTITY", "No import is configured for that entity.");
     if (typeof options.configs === "function") checkLookups(entity, config, options.lookups);
-    return { entity, config };
+    const lang = languageOf(request);
+    const adapter = core.entityFormConfigAdapter(config, {
+      rules: options.rules && ownValue(options.rules, entity),
+      lookups: options.lookups
+    });
+    return {
+      adapter,
+      ctx: { lang },
+      kind: "dynamic-entity",
+      config,
+      // Named from the config. The route segment only when the config names nothing.
+      templateName: config.entity || entity,
+      template: ({ lang: language, fields }) => templateSheetOf(core.buildTemplateSpec(config, { lang: language, fields })),
+      // What the browser suggests for the same headers, and the one number it was sized with.
+      previewExtras: (preview) => suggestionFor(preview.headers, config, lang),
+      // A 2.x plan that names no entity is read against this config, as 2.x read it.
+      plan: (plan) => core.planForConfig(plan, config)
+    };
   };
-  const respond = (result, written) => ({
-    written,
-    imported: result.imported,
-    skipped: result.skipped,
-    failed: result.failed,
-    rowsRead: result.rowsRead,
-    errors: result.errors,
-    errorCount: result.errorCount,
-    truncated: result.truncated,
-    planProblems: result.planProblems,
-    engineVersion: core.CORE_VERSION
+  return node.createImportRouter(express__default.default.Router(), {
+    bindings: bindingFor,
+    param: "entity",
+    // What a Dynamic Entity client compares with its own `CORE_VERSION`, as it always has.
+    engineVersion: core.CORE_VERSION,
+    dateOrder: options.dateOrder,
+    limits: options.limits,
+    lang: options.lang,
+    onImport: (records, { index, firstRow, imported, name, binding, request }) => options.onImport(records, { index, firstRow, imported, entity: name, config: binding.config, request })
   });
-  const route = (handler) => (request, response) => {
-    applyTimeouts(request, response, limits);
-    handler(request, response).catch((error) => sendFailure(response, error));
-  };
-  router.get(
-    "/:entity/template",
-    route(async (request, response) => {
-      const { entity, config } = await configFor(request);
-      const format = readFormat(request.query["format"]);
-      const spec = core.buildTemplateSpec(config, {
-        lang: languageOf(request),
-        fields: readFields(request.query["fields"])
-      });
-      response.setHeader("Content-Type", TEMPLATE_MEDIA_TYPE[format]);
-      response.setHeader(
-        "Content-Disposition",
-        `attachment; filename="${templateFilename(config.entity || entity, format)}"`
-      );
-      await writeTemplate({ spec, format, out: response, limits });
-    })
-  );
-  router.post(
-    "/:entity/preview",
-    route(async (request, response) => {
-      const { config } = await configFor(request);
-      const upload = await receiveUpload(request, limits);
-      const preview = await previewSheet({
-        stream: upload.stream,
-        filename: upload.filename,
-        config,
-        lang: languageOf(request),
-        limits
-      });
-      const body = {
-        headers: preview.headers,
-        sample: preview.sample,
-        suggestion: preview.suggestion,
-        rowCount: preview.rowCount,
-        arrayBound: preview.arrayBound,
-        ...preview.delimiter ? { delimiter: preview.delimiter } : {},
-        // The order every import through this router is read in, so the client reads its
-        // sample the same way and can refuse to commit when it was told another.
-        ...options.dateOrder ? { dateOrder: options.dateOrder } : {},
-        engineVersion: core.CORE_VERSION
-      };
-      response.json(body);
-    })
-  );
-  router.post(
-    "/:entity/validate",
-    route(async (request, response) => {
-      response.json(await execute(request, options, limits, languageOf, void 0));
-    })
-  );
-  router.post(
-    "/:entity/import",
-    route(async (request, response) => {
-      const onBatch = async (records, info, entity, config) => {
-        await options.onImport(records, { ...info, entity, config, request });
-      };
-      response.json(await execute(request, options, limits, languageOf, onBatch));
-    })
-  );
-  async function execute(request, routerOptions, resolved, language, write) {
-    const { entity, config } = await configFor(request);
-    const upload = await receiveUpload(request, resolved);
-    let plan;
-    try {
-      plan = readPlanField(upload.fields);
-    } catch (error) {
-      destroySource(upload.stream);
-      throw error;
-    }
-    const result = await runImport({
-      stream: upload.stream,
-      filename: upload.filename,
-      plan,
-      config,
-      rules: routerOptions.rules && ownValue(routerOptions.rules, entity),
-      lookups: routerOptions.lookups,
-      dateOrder: routerOptions.dateOrder,
-      lang: language(request),
-      limits: resolved,
-      onBatch: write && ((records, info) => write(records, info, entity, config))
-    });
-    return respond(result, write !== void 0);
-  }
-  return router;
 }
 
 exports.createImportRouter = createImportRouter;