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

package/index.js

@@ -1,840 +1,77 @@
 'use strict';
 
+var node = require('sheet-to-schema/node');
 var core = require('@dynamic-entity/core');
-var zlib = require('zlib');
-var ExcelJS = require('exceljs');
-var stream = require('stream');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-var zlib__default = /*#__PURE__*/_interopDefault(zlib);
-var ExcelJS__default = /*#__PURE__*/_interopDefault(ExcelJS);
 
 // 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;
-}
-
-// 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 {
-  }
-}
-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 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();
-  }
-}
-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);
-  }
-}
-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({
+var DEFAULT_LIMITS = node.DEFAULT_LIMITS;
+var resolveLimits = node.resolveLimits;
+var toErrorBody = node.toErrorBody;
+var toByteStream = node.toByteStream;
+var limitBytes = node.limitBytes;
+var peek = node.peek;
+var destroySource = node.destroySource;
+var guardZip = node.guardZip;
+var cellValue = node.cellValue;
+var xlsxRows = node.xlsxRows;
+var detectFormat = node.detectFormat;
+var guardRows = node.guardRows;
+var readSheet = node.readSheet;
+function runImport(options) {
+  const { config } = options;
+  return node.runImport({
     stream: options.stream,
     filename: options.filename,
-    limits
+    // A 2.x plan that names no entity is read against this config, as 2.x read it.
+    plan: core.planForConfig(options.plan, config),
+    adapter: core.entityFormConfigAdapter(config, { rules: options.rules, lookups: options.lookups }),
+    ctx: { lang: options.lang },
+    decimal: options.decimal,
+    dateOrder: options.dateOrder,
+    onBatch: options.onBatch,
+    limits: options.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
-  };
+}
+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 };
 }
 async function previewSheet(options) {
-  const limits = resolveLimits(options.limits);
-  const sheet = await readSheet({
+  const preview = await node.previewSheet({
     stream: options.stream,
     filename: options.filename,
-    limits
+    adapter: core.entityFormConfigAdapter(options.config, { includeReadonly: false, includeSystemDefault: false }),
+    lang: options.lang,
+    limits: options.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
+    headers: preview.headers,
+    sample: preview.sample,
+    rowCount: preview.rowCount,
+    format: preview.format,
+    ...preview.delimiter ? { delimiter: preview.delimiter } : {},
+    ...suggestionFor(preview.headers, options.config, options.lang)
   };
 }
-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);
+var TEMPLATE_EXTENSION = node.TEMPLATE_EXTENSION;
+var TEMPLATE_MEDIA_TYPE = node.TEMPLATE_MEDIA_TYPE;
+function templateSheetOf(spec) {
+  return { sheetName: spec.sheetName, headers: spec.columns.map((column) => column.header), notes: spec.notes };
 }
-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 writeTemplate(options) {
+  return node.writeTemplate({ sheet: templateSheetOf(options.spec), format: options.format, out: options.out, limits: options.limits });
 }
 
+Object.defineProperty(exports, "ImportError", {
+  enumerable: true,
+  get: function () { return node.ImportError; }
+});
 Object.defineProperty(exports, "sampleText", {
   enumerable: true,
   get: function () { return core.cellText; }
 });
 exports.DEFAULT_LIMITS = DEFAULT_LIMITS;
-exports.ImportError = ImportError;
 exports.TEMPLATE_EXTENSION = TEMPLATE_EXTENSION;
 exports.TEMPLATE_MEDIA_TYPE = TEMPLATE_MEDIA_TYPE;
 exports.cellValue = cellValue;