@graphty/graph-io 0.3.25 → 0.3.27

package/dist/neo4j.js

@@ -1,22 +1,37 @@
-import { R as ROLE_TAKEN_CODE$1, I as ID_MERGED_CODE$1, d as DUPLICATE_NODE_CODE$1, e as MISSING_ENDPOINT_CODE$1, f as MISSING_ID_CODE$1, v as resolveImportOptions, w as ImportReportBuilder, F as reportSinkOptions, z as reportUnusedOptions, y as throwIfAborted, K as IdCoercer, J as DirectionResolver, ao as ImportError, aK as declareAttribute, aW as declareOn, Q as uniqueColumnName, at as RENAMED_CODE, aL as parseDeclaredTemporal, aM as parseDeclaredValue, aN as losesPrecision, aA as declareCompanion, P as PRECISION_CODE, aP as splitListText, aF as isImportInput, aX as takenIn, aC as inputLength, a8 as ID_TEXT_COLLISION_CODE, b as ID_TEXT_TYPE_CODE, V as resolveExportOptions, X as pairFolding, aS as mapDeclaredType, aE as isCanonicalIntegerText, aU as formatTemporal, S as SINK_OPTION_CODE, O as OPTION_IGNORED_CODE, C as COLUMN_RENAMED_CODE, k as UNKNOWN_ATTR_TYPE_CODE, q as UNKNOWN_ENCODING_CODE, E as ENCODING_FALLBACK_CODE, r as INVALID_ENCODING_CODE, s as INVALID_UTF8_CODE, a7 as WEIGHT_KEY_CLASH_CODE, ac as ROLE_DROPPED_CODE, aa as MUTUAL_EXPANDED_CODE } from "./chunks/report-B1z4WT9e.js";
-import { c as checkRecordSyntax, R as RecordReader, B as BAD_QUOTE_CODE, U as UNCLOSED_QUOTE_CODE } from "./chunks/records-dbRkxwaq.js";
+import { i as DANGLING_REFERENCE_CODE$1, R as ROLE_TAKEN_CODE$1, I as ID_MERGED_CODE$1, n as DUPLICATE_NODE_CODE$1, s as MISSING_ENDPOINT_CODE$1, t as MISSING_ID_CODE$1, al as resolveImportOptions, a8 as ImportReportBuilder, ao as reportSinkOptions, an as reportUnusedOptions, am as throwIfAborted, ar as IdCoercer, aq as DirectionResolver, b as plural, $ as agree, aT as ImportError, bI as declareAttribute, bY as declareOn, a0 as uniqueColumnName, ay as RENAMED_CODE, aL as parseWeightText, bK as parseDeclaredTemporal, bL as parseDeclaredValue, bM as losesPrecision, bs as declareCompanion, P as PRECISION_CODE, bO as splitListText, bz as isImportInput, bX as takenIn, bx as inputLength, bZ as parseTemporal, b_ as withArticle, c as capabilities, b9 as ID_TEXT_COLLISION_CODE, J as ID_TEXT_TYPE_CODE, r as resolveExportOptions, a as checkCapabilities, p as pairFolding, L as LOSS, bS as mapDeclaredType, e as explicitWeights, by as isCanonicalIntegerText, bU as formatTemporal, ab as formatF64, aa as formatF32, aG as formatInteger, S as SINK_OPTION_CODE, O as OPTION_IGNORED_CODE, C as COLUMN_RENAMED_CODE, U as UNKNOWN_ATTR_TYPE_CODE, w as UNKNOWN_ENCODING_CODE, x as ENCODING_FALLBACK_CODE, y as INVALID_ENCODING_CODE, z as INVALID_UTF8_CODE, A as COLUMN_TYPE_CODE, F as ELEMENT_ISSUE, G as INPUT_ISSUE, bq as WEIGHT_KEY_CLASH_CODE, K as ROLE_DROPPED_CODE, bd as MUTUAL_EXPANDED_CODE } from "./chunks/export-CHd4tQE2.js";
+import { c as checkRecordSyntax, R as RecordReader, B as BAD_QUOTE_CODE, U as UNCLOSED_QUOTE_CODE } from "./chunks/records-CdlvL4RO.js";
 import { GraphFormatError, INVALID_INDEX } from "@graphty/graph-format";
-import { m as quoteCsvCell } from "./chunks/escape-B-tkk_Cl.js";
-import { c as capabilities, a as checkCapabilities, L as LOSS } from "./chunks/export-Bh60Dv-n.js";
-import { p as parseWeightText, e as explicitWeights, a as formatF64, f as formatF32, d as formatInteger } from "./chunks/weights-Dzba96G3.js";
-import { j as joinText, e as encodeChunks } from "./chunks/writer-C7flM-Ih.js";
+import { o as quoteCsvCell } from "./chunks/escape-D1HPTUrP.js";
+import { j as joinText, e as encodeChunks } from "./chunks/writer-DxjgHwSe.js";
 const STRUCTURAL = /* @__PURE__ */ new Set(["ID", "LABEL", "START_ID", "END_ID", "TYPE", "IGNORE"]);
 const SPACE_KINDS = /* @__PURE__ */ new Set(["ID", "START_ID", "END_ID"]);
 const HEADER_MARKER = /^[^:{}()]*:\s*(ID|START_ID|END_ID)\s*(\(|\{|$)/i;
 const CELL = /^([^:(){}]*)(?::([^:(){}]*))?(?:\(([^)]*)\))?(?:\{([^}]*)\})?$/;
-function isHeaderRecord(cells, count) {
+function isHeaderRecord(cells, count, quoted) {
+  let quotedMarker = false;
   for (let i = 0; i < count; i++) {
     const cell = cells[i];
     if (cell.indexOf(":") >= 0 && HEADER_MARKER.test(cell.trim())) {
-      return true;
+      if (quoted?.[i] !== true) {
+        return true;
+      }
+      quotedMarker = true;
+    }
+  }
+  return quotedMarker && quoted !== void 0 && isQuotedHeader(cells, count, quoted);
+}
+function isQuotedHeader(cells, count, quoted) {
+  for (let i = 0; i < count; i++) {
+    if (!quoted[i]) {
+      return false;
+    }
+    try {
+      parseHeaderField(cells[i]);
+    } catch {
+      return false;
     }
   }
-  return false;
+  return true;
 }
 function parseHeaderField(text) {
   const trimmed = text.trim();
@@ -103,6 +118,9 @@ const ENDPOINT_SPACE_CODE = "E_NEO4J_ENDPOINT_SPACE";
 const ID_MERGED_CODE = ID_MERGED_CODE$1;
 const HEADER_OPTION_CODE = "W_NEO4J_HEADER_OPTION_IGNORED";
 const ROLE_TAKEN_CODE = ROLE_TAKEN_CODE$1;
+const MISSING_TYPE_CODE = "W_NEO4J_MISSING_TYPE";
+const SECTION_KIND_CODE = "W_NEO4J_SECTION_KIND";
+const DANGLING_REFERENCE_CODE = DANGLING_REFERENCE_CODE$1;
 const IGNORED_COLUMNS_LOSS = "W_NEO4J_IGNORED_COLUMNS";
 const USED_OPTIONS = /* @__PURE__ */ new Set([
   "ids",
@@ -161,16 +179,27 @@ function resolveNeo4jOptions(options) {
       { option: "arrayDelimiter", found: arrayDelimiter }
     );
   }
+  if (arrayDelimiter === "," && o.delimiter === void 0) {
+    throw new GraphFormatError(
+      "E_UNSUPPORTED",
+      'option arrayDelimiter "," needs the delimiter option: the field delimiter is a comma unless another is given',
+      { option: "arrayDelimiter", found: arrayDelimiter }
+    );
+  }
   const syntax = checkRecordSyntax({
     delimiter: o.delimiter ?? null,
     quote: o.quote ?? '"',
     candidates: NEO4J_DELIMITER_CANDIDATES.filter((d) => d !== arrayDelimiter)
   });
   if (syntax.delimiter === arrayDelimiter) {
-    throw new GraphFormatError("E_UNSUPPORTED", "options delimiter and arrayDelimiter must differ", {
-      option: "arrayDelimiter",
-      found: arrayDelimiter
-    });
+    throw new GraphFormatError(
+      "E_UNSUPPORTED",
+      `options delimiter and arrayDelimiter must differ: both are ${JSON.stringify(arrayDelimiter)}; pass another arrayDelimiter (";", "," or "|")`,
+      {
+        option: "arrayDelimiter",
+        found: arrayDelimiter
+      }
+    );
   }
   return {
     nodes: inputList("nodes", o.nodes),
@@ -299,6 +328,7 @@ class Neo4jImportSession {
    */
   constructor(sink, report, common, options) {
     this.registry = new NodeRegistry();
+    this.weightProperty = null;
     this.labelsHandle = INVALID_INDEX;
     this.typeHandle = INVALID_INDEX;
     this.idSpaceHandle = INVALID_INDEX;
@@ -308,6 +338,10 @@ class Neo4jImportSession {
     this.values = [];
     this.texts = [];
     this.precisionSlots = [];
+    this.overflows = [];
+    this.expectedKind = null;
+    this.nodeRows = false;
+    this.placeholders = [];
     this.sink = sink;
     this.report = report;
     this.common = common;
@@ -316,38 +350,69 @@ class Neo4jImportSession {
     this.direction = new DirectionResolver(sink, report, common.onMixedDirection);
   }
   /**
-   * Read every input.
-   * @param inputs - the inputs in reading order
+   * Read every input. A header-only input lends its header to the headerless input after it (the
+   * neo4j-admin convention `--nodes=header.csv,part1.csv`); an empty input is an error only when
+   * it is the only one.
+   * @param inputs - the inputs in reading order, each with the kind of section its option names (null for the primary input)
    */
   async run(inputs) {
-    const progress = new ProgressTracker(this.common.onProgress, inputs);
-    for (const input of inputs) {
-      await this.readInput(input, { ...progress.optionsFor(this.common.signal), encoding: this.common.encoding });
+    const progress = new ProgressTracker(
+      this.common.onProgress,
+      inputs.map((i) => i.input)
+    );
+    let carried = null;
+    for (const { input, kind } of inputs) {
+      this.expectedKind = kind;
+      if (carried !== null && kind !== null && carried.kind !== kind) {
+        carried = null;
+      }
+      carried = await this.readInput(
+        input,
+        { ...progress.optionsFor(this.common.signal), encoding: this.common.encoding },
+        carried,
+        inputs.length > 1
+      );
       progress.finishInput();
     }
     if (this.ignoredColumns > 0) {
       this.report.loss(
         IGNORED_COLUMNS_LOSS,
-        `${this.ignoredColumns} :IGNORE column(s) were skipped as the header instructs`,
+        `${this.ignoredColumns} :IGNORE column${plural(this.ignoredColumns)} ${agree(this.ignoredColumns, "was", "were")} skipped as the header instructs`,
         null,
         this.ignoredColumns
       );
     }
+    this.reportDangling();
   }
   /**
    * Read one input: a header row, then data rows until the next header row.
    * @param input - the input
    * @param readOptions - cancellation and progress
+   * @param carried - the section of a header-only input just before this one, or null
+   * @param mayBeEmpty - whether an input without any record is allowed (other inputs exist)
+   * @returns this input's section when it held a header and no data row (lent to the next input), else null
    */
-  async readInput(input, readOptions) {
-    const reader = new RecordReader(input, this.report, this.options.syntax, readOptions);
-    let section = null;
+  async readInput(input, readOptions, carried, mayBeEmpty) {
+    const reader = new RecordReader(input, this.report, this.options.syntax, {
+      ...readOptions,
+      allowEmpty: mayBeEmpty
+    });
+    let section = carried;
+    let records = 0;
+    let rows = 0;
     let sinceCheck = 0;
     for await (const count of reader) {
-      if (section === null || isHeaderRecord(reader.cells, count)) {
+      const { cells, quoted } = reader;
+      if (records === 0 && count === 1 && !quoted[0] && cells[0].trim().length === 0) {
+        continue;
+      }
+      records++;
+      if (section === null || isHeaderRecord(cells, count, quoted)) {
         section = this.declareSection(reader, count);
+        rows = 0;
         continue;
       }
+      rows++;
       if (section.kind === "node") {
         this.nodeRow(section, reader, count);
       } else {
@@ -358,9 +423,13 @@ class Neo4jImportSession {
         throwIfAborted(readOptions.signal);
       }
     }
-    if (section === null) {
+    if (records === 0 && carried === null && !mayBeEmpty) {
       this.report.fail(HEADER_CODE, "the input has no header row", { line: 1 });
     }
+    if (section === carried) {
+      return carried;
+    }
+    return rows === 0 ? section : null;
   }
   /**
    * Interpret a header row: parse every cell, check the section shape, declare its columns.
@@ -393,8 +462,17 @@ class Neo4jImportSession {
         throw headerError("a header mixes :ID with :START_ID / :END_ID");
       }
       if (!isNode && !isRelationship) {
+        const apoc = fields.some((f) => f.name === "_id" || f.name === "_start");
         throw headerError(
-          "a header needs an :ID column (nodes) or :START_ID and :END_ID columns (relationships)"
+          apoc ? "a header needs an :ID column (nodes) or :START_ID and :END_ID columns (relationships); this is the apoc.export.csv layout (_id, _labels, _start, _end, _type), which is not the neo4j-admin import format" : "a header needs an :ID column (nodes) or :START_ID and :END_ID columns (relationships)"
+        );
+      }
+      if (this.expectedKind !== null && this.expectedKind !== (isNode ? "node" : "relationship")) {
+        this.report.warning(
+          "validation-error",
+          SECTION_KIND_CODE,
+          `a ${isNode ? "node" : "relationship"} header in a file given as ${this.expectedKind === "node" ? "nodes" : "relationships"}; read by its header`,
+          { line }
         );
       }
       checkPropertyNames(fields);
@@ -427,7 +505,11 @@ class Neo4jImportSession {
       );
     } catch (err) {
       if (err instanceof GraphFormatError && !(err instanceof ImportError)) {
-        this.report.fail(HEADER_CODE, `line ${line}: ${err.message}`, { line }, { cause: err.code });
+        const other = [";", "|", "	", ","].find(
+          (d) => d !== reader.delimiter && reader.cells.slice(0, count).some((c) => c.includes(d))
+        );
+        const hint = other === void 0 ? "" : `; if the file is delimited by ${JSON.stringify(other)}, pass the delimiter option`;
+        this.report.fail(HEADER_CODE, `${err.message}${hint}`, { line }, { cause: err.code });
       }
       throw err;
     }
@@ -513,6 +595,9 @@ class Neo4jImportSession {
     let weightCell = -1;
     if (weightFrom !== null) {
       weightCell = fields.findIndex((field) => field.kind === "PROPERTY" && field.name === weightFrom);
+      if (weightCell >= 0 && weightFrom !== "weight") {
+        this.weightProperty = weightFrom;
+      }
     }
     const properties = this.declareProperties("edge", fields, line, weightCell);
     const { space: startSpace } = fields[startCell];
@@ -675,7 +760,7 @@ class Neo4jImportSession {
       report.error(
         "validation-error",
         COLUMN_COUNT_CODE,
-        `row has ${count} cell(s) but the header has ${section.width}`,
+        `row has ${count} cell${plural(count)} but the header has ${section.width}`,
         { line }
       );
       report.counts.skippedNodes++;
@@ -697,7 +782,16 @@ class Neo4jImportSession {
     if (section.labelCells.length > 0 || section.extraLabels.length > 0) {
       labels = this.labelsOf(section, cells, quoted);
     }
-    const index = sink.addNode(id);
+    this.nodeRows = true;
+    const existed = sink.indexOf(id) !== INVALID_INDEX;
+    let index;
+    try {
+      index = sink.addNode(id);
+    } catch (err) {
+      report.recordError(err, { line, element: idText2 });
+      report.counts.skippedNodes++;
+      return;
+    }
     const status = this.registry.declare(index, section.spaceCode);
     if (status === "collision") {
       report.error(
@@ -720,19 +814,61 @@ class Neo4jImportSession {
         }
       );
     }
+    const set = (column, value) => {
+      this.guarded(line, idText2, () => {
+        sink.setNodeValue(column, index, value);
+      });
+    };
     if (section.idHandle !== INVALID_INDEX) {
-      sink.setNodeValue(section.idHandle, index, idText2);
+      set(section.idHandle, idText2);
     }
     if (section.space !== null) {
-      sink.setNodeValue(this.idSpaceHandle, index, section.space);
-      sink.setNodeValue(this.originalIdHandle, index, idText2);
+      set(this.idSpaceHandle, section.space);
+      set(this.originalIdHandle, idText2);
     }
     if (labels !== void 0) {
-      sink.setNodeValue(this.labelsHandle, index, labels);
+      set(this.labelsHandle, labels);
     }
-    this.writeProperties("node", section.properties, index);
+    this.writeProperties("node", section.properties, index, line, idText2);
     this.reportPrecision(line, idText2);
-    report.counts.nodes++;
+    if (!existed) {
+      report.counts.nodes++;
+    }
+  }
+  /**
+   * Run one sink write, recording a refusal (a GraphFormatError) on the row's line instead of
+   * letting it escape the import.
+   * @param line - the row's line
+   * @param element - the row's element name
+   * @param write - the write
+   */
+  guarded(line, element, write) {
+    try {
+      write();
+    } catch (err) {
+      if (!(err instanceof GraphFormatError) || err instanceof ImportError) {
+        throw err;
+      }
+      this.report.recordError(err, { line, element });
+    }
+  }
+  /**
+   * Report the relationship endpoints no node row declared (the shared W_DANGLING_REFERENCE,
+   * once) when the input has node rows: each became a node, where neo4j-admin refuses the
+   * relationship.
+   */
+  reportDangling() {
+    const dangling = this.placeholders.filter((p) => this.registry.codeAt(p.index) === 0);
+    if (dangling.length === 0 || !this.nodeRows) {
+      return;
+    }
+    const shown = dangling.slice(0, 5).map((p) => String(p.id)).join(", ");
+    this.report.warning(
+      "validation-error",
+      DANGLING_REFERENCE_CODE,
+      `${dangling.length} relationship endpoint${plural(dangling.length)} ${agree(dangling.length, "names", "name")} no node row and became nodes: ${shown}${dangling.length > 5 ? ", ..." : ""} (neo4j-admin refuses such relationships)`,
+      { element: String(dangling[0].id) }
+    );
   }
   /**
    * Push one relationship row.
@@ -751,7 +887,7 @@ class Neo4jImportSession {
       report.error(
         "validation-error",
         COLUMN_COUNT_CODE,
-        `row has ${count} cell(s) but the header has ${section.width}`,
+        `row has ${count} cell${plural(count)} but the header has ${section.width}`,
         { line }
       );
       report.counts.skippedEdges++;
@@ -800,7 +936,7 @@ class Neo4jImportSession {
     let weight;
     if (section.weightCell >= 0) {
       try {
-        weight = parseWeightText(cells[section.weightCell]);
+        weight = parseWeightText(cells[section.weightCell], this.report);
       } catch (err) {
         report.recordError(err, { line, element });
         report.counts.skippedEdges++;
@@ -811,6 +947,9 @@ class Neo4jImportSession {
       report.counts.skippedEdges++;
       return;
     }
+    const created = [source, target].filter(
+      (id, k) => (k === 0 || id !== source) && sink.indexOf(id) === INVALID_INDEX
+    );
     let edge;
     try {
       edge = this.direction.addEdge(source, target, "directed", weight, { line, element });
@@ -819,13 +958,26 @@ class Neo4jImportSession {
       report.counts.skippedEdges++;
       return;
     }
+    for (const id of created) {
+      report.counts.nodes++;
+      this.placeholders.push({ id, index: sink.indexOf(id) });
+    }
     if (section.typeCell >= 0) {
       const type = cells[section.typeCell];
       if (type.length > 0) {
-        sink.setEdgeValue(this.typeHandle, edge, type);
+        this.guarded(line, element, () => {
+          sink.setEdgeValue(this.typeHandle, edge, type);
+        });
+      } else {
+        report.warning(
+          "missing-value",
+          MISSING_TYPE_CODE,
+          "empty :TYPE cell; neo4j-admin requires a relationship type, the relationship is kept without one",
+          { line, element }
+        );
       }
     }
-    this.writeProperties("edge", section.properties, edge);
+    this.writeProperties("edge", section.properties, edge, line, element);
     this.reportPrecision(line, element);
     report.counts.edges++;
   }
@@ -886,6 +1038,7 @@ class Neo4jImportSession {
   parseProperties(slots, cells, quoted, line, element) {
     const { values, texts, precisionSlots } = this;
     precisionSlots.length = 0;
+    this.overflows.length = 0;
     for (const slot of slots) {
       const text = cells[slot.cell];
       texts[slot.cell] = null;
@@ -896,16 +1049,21 @@ class Neo4jImportSession {
       const { spec } = slot;
       try {
         if (spec.temporal !== null && !spec.list) {
-          const parsed = parseDeclaredTemporal(text, spec);
+          const zoned = withZoneOffset(text, spec);
+          const parsed = parseDeclaredTemporal(zoned, spec);
           values[slot.cell] = parsed.value;
-          texts[slot.cell] = parsed.text;
+          texts[slot.cell] = zoned === text ? parsed.text : text;
         } else {
           values[slot.cell] = parseDeclaredValue(text, spec, this.options.listSyntax);
+          checkNeo4jRange(spec, values[slot.cell], text);
         }
       } catch (err) {
         this.report.recordError(err, { line, element: `${element} ${slot.name}` });
         return false;
       }
+      if (overflows(spec, values[slot.cell], text)) {
+        this.overflows.push(slot.name);
+      }
       if (spec.precision && losesPrecision(spec, text)) {
         precisionSlots.push(slot);
       }
@@ -917,8 +1075,10 @@ class Neo4jImportSession {
    * @param domain - node or edge
    * @param slots - the section's property slots
    * @param row - the node or edge index
+   * @param line - the row's line
+   * @param element - the row's element name for issues
    */
-  writeProperties(domain, slots, row) {
+  writeProperties(domain, slots, row, line, element) {
     const { sink, values, texts } = this;
     for (const slot of slots) {
       const value = values[slot.cell];
@@ -926,20 +1086,22 @@ class Neo4jImportSession {
         continue;
       }
       const text = texts[slot.cell];
-      if (text !== null && slot.companion === INVALID_INDEX && slot.companionDecl !== null) {
-        slot.companion = declareCompanion(sink, domain, slot.companionDecl);
-      }
-      if (domain === "node") {
-        sink.setNodeValue(slot.handle, row, value);
-        if (text !== null) {
-          sink.setNodeValue(slot.companion, row, text);
+      this.guarded(line, `${element} ${slot.name}`, () => {
+        if (text !== null && slot.companion === INVALID_INDEX && slot.companionDecl !== null) {
+          slot.companion = declareCompanion(sink, domain, slot.companionDecl);
         }
-      } else {
-        sink.setEdgeValue(slot.handle, row, value);
-        if (text !== null) {
-          sink.setEdgeValue(slot.companion, row, text);
+        if (domain === "node") {
+          sink.setNodeValue(slot.handle, row, value);
+          if (text !== null) {
+            sink.setNodeValue(slot.companion, row, text);
+          }
+        } else {
+          sink.setEdgeValue(slot.handle, row, value);
+          if (text !== null) {
+            sink.setEdgeValue(slot.companion, row, text);
+          }
         }
-      }
+      });
     }
   }
   /**
@@ -957,6 +1119,15 @@ class Neo4jImportSession {
       );
     }
     this.precisionSlots.length = 0;
+    for (const name of this.overflows) {
+      this.report.warning(
+        "precision",
+        PRECISION_CODE,
+        `the value of "${name}" is beyond the range of its float / double type and was stored as the nearest representable value`,
+        { line, element }
+      );
+    }
+    this.overflows.length = 0;
   }
   /**
    * The labels of a node row: every `:LABEL` cell split by the array delimiter (empty items
@@ -994,6 +1165,101 @@ class Neo4jImportSession {
 function qualify(id, space) {
   return space === null ? id : `${space}:${String(id)}`;
 }
+const INTEGER_RANGES = {
+  byte: [-128, 127],
+  short: [-32768, 32767]
+};
+function isDuration(text) {
+  if (DURATION_DATE_TIME.test(text)) {
+    return true;
+  }
+  const m = /^[+-]?P([^T]*)(?:T(.*))?$/i.exec(text);
+  if (m === null || m[2] === "" || m[1] === "" && m[2] === void 0) {
+    return false;
+  }
+  return unitsInOrder(m[1], "YMWD") && unitsInOrder(m[2] ?? "", "HMS");
+}
+const DURATION_DATE_TIME = /^[+-]?P\d{4}-?\d{2}-?\d{2}T\d{2}:?\d{2}:?\d{2}(?:\.\d+)?$/i;
+function unitsInOrder(text, units) {
+  let rest = text.toUpperCase();
+  let from = 0;
+  while (rest !== "") {
+    const m = /^[-+]?\d+(?:\.\d+)?([A-Z])/.exec(rest);
+    const at = m === null ? -1 : units.indexOf(m[1], from);
+    if (m === null || at < 0) {
+      return false;
+    }
+    from = at + 1;
+    rest = rest.slice(m[0].length);
+  }
+  return true;
+}
+function checkNeo4jRange(spec, value, text) {
+  const base = spec.declared.trim().toLowerCase().replace(/\[\]$/, "");
+  const items = spec.list && Array.isArray(value) ? value : [value];
+  const range = INTEGER_RANGES[base];
+  for (const item of items) {
+    let bad = false;
+    if (range !== void 0) {
+      bad = typeof item === "number" && (item < range[0] || item > range[1]);
+    } else if (base === "char") {
+      bad = typeof item === "string" && item.length !== 1;
+    } else if (base === "duration") {
+      bad = typeof item === "string" && !isDuration(item.trim());
+    }
+    if (bad) {
+      const span = range === void 0 ? "" : ` (${range[0]} to ${range[1]})`;
+      throw new GraphFormatError("E_COLUMN_TYPE", `"${text}" is not ${withArticle(base)}${span}`, {
+        value: text,
+        kind: base
+      });
+    }
+  }
+}
+const F32_MAX = 34028234663852886e22;
+function overflows(spec, value, text) {
+  if (spec.kind !== "float" && spec.kind !== "double" || /inf|nan/i.test(text)) {
+    return false;
+  }
+  const items = spec.list && Array.isArray(value) ? value : [value];
+  return items.some(
+    (v) => typeof v === "number" && (!Number.isFinite(v) || spec.kind === "float" && Math.abs(v) > F32_MAX)
+  );
+}
+function withZoneOffset(text, spec) {
+  const trimmed = text.trim();
+  const open = trimmed.lastIndexOf("[");
+  if (spec.temporal !== "dateTime" || open < 0 || !trimmed.endsWith("]")) {
+    return text;
+  }
+  const local = trimmed.slice(0, open);
+  const zone = trimmed.slice(open + 1, -1);
+  if (zone === "" || zone.includes("]") || /[\n\r\u2028\u2029]/.test(local)) {
+    return text;
+  }
+  let format;
+  try {
+    format = new Intl.DateTimeFormat("en-US", { timeZone: zone, timeZoneName: "longOffset" });
+  } catch {
+    throw new GraphFormatError("E_COLUMN_TYPE", `"${text}" names an unknown time zone ${zone}`, { value: text });
+  }
+  if (/(Z|z|[+-]\d{2}(:?\d{2})?)$/.test(local)) {
+    return local;
+  }
+  const wall = parseTemporal(local, "localDateTime").value;
+  const offsetAt = (ms) => {
+    const name = format.formatToParts(new Date(ms)).find((p) => p.type === "timeZoneName")?.value ?? "GMT";
+    const o = /GMT([+-])(\d{2}):(\d{2})/.exec(name);
+    if (o === null) {
+      return 0;
+    }
+    return (o[1] === "-" ? -1 : 1) * (Number(o[2]) * 60 + Number(o[3]));
+  };
+  const minutes = offsetAt(wall - offsetAt(wall) * 6e4);
+  const sign = minutes < 0 ? "-" : "+";
+  const abs = Math.abs(minutes);
+  return `${local}${sign}${String(Math.floor(abs / 60)).padStart(2, "0")}:${String(abs % 60).padStart(2, "0")}`;
+}
 function emptyValue(spec) {
   if (spec.list) {
     return [];
@@ -1027,6 +1293,7 @@ function sniffNeo4j(head) {
 }
 const neo4jImporter = Object.freeze({
   format: NEO4J$1,
+  options: Object.freeze(["arrayDelimiter", "delimiter", "nodes", "quote", "relationships"]),
   extensions: Object.freeze([".csv", ".tsv"]),
   mimeTypes: Object.freeze(["text/csv", "text/tab-separated-values"]),
   sniff: sniffNeo4j,
@@ -1044,7 +1311,14 @@ const neo4jImporter = Object.freeze({
     reportSinkOptions(sink, options, report);
     reportUnusedOptions(options, report, USED_OPTIONS);
     const session = new Neo4jImportSession(sink, report, common, format);
-    await session.run([input, ...format.nodes, ...format.relationships]);
+    await session.run([
+      { input, kind: null },
+      ...format.nodes.map((file) => ({ input: file, kind: "node" })),
+      ...format.relationships.map((file) => ({ input: file, kind: "relationship" }))
+    ]);
+    if (session.weightProperty !== null) {
+      sink.setMeta({ extra: { neo4j: { weightProperty: session.weightProperty } } });
+    }
     throwIfAborted(common.signal);
     return report.finish();
   }
@@ -1121,7 +1395,7 @@ const NODE_NOTE_CODES = /* @__PURE__ */ new Set([
 ]);
 const ARRAY_SYNTAXES = /* @__PURE__ */ new Set([";", ",", "|"]);
 const PARTS = /* @__PURE__ */ new Set(["all", "nodes", "relationships"]);
-function resolveNeo4jExportOptions(options) {
+function resolveNeo4jExportOptions(options, readFrom) {
   const o = options ?? {};
   const part = o.part ?? "all";
   if (!PARTS.has(part)) {
@@ -1145,12 +1419,16 @@ function resolveNeo4jExportOptions(options) {
   const delimiter = o.delimiter ?? ",";
   const syntax = { ...checkRecordSyntax({ delimiter, quote: o.quote ?? '"' }), delimiter };
   if (syntax.delimiter === arrayDelimiter) {
-    throw new GraphFormatError("E_UNSUPPORTED", "options delimiter and arrayDelimiter must differ", {
-      option: "arrayDelimiter",
-      found: arrayDelimiter
-    });
+    throw new GraphFormatError(
+      "E_UNSUPPORTED",
+      `options delimiter and arrayDelimiter must differ: both are ${JSON.stringify(arrayDelimiter)}; pass another arrayDelimiter (";", "," or "|")`,
+      {
+        option: "arrayDelimiter",
+        found: arrayDelimiter
+      }
+    );
   }
-  const weightColumn = o.weightColumn === void 0 ? "weight" : o.weightColumn;
+  const weightColumn = o.weightColumn === void 0 ? readFrom ?? "weight" : o.weightColumn;
   if (weightColumn !== null && (typeof weightColumn !== "string" || weightColumn.length === 0)) {
     throw new GraphFormatError("E_UNSUPPORTED", "option weightColumn: expected a non-empty name or null", {
       option: "weightColumn",
@@ -1197,7 +1475,8 @@ class ExportPlan {
     const generic = checkCapabilities(snapshot, NEO4J_CAPABILITIES, common, {
       roles: SLOT_ROLES,
       roleNames: ROLE_NAMES,
-      temporalText: true
+      temporalText: true,
+      weights: options.weightColumn !== null
     });
     this.planColumns("node", snapshot.nodes, this.nodeColumns);
     this.planColumns("edge", snapshot.edges, this.edgeColumns);
@@ -1246,7 +1525,7 @@ class ExportPlan {
     if (!snapshot.directed) {
       this.note(
         UNDIRECTED_LOSS,
-        `the snapshot is undirected; every edge is written as a directed relationship (${snapshot.edgeCount} edge(s))`,
+        `the snapshot is undirected; every edge is written as a directed relationship (${snapshot.edgeCount} edge${plural(snapshot.edgeCount)})`,
         null,
         snapshot.edgeCount
       );
@@ -1260,7 +1539,7 @@ class ExportPlan {
       if (undirected > 0) {
         this.note(
           UNDIRECTED_LOSS,
-          `${undirected} undirected edge(s) are written as one directed relationship each (source to target, a pair folded to its primary); Neo4j has no undirected relationship`,
+          `${undirected} undirected edge${plural(undirected)} ${agree(undirected, "is", "are")} written as one directed relationship each (source to target, a pair folded to its primary); Neo4j has no undirected relationship`,
           null,
           undirected
         );
@@ -1269,7 +1548,7 @@ class ExportPlan {
     if (folding.mutualCount > 0) {
       this.note(
         LOSS.MUTUAL_EXPANDED,
-        `${folding.mutualCount} mutual pair(s) are written as two directed relationships; the mutual mark is lost`,
+        `${folding.mutualCount} mutual pair${plural(folding.mutualCount)} ${agree(folding.mutualCount, "is", "are")} written as two directed relationships; the mutual mark is lost`,
         null,
         folding.mutualCount
       );
@@ -1461,7 +1740,7 @@ class ExportPlan {
     if (rows > 0) {
       this.note(
         ARRAY_DELIMITER_LOSS,
-        `${label}: ${rows} row(s) hold an item containing the array delimiter "${arrayDelimiter}", which Neo4j cannot escape`,
+        `${label}: ${rows} row${plural(rows)} ${agree(rows, "holds", "hold")} an item containing the array delimiter "${arrayDelimiter}", which Neo4j cannot escape`,
         column.meta.name,
         rows
       );
@@ -1496,7 +1775,7 @@ class ExportPlan {
     } else if (taken !== void 0 && name === DEFAULT_WEIGHT_COLUMN) {
       this.note(
         LOSS.WEIGHT_KEY_CLASH,
-        `edge column "${name}" is written under the property the importer reads THE weight from (weightFrom "${name}"); it reads back as the weight, not as a column`,
+        `edge column "${name}" is written under the property the importer reads edge weights from (weightFrom "${name}"); it reads back as the weight, not as a column`,
         name,
         taken.column.length - taken.column.nullCount
       );
@@ -1550,7 +1829,7 @@ class ExportPlan {
     if (typeChanges > 0) {
       this.note(
         ID_TEXT_TYPE_LOSS,
-        `${typeChanges} node id(s) re-import as another type under the canonical id rule (a string of canonical integer text, or a non-integer number)`,
+        `${typeChanges} node id${plural(typeChanges)} re-import as another type under the canonical id rule (a string of canonical integer text, or a non-integer number)`,
         null,
         typeChanges
       );
@@ -1558,13 +1837,13 @@ class ExportPlan {
     if (collisions > 0) {
       this.note(
         ID_TEXT_COLLISION_LOSS,
-        `${collisions} node id(s) share their text with another id (a number and a string); export() will throw`,
+        `${collisions} node id${plural(collisions)} ${agree(collisions, "shares", "share")} their text with another id (a number and a string); the save fails`,
         null,
         collisions
       );
       this.fatalAll = new GraphFormatError(
         "E_INVALID_ID",
-        `${collisions} node id(s) share their text with another id; Neo4j ids are text`,
+        `${collisions} node id${plural(collisions)} ${agree(collisions, "shares", "share")} their text with another id; Neo4j ids are text`,
         { reason: "text collision", count: collisions }
       );
     }
@@ -1613,7 +1892,7 @@ class ExportPlan {
     if (count > 0) {
       this.note(
         MULTIPLE_ID_PROPERTIES_LOSS,
-        `${count} node(s) have more than one stored-id column set; only the first in declaration order is written`,
+        `${count} node${plural(count)} ${agree(count, "has", "have")} more than one stored-id column set; only the first in declaration order is written`,
         null,
         count
       );
@@ -1713,6 +1992,16 @@ class ExportPlan {
    * @returns nothing
    */
   *lines() {
+    for (const row of this.rows()) {
+      yield row.line;
+    }
+  }
+  /**
+   * The lines of the requested part, each header line tagged with the file it starts.
+   * @yields one line at a time, with the file name on a header line
+   * @returns nothing
+   */
+  *rows() {
     if (this.fatal !== null) {
       throw this.fatal;
     }
@@ -1724,19 +2013,50 @@ class ExportPlan {
       yield* this.relationshipLines();
     }
   }
+  /**
+   * The requested part as one file per section kind: a node file per id space (and stored-id
+   * property), a relationship file per pair of endpoint id spaces, rows of one kind gathered
+   * under one header.
+   * @returns the files, node files first
+   */
+  files() {
+    const files = /* @__PURE__ */ new Map();
+    const names = /* @__PURE__ */ new Set();
+    let current = null;
+    for (const row of this.rows()) {
+      if (row.file !== null) {
+        let file = files.get(row.line);
+        if (file === void 0) {
+          let name = `${row.file.name}.csv`;
+          let k = 2;
+          while (names.has(name)) {
+            name = `${row.file.name}-${k}.csv`;
+            k++;
+          }
+          names.add(name);
+          file = { name, kind: row.file.kind, rows: [] };
+          files.set(row.line, file);
+        }
+        current = file;
+      } else if (current !== null) {
+        current.rows.push(row.line);
+      }
+    }
+    const written = [...files].filter(([, f], i) => f.rows.length > 0 || i === 0 && files.size === 1);
+    return written.map(
+      ([header, f]) => Object.freeze({ name: f.name, kind: f.kind, text: header + f.rows.join("") })
+    );
+  }
   /**
    * The node sections.
    * @yields one line at a time
    * @returns nothing
    */
   *nodeLines() {
-    const { snapshot, labels, nodeColumns } = this;
-    const { delimiter } = this.options.syntax;
-    const propertyHeaders = nodeColumns.map((plan2) => plan2.header).join(delimiter);
+    const { snapshot } = this;
     let sections = 0;
     let sectionSpace = null;
     let sectionIdName = null;
-    const cells = [];
     for (let i = 0; i < snapshot.nodeCount; i++) {
       const space = this.spaceOf(i);
       const stored = this.storedIdOf(i);
@@ -1745,38 +2065,49 @@ class ExportPlan {
         sections++;
         sectionSpace = space;
         sectionIdName = idName;
-        const header = [formatHeaderField(idName, ID_TYPE, space)];
-        if (labels !== null) {
-          header.push(":LABEL");
-        }
-        if (propertyHeaders.length > 0) {
-          header.push(propertyHeaders);
-        }
-        yield `${header.join(delimiter)}
-`;
-      }
-      cells.length = 0;
-      cells.push(this.cell(this.idTextOf(i)));
-      if (labels !== null) {
-        cells.push(this.cell(this.labelsText(i)));
-      }
-      for (const plan2 of nodeColumns) {
-        cells.push(this.cell(this.valueText(plan2, i)));
+        yield this.nodeHeader(idName, space, space ?? idName);
       }
-      yield `${cells.join(delimiter)}
-`;
+      yield { line: this.nodeRow(i), file: null };
     }
     if (sections === 0) {
-      const header = [formatHeaderField(this.options.idColumn ?? "", ID_TYPE, null)];
-      if (labels !== null) {
-        header.push(":LABEL");
-      }
-      if (propertyHeaders.length > 0) {
-        header.push(propertyHeaders);
-      }
-      yield `${header.join(delimiter)}
-`;
+      yield this.nodeHeader(this.options.idColumn ?? "", null, null);
+    }
+  }
+  /**
+   * The header line of a node section, which starts its file.
+   * @param idName - the id column's name
+   * @param space - the id space, or null
+   * @param fileKey - what names the file, or null for the default name
+   * @returns the line
+   */
+  nodeHeader(idName, space, fileKey) {
+    const { delimiter } = this.options.syntax;
+    const header = [formatHeaderField(idName, ID_TYPE, space)];
+    if (this.labels !== null) {
+      header.push(":LABEL");
+    }
+    const properties = this.nodeColumns.map((plan2) => plan2.header).join(delimiter);
+    if (properties.length > 0) {
+      header.push(properties);
+    }
+    return { line: `${header.join(delimiter)}
+`, file: { kind: "nodes", name: fileName("nodes", fileKey, null) } };
+  }
+  /**
+   * One node's line: the id, the labels, the properties.
+   * @param i - the node
+   * @returns the line
+   */
+  nodeRow(i) {
+    const cells = [this.cell(this.idTextOf(i))];
+    if (this.labels !== null) {
+      cells.push(this.cell(this.labelsText(i)));
+    }
+    for (const plan2 of this.nodeColumns) {
+      cells.push(this.cell(this.valueText(plan2, i)));
     }
+    return `${cells.join(this.options.syntax.delimiter)}
+`;
   }
   /**
    * The relationship sections.
@@ -1784,29 +2115,11 @@ class ExportPlan {
    * @returns nothing
    */
   *relationshipLines() {
-    const { snapshot, kind, weights, edgeColumns, folding } = this;
-    const { delimiter } = this.options.syntax;
+    const { snapshot, folding } = this;
     const list = snapshot.edgeList();
-    const propertyHeaders = edgeColumns.map((plan2) => plan2.header).join(delimiter);
-    const weightHeader = weights === null ? null : formatHeaderField(this.options.weightColumn ?? "weight", "double", null);
     let sections = 0;
     let sectionStart = null;
     let sectionEnd = null;
-    const cells = [];
-    const headerOf = (startSpace, endSpace) => {
-      const header = [formatHeaderField("", "START_ID", startSpace), formatHeaderField("", "END_ID", endSpace)];
-      if (kind !== null) {
-        header.push(":TYPE");
-      }
-      if (weightHeader !== null) {
-        header.push(weightHeader);
-      }
-      if (propertyHeaders.length > 0) {
-        header.push(propertyHeaders);
-      }
-      return `${header.join(delimiter)}
-`;
-    };
     for (let e = 0; e < snapshot.edgeCount; e++) {
       if (folding.folded(e)) {
         continue;
@@ -1819,25 +2132,60 @@ class ExportPlan {
         sections++;
         sectionStart = startSpace;
         sectionEnd = endSpace;
-        yield headerOf(startSpace, endSpace);
-      }
-      cells.length = 0;
-      cells.push(this.cell(this.idTextOf(u)), this.cell(this.idTextOf(v)));
-      if (kind !== null) {
-        cells.push(this.cell(kind.isSet(e) ? textOf(kind, e) : null));
+        yield this.relationshipHeader(startSpace, endSpace);
       }
-      if (weights !== null) {
-        cells.push(this.cell(weights.text(e)));
-      }
-      for (const plan2 of edgeColumns) {
-        cells.push(this.cell(this.valueText(plan2, e)));
-      }
-      yield `${cells.join(delimiter)}
-`;
+      yield { line: this.relationshipRow(e, u, v), file: null };
     }
     if (sections === 0) {
-      yield headerOf(null, null);
+      yield this.relationshipHeader(null, null);
+    }
+  }
+  /**
+   * The header line of a relationship section, which starts its file.
+   * @param startSpace - the id space of the start nodes, or null
+   * @param endSpace - the id space of the end nodes, or null
+   * @returns the line
+   */
+  relationshipHeader(startSpace, endSpace) {
+    const { delimiter } = this.options.syntax;
+    const header = [formatHeaderField("", "START_ID", startSpace), formatHeaderField("", "END_ID", endSpace)];
+    if (this.kind !== null) {
+      header.push(":TYPE");
+    }
+    if (this.weights !== null) {
+      header.push(formatHeaderField(this.options.weightColumn ?? "weight", "double", null));
     }
+    const properties = this.edgeColumns.map((plan2) => plan2.header).join(delimiter);
+    if (properties.length > 0) {
+      header.push(properties);
+    }
+    return {
+      line: `${header.join(delimiter)}
+`,
+      file: { kind: "relationships", name: fileName("relationships", startSpace, endSpace) }
+    };
+  }
+  /**
+   * One relationship's line: the ends, the type, the weight, the properties.
+   * @param e - the edge
+   * @param u - its source
+   * @param v - its target
+   * @returns the line
+   */
+  relationshipRow(e, u, v) {
+    const { kind, weights } = this;
+    const cells = [this.cell(this.idTextOf(u)), this.cell(this.idTextOf(v))];
+    if (kind !== null) {
+      cells.push(this.cell(kind.isSet(e) ? textOf(kind, e) : null));
+    }
+    if (weights !== null) {
+      cells.push(this.cell(weights.text(e)));
+    }
+    for (const plan2 of this.edgeColumns) {
+      cells.push(this.cell(this.valueText(plan2, e)));
+    }
+    return `${cells.join(this.options.syntax.delimiter)}
+`;
   }
   /**
    * A CSV cell: empty for an unset value, a quoted empty string for a set empty string, the
@@ -1853,7 +2201,7 @@ class ExportPlan {
     if (text.length === 0) {
       return quote + quote;
     }
-    return quoteCsvCell(text, this.options.syntax.delimiter);
+    return quoteCsvCell(text, this.options.syntax.delimiter, quote);
   }
   /**
    * The `:LABEL` cell of a node.
@@ -2000,7 +2348,7 @@ function formatPoint(value) {
     if (typeof item === "number") {
       parts.push(`${key}:${formatF64(item)}`);
     } else if (typeof item === "string") {
-      parts.push(`${key}:'${item.replace(/'/g, "")}'`);
+      parts.push(`${key}:'${item.replaceAll("'", "")}'`);
     } else {
       return JSON.stringify(value) ?? "";
     }
@@ -2033,6 +2381,7 @@ function textOf(column, row) {
 }
 const neo4jExporter = Object.freeze({
   format: NEO4J,
+  options: Object.freeze(["arrayDelimiter", "delimiter", "idColumn", "part", "quote", "weightColumn"]),
   capabilities: NEO4J_CAPABILITIES,
   /**
    * Pre-flight: what export() would lose.
@@ -2062,23 +2411,56 @@ const neo4jExporter = Object.freeze({
     return joinText(plan(snapshot, options).lines());
   }
 });
+function fileName(kind, first, second) {
+  const parts = [kind, first ?? "", second ?? ""].filter((p) => p !== "");
+  return parts.join("-").replaceAll(/[^\w.-]/g, "_");
+}
+function exportNeo4jFiles(snapshot, options) {
+  try {
+    return Promise.resolve(plan(snapshot, options).files());
+  } catch (err) {
+    return Promise.reject(err);
+  }
+}
 function plan(snapshot, options) {
-  return new ExportPlan(snapshot, resolveNeo4jExportOptions(options), resolveExportOptions(options));
+  return new ExportPlan(
+    snapshot,
+    resolveNeo4jExportOptions(options, weightPropertyOf(snapshot)),
+    resolveExportOptions(options)
+  );
+}
+function weightPropertyOf(snapshot) {
+  const neo4j = snapshot.meta.extra?.neo4j;
+  const name = neo4j?.weightProperty;
+  return typeof name === "string" && name !== "" ? name : null;
 }
 const NEO4J_ISSUE = Object.freeze({
-  /** The input holds invalid UTF-8 (fatal). */
+  ...INPUT_ISSUE,
+  ...ELEMENT_ISSUE,
+  /**
+   * A cell that does not parse as its column's declared type ("x" in an `:int` column, a `:byte` beyond 127). The
+   * row is skipped.
+   */
+  COLUMN_TYPE: COLUMN_TYPE_CODE,
+  /** The input is not valid UTF-8. The import stops. */
   INVALID_UTF8: INVALID_UTF8_CODE,
-  /** Invalid bytes in the encoding a BOM, a declaration or the encoding option chose (fatal). */
+  /**
+   * Some bytes are not valid in the encoding that was chosen (by a byte order mark, the file's declaration or the
+   * `encoding` option). The import stops.
+   */
   INVALID_ENCODING: INVALID_ENCODING_CODE,
   /** Bytes that are not UTF-8 and declare no encoding were read as windows-1252. */
   ENCODING_FALLBACK: ENCODING_FALLBACK_CODE,
   /** A declared encoding the platform cannot decode was ignored. */
   UNKNOWN_ENCODING: UNKNOWN_ENCODING_CODE,
-  /** An unterminated quoted field (fatal). */
+  /** A quoted field is never closed. The import stops. */
   CSV_UNCLOSED_QUOTE: UNCLOSED_QUOTE_CODE,
-  /** Text after a closing quote (fatal). */
+  /**
+   * There is text after a closing quote, such as `"a"b`. Inside a quoted field, write a quote as two quotes. The
+   * import stops.
+   */
   CSV_QUOTE: BAD_QUOTE_CODE,
-  /** No header or a malformed header (fatal). */
+  /** The file has no header, or a header neo4j-admin would refuse. The import stops. */
   HEADER: HEADER_CODE,
   /** A row with a different field count than the header. */
   COLUMN_COUNT: COLUMN_COUNT_CODE,
@@ -2092,41 +2474,65 @@ const NEO4J_ISSUE = Object.freeze({
   ID_SPACE_COLLISION: ID_SPACE_COLLISION_CODE,
   /** A spaced relationship endpoint `Space:id` that names a node declared without a space; the row is skipped. */
   ENDPOINT_SPACE: ENDPOINT_SPACE_CODE,
-  /** Two id texts merged into one number under ids "number". */
+  /** Two different id texts became the same number because `ids` is "number", so their nodes were merged. */
   ID_MERGED: ID_MERGED_CODE,
   /** A header brace option the importer does not apply. */
   HEADER_OPTION_IGNORED: HEADER_OPTION_CODE,
   /** A declared type the format does not define (kept as string). */
   UNKNOWN_ATTR_TYPE: UNKNOWN_ATTR_TYPE_CODE,
-  /** A long value beyond 2^53 rounded. */
+  /** An integer beyond 2^53 was stored as the nearest 64-bit float; pass `long: "string"` to keep every digit. */
   PRECISION: PRECISION_CODE,
-  /** A column renamed `<name>#<id>` because the name was taken (design section 5.6). */
+  /**
+   * An attribute was renamed `<name>#<suffix>` because another attribute already has its name, for example a
+   * repeated column header.
+   */
   COLUMN_RENAMED: COLUMN_RENAMED_CODE,
-  /** A role the caller's sink already holds. */
+  /**
+   * You read into a graph builder that already has an id, label or position attribute, so this file's one is kept as
+   * a plain attribute.
+   */
   ROLE_TAKEN: ROLE_TAKEN_CODE,
-  /** A common option the importer has no use for (nodeIdFrom, defaultDirected, ...). */
+  /** You set an option this format does not use; it had no effect. The message names the option. */
   OPTION_IGNORED: OPTION_IGNORED_CODE,
-  /** A builder-policy option the sink does not honour. */
-  SINK_OPTION: SINK_OPTION_CODE
+  /**
+   * You read into your own graph builder, which was created with a different `addMissingNodes`, `duplicateEdges`,
+   * `selfLoops` or `weightDtype` than the option you passed; the builder's setting applies.
+   */
+  SINK_OPTION: SINK_OPTION_CODE,
+  /** A relationship with an empty :TYPE cell (neo4j-admin requires one); kept without a type. */
+  MISSING_TYPE: MISSING_TYPE_CODE,
+  /** A file under the nodes option holds a relationship header, or the reverse; read by its header. */
+  SECTION_KIND: SECTION_KIND_CODE,
+  /** Relationship endpoints no node row declares became nodes (neo4j-admin refuses them). */
+  DANGLING_REFERENCE: DANGLING_REFERENCE_CODE
 });
 const NEO4J_LOSS = Object.freeze({
   /** `:IGNORE` columns skipped on import. */
   IGNORED_COLUMNS: IGNORED_COLUMNS_LOSS,
-  /** Undirected edges (an undirected snapshot, the folded pairs of a mixed one) written as directed relationships. */
+  /**
+   * Neo4j relationships are always directed, so the edges of an undirected graph, and the undirected edges of a
+   * mixed graph, read back as directed.
+   */
   UNDIRECTED_AS_DIRECTED: UNDIRECTED_LOSS,
   /** A mutual pair written as two directed relationships without its mark. */
   MUTUAL_EXPANDED: MUTUAL_EXPANDED_CODE,
-  /** A role column Neo4j has no slot for (label, ...) written as a plain property. */
+  /** An attribute with a role the format has no place for is written as a plain attribute; the role is lost. */
   ROLE_DROPPED: ROLE_DROPPED_CODE,
-  /** A plain `weight` edge column reads back as THE weight (the importer's weightFrom default). */
+  /**
+   * An edge attribute named `weight` that is not the graph's weight reads back as the edge weight, because the
+   * Neo4j importer reads weights from the `weight` property by default.
+   */
   WEIGHT_KEY_CLASH: WEIGHT_KEY_CLASH_CODE,
-  /** A node id whose text re-imports as another type under the canonical rule. */
+  /**
+   * A node id that reads back as a different type, such as the text "7" as the number 7. Read the file with `ids:
+   * "string"` or `ids: "keep"` to keep the type.
+   */
   ID_TEXT_TYPE: ID_TEXT_TYPE_LOSS,
-  /** A number and a string id with the same text; export() throws. */
+  /** Two node ids would be written as the same text (the number 5 and the text "5"); the save fails with E_INVALID_ID. */
   ID_TEXT_COLLISION: ID_TEXT_COLLISION_LOSS,
-  /** The weight column name is taken by an edge column; export() throws. */
+  /** The `weightColumn` name is already an edge attribute; the save fails. */
   WEIGHT_COLUMN_TAKEN: WEIGHT_COLUMN_TAKEN_LOSS,
-  /** The id column name is taken by a node column; export() throws. */
+  /** The `idColumn` name is already a node attribute; the save fails. */
   ID_COLUMN_TAKEN: ID_COLUMN_TAKEN_LOSS,
   /** Several stored-id properties; one becomes the `:ID` column. */
   MULTIPLE_ID_PROPERTIES: MULTIPLE_ID_PROPERTIES_LOSS,
@@ -2143,6 +2549,7 @@ export {
   NEO4J_LOSS,
   ORIGINAL_ID_COLUMN,
   TYPE_COLUMN,
+  exportNeo4jFiles,
   neo4jExporter,
   neo4jImporter
 };