@graphty/graph-io 0.3.25 → 0.3.27

package/dist/csv.js

@@ -1,11 +1,9 @@
-import { aV as DICT_SAMPLE_ROWS, _ as DictHeuristic, R as ROLE_TAKEN_CODE$1, I as ID_MERGED_CODE$1, c as DUPLICATE_EDGE_ID_CODE$1, d as DUPLICATE_NODE_CODE$1, f as MISSING_ID_CODE$1, e as MISSING_ENDPOINT_CODE$1, u as EMPTY_INPUT_CODE$1, v as resolveImportOptions, w as ImportReportBuilder, F as reportSinkOptions, z as reportUnusedOptions, J as DirectionResolver, K as IdCoercer, y as throwIfAborted, Q as uniqueColumnName, at as RENAMED_CODE, L as declareResolved, V as resolveExportOptions, X as pairFolding, aT as joinListText, ax as canonicalId, af as MIXED_DIRECTION_CODE, D as DIRECTION_FORCED_CODE, a as DIRECTION_REFUSED_CODE, S as SINK_OPTION_CODE, O as OPTION_IGNORED_CODE, C as COLUMN_RENAMED_CODE, q as UNKNOWN_ENCODING_CODE, E as ENCODING_FALLBACK_CODE, r as INVALID_ENCODING_CODE, s as INVALID_UTF8_CODE } from "./chunks/report-B1z4WT9e.js";
-import { i as inferTextDtype, T as TextCellWriter, p as parseTextCell, W as WIDENING_UNSUPPORTED_CODE } from "./chunks/text-Dr0Ifpag.js";
+import { b as plural, bV as DICT_SAMPLE_ROWS, ac as DictHeuristic, R as ROLE_TAKEN_CODE$1, I as ID_MERGED_CODE$1, m as DUPLICATE_EDGE_ID_CODE$1, n as DUPLICATE_NODE_CODE$1, t as MISSING_ID_CODE$1, s as MISSING_ENDPOINT_CODE$1, E as EMPTY_INPUT_CODE$1, al as resolveImportOptions, a8 as ImportReportBuilder, ao as reportSinkOptions, an as reportUnusedOptions, aq as DirectionResolver, ar as IdCoercer, am as throwIfAborted, O as OPTION_IGNORED_CODE, aL as parseWeightText, a0 as uniqueColumnName, ay as RENAMED_CODE, a1 as declareResolved, c as capabilities, L as LOSS, a as checkCapabilities, r as resolveExportOptions, p as pairFolding, bE as countMixedEdges, $ as agree, e as explicitWeights, b$ as otherFormatDialect, bT as joinListText, aG as formatInteger, aF as formatDecimal, aH as canonicalId, M as MIXED_DIRECTION_CODE, D as DIRECTION_FORCED_CODE, d as DIRECTION_REFUSED_CODE, S as SINK_OPTION_CODE, C as COLUMN_RENAMED_CODE, w as UNKNOWN_ENCODING_CODE, x as ENCODING_FALLBACK_CODE, y as INVALID_ENCODING_CODE, z as INVALID_UTF8_CODE, P as PRECISION_CODE, F as ELEMENT_ISSUE, G as INPUT_ISSUE } from "./chunks/export-CHd4tQE2.js";
+import { i as inferTextDtype, T as TextCellWriter, p as parseTextCell, W as WIDENING_UNSUPPORTED_CODE } from "./chunks/text-DzXjAiTl.js";
 import { GraphFormatError, INVALID_INDEX } from "@graphty/graph-format";
-import { p as parseWeightText, e as explicitWeights, d as formatInteger, b as formatDecimal } from "./chunks/weights-Dzba96G3.js";
-import { s as sniffNewline, a as sniffDelimiter, C as CsvRecordReader, D as DELIMITER_CANDIDATES, B as BAD_QUOTE_CODE, U as UNCLOSED_QUOTE_CODE } from "./chunks/records-dbRkxwaq.js";
-import { m as quoteCsvCell } from "./chunks/escape-B-tkk_Cl.js";
-import { c as capabilities, L as LOSS, a as checkCapabilities, d as countMixedEdges } from "./chunks/export-Bh60Dv-n.js";
-import { j as joinText, e as encodeChunks } from "./chunks/writer-C7flM-Ih.js";
+import { s as stripLeadingComments, a as sniffNewline, b as sniffDelimiter, D as DELIMITER_CANDIDATES, c as checkRecordSyntax, C as CsvRecordReader, d as splitRecords, B as BAD_QUOTE_CODE, U as UNCLOSED_QUOTE_CODE } from "./chunks/records-CdlvL4RO.js";
+import { o as quoteCsvCell } from "./chunks/escape-D1HPTUrP.js";
+import { j as joinText, e as encodeChunks } from "./chunks/writer-DxjgHwSe.js";
 const SOURCE_NAMES = Object.freeze([
   "source",
   "src",
@@ -61,7 +59,7 @@ function resolveColumnRef(names, ref, option) {
     if (!Number.isInteger(ref) || ref < 0 || ref >= names.length) {
       throw new GraphFormatError(
         "E_UNSUPPORTED",
-        `option ${option}: column ${ref} does not exist (the file has ${names.length} column(s))`,
+        `option ${option}: column ${ref} does not exist (the file has ${names.length} column${plural(names.length)})`,
         { option, found: ref, columns: names.length }
       );
     }
@@ -79,15 +77,24 @@ function resolveColumnRef(names, ref, option) {
 }
 function looksLikeHeader(first, second) {
   let allText = true;
+  let marker = false;
   for (const cell of first) {
     const text = cell.trim();
     if (HEADER_MARKERS.has(text.toLowerCase())) {
-      return true;
+      marker = true;
     }
     if (text.length === 0 || inferTextDtype(text) !== "string") {
       allText = false;
     }
   }
+  if (marker) {
+    const names = headerNames(first);
+    if (second === null || findColumn(names, SOURCE_NAMES) >= 0 && findColumn(names, TARGET_NAMES) >= 0) {
+      return true;
+    }
+    const chained = first.length === 2 && second.length >= 1 && first[1].trim() === second[0].trim();
+    return !chained || first[1].trim().length === 0;
+  }
   if (!allText || second === null) {
     return false;
   }
@@ -280,6 +287,17 @@ const ID_MERGED_CODE = ID_MERGED_CODE$1;
 const COLUMN_MISSING_CODE = "W_CSV_COLUMN_MISSING";
 const ROLE_TAKEN_CODE = ROLE_TAKEN_CODE$1;
 const DUPLICATE_EDGE_ID_CODE = DUPLICATE_EDGE_ID_CODE$1;
+const OTHER_FORMAT_CODE = "E_CSV_OTHER_FORMAT";
+const STRAY_QUOTE_CODE = "W_CSV_STRAY_QUOTE";
+const COMMENT_DIRECTION_CODE = "W_CSV_COMMENT_DIRECTION";
+const TYPE_COLUMN_IGNORED_CODE = "W_CSV_TYPE_COLUMN_IGNORED";
+const TRAILING_HEADER_DELIMITER_CODE = "W_CSV_TRAILING_HEADER_DELIMITER";
+const SINGLE_COLUMN_CODE = "W_CSV_SINGLE_COLUMN";
+const AMBIGUOUS_COLUMN_CODE = "W_CSV_AMBIGUOUS_COLUMN";
+const PADDED_ID_CODE = "W_CSV_PADDED_ID";
+const COMMENT_LIKE_RECORD_CODE = "W_CSV_COMMENT_LIKE_RECORD";
+const TRAILING_DELIMITER_CODE = "W_CSV_TRAILING_DELIMITER";
+const WEIGHT_AS_ATTRIBUTE_CODE = "W_CSV_WEIGHT_AS_ATTRIBUTE";
 const TABLE_MODES = /* @__PURE__ */ new Set(["edges", "nodes", "adjacency", "auto"]);
 const USED_OPTIONS = /* @__PURE__ */ new Set([
   "ids",
@@ -298,20 +316,24 @@ const USED_OPTIONS_WITH_NODES = /* @__PURE__ */ new Set([
   ...USED_OPTIONS,
   "nodeIdFrom"
 ]);
-const BAD_DELIMITERS = /* @__PURE__ */ new Set(['"', "\n", "\r"]);
 const COMMENT_CHARS = Object.freeze(["#", "%"]);
-function commentDirection(comments) {
-  for (const comment of comments) {
-    const text = comment.slice(1).trim().toLowerCase();
-    if (text.startsWith("directed graph") || text.startsWith("asym")) {
-      return true;
-    }
-    if (text.startsWith("undirected graph") || text.startsWith("sym") || text.startsWith("bip")) {
-      return false;
-    }
+const DECIMAL_COMMA = /^\s*[+-]?\d+,\d+(?:[eE][+-]?\d+)?\s*$/;
+function commentDirection(comment) {
+  const text = comment.slice(1).trim().toLowerCase();
+  if (/^(?:directed graph|asym)\b/.test(text)) {
+    return true;
+  }
+  if (/^(?:undirected graph|sym|bip)\b/.test(text)) {
+    return false;
   }
   return null;
 }
+function directionName(directed) {
+  return directed ? "directed" : "undirected";
+}
+function isPadded(text, quoted) {
+  return quoted !== true && text.trim().length !== text.length;
+}
 function resolveCsvOptions(options) {
   const o = options ?? {};
   if (o.delimiter !== void 0 && (typeof o.delimiter !== "string" || o.delimiter.length === 0)) {
@@ -320,12 +342,21 @@ function resolveCsvOptions(options) {
       found: o.delimiter
     });
   }
-  if (o.delimiter !== void 0 && BAD_DELIMITERS.has(o.delimiter)) {
-    throw new GraphFormatError("E_UNSUPPORTED", "option delimiter: a quote or a line break cannot delimit", {
-      option: "delimiter",
-      found: o.delimiter
+  if (o.decimal !== void 0 && o.decimal !== "." && o.decimal !== ",") {
+    throw new GraphFormatError("E_UNSUPPORTED", 'option decimal: expected "." or ","', {
+      option: "decimal",
+      found: o.decimal
+    });
+  }
+  if (o.decimal === "," && o.delimiter === ",") {
+    throw new GraphFormatError("E_UNSUPPORTED", 'options delimiter and decimal are both ","; pass delimiter: ";"', {
+      option: "decimal",
+      found: o.decimal
     });
   }
+  if (o.delimiter !== void 0) {
+    checkRecordSyntax({ delimiter: o.delimiter, quote: '"' });
+  }
   if (o.header !== void 0 && o.header !== "auto" && typeof o.header !== "boolean") {
     throw new GraphFormatError("E_UNSUPPORTED", 'option header: expected true, false or "auto"', {
       option: "header",
@@ -338,14 +369,14 @@ function resolveCsvOptions(options) {
       found: o.table
     });
   }
-  for (const name of ["sourceColumn", "targetColumn", "idColumn"]) {
+  for (const name of ["sourceColumn", "targetColumn", "idColumn", "labelColumn"]) {
     checkColumnRef(name, o[name]);
   }
   if (o.typeColumn !== null) {
     checkColumnRef("typeColumn", o.typeColumn);
   }
   if (o.table === "adjacency") {
-    for (const name of ["sourceColumn", "targetColumn", "typeColumn", "idColumn"]) {
+    for (const name of ["sourceColumn", "targetColumn", "typeColumn", "idColumn", "labelColumn"]) {
       if (o[name] !== void 0) {
         throw new GraphFormatError("E_UNSUPPORTED", `option ${name}: an adjacency table has no columns`, {
           option: name,
@@ -368,14 +399,17 @@ function resolveCsvOptions(options) {
   }
   return {
     delimiter: o.delimiter ?? null,
+    decimalComma: o.decimal === ",",
     header: o.header ?? "auto",
     table: o.table ?? "auto",
     sourceColumn: o.sourceColumn ?? null,
     targetColumn: o.targetColumn ?? null,
     typeColumn: o.typeColumn,
     idColumn: o.idColumn ?? null,
-    nodes: o.nodes ?? null,
-    rowNumberIds: o.rowNumberIds ?? false
+    labelColumn: o.labelColumn ?? null,
+    nodes: nodesInput(o.nodes),
+    rowNumberIds: o.rowNumberIds ?? false,
+    explicitDirected: typeof options?.defaultDirected === "boolean" ? options.defaultDirected : null
   };
 }
 function checkColumnRef(name, value) {
@@ -477,6 +511,7 @@ class TableReader {
     this.labelHandle = INVALID_INDEX;
     this.dataRows = 0;
     this.nodeOrdinal = 0;
+    this.adjacencyHinted = false;
     this.edgeIds = /* @__PURE__ */ new Set();
     this.where = { line: null, element: null };
     this.state = state;
@@ -484,17 +519,25 @@ class TableReader {
     this.rowNumbers = state.csv.rowNumberIds && (kind === "nodes" || kind === "auto" && state.csv.nodes === null);
     const readerOptions = {
       delimiter: state.csv.delimiter,
+      // a decimal comma is never the delimiter
+      ...state.csv.decimalComma ? { candidates: DELIMITER_CANDIDATES.filter((d) => d !== ",") } : {},
       comments: COMMENT_CHARS,
       // field counts say nothing about an adjacency table, whose rows vary in width
       skipQuoteErrors: kind === "adjacency",
       signal: state.common.signal,
       onProgress: progress ? state.common.onProgress : null,
-      encoding: state.common.encoding
+      encoding: state.common.encoding,
+      // an adjacency table has no header: an empty one is the empty graph
+      allowEmpty: kind === "adjacency",
+      // explicit dialect options say the caller knows the input is a table
+      inspect: hasExplicitDialect(state.csv) ? void 0 : (preview, line) => {
+        this.refuseOtherFormat(preview, line);
+      }
     };
     this.reader = new CsvRecordReader(input, state.report, readerOptions);
   }
   /**
-   * Read every row; the reader is closed (and a stream cancelled) when the import aborts midway.
+   * Read every row; the reader is closed (and a stream canceled) when the import aborts midway.
    */
   async read() {
     const iterator = this.reader[Symbol.asyncIterator]();
@@ -510,7 +553,10 @@ class TableReader {
    */
   async readRows(iterator) {
     const { report } = this.state;
-    const first = await iterator.next();
+    let first = await iterator.next();
+    if (!first.done && (this.reader.sepDirective || this.isSepDirective(first.value))) {
+      first = await iterator.next();
+    }
     if (first.done && this.kind === "adjacency") {
       return;
     }
@@ -530,7 +576,7 @@ class TableReader {
       const secondRow = second.done ? null : second.value;
       const secondLine = this.reader.line;
       const secondQuoted = this.reader.quoted.slice(0, secondRow?.length ?? 0);
-      header = looksLikeHeader(firstRow, secondRow);
+      header = looksLikeHeader(firstRow, secondRow) || this.namesExplicitColumn(firstRow);
       if (!header) {
         pending.push({ row: firstRow, quoted: firstQuoted, line: firstLine });
       }
@@ -543,11 +589,39 @@ class TableReader {
         pending.push({ row: firstRow, quoted: firstQuoted, line: firstLine });
       }
     }
+    if (this.rowNumbers && !header) {
+      report.warning(
+        "unsupported",
+        OPTION_IGNORED_CODE,
+        "option rowNumberIds ignored: a headerless node table takes its ids from column 0",
+        { line: firstLine, element: "rowNumberIds" }
+      );
+    }
     const names = header ? uniqueNames(headerNames(firstRow), report, firstLine) : positionalNames(firstRow.length);
-    if (this.kind !== "nodes" && this.state.commentDirected === null) {
-      this.state.commentDirected = commentDirection(this.reader.leadingComments);
+    const last = firstRow.length - 1;
+    const optionalLast = header && last > 0 && isUnset(firstRow[last], firstQuoted[last]);
+    this.applyCommentDirection();
+    this.plan = this.resolvePlan(
+      names,
+      header,
+      firstLine,
+      pending.map((p) => p.row),
+      optionalLast
+    );
+    if (optionalLast) {
+      report.warning(
+        "validation-error",
+        TRAILING_HEADER_DELIMITER_CODE,
+        `the header ends in a delimiter; rows without the empty last cell are read as complete`,
+        { line: firstLine, element: names[last] }
+      );
     }
-    this.plan = this.resolvePlan(names, header, firstLine);
+    this.reportCommentLikeRecords(names.length);
+    this.reportSingleColumn(
+      names.length,
+      pending.map((p) => p.row),
+      firstLine
+    );
     this.prepareColumns(firstLine);
     for (const { row, quoted, line } of pending) {
       this.processRow(row, quoted, line);
@@ -573,37 +647,161 @@ class TableReader {
         line: firstLine
       });
     }
+    this.reportReaderFindings();
+  }
+  /**
+   * Whether a row is Excel's delimiter directive (`sep=;`) under a delimiter the caller gave (a
+   * sniffed one comes from the directive itself: `reader.sepDirective`).
+   * @param row - the first row
+   * @returns true for the directive
+   */
+  isSepDirective(row) {
+    return this.state.csv.delimiter !== null && !this.reader.quoted[0] && /^sep=.$/i.test(row.join(this.state.csv.delimiter));
+  }
+  /**
+   * Fail when the input opens like another format (an HTML error page, a JSON, GML, DOT or Pajek
+   * file handed to the CSV importer), which any delimiter would otherwise read as rows of text.
+   * Runs on the raw preview before any record is parsed, so a quoting error in the other
+   * format's syntax cannot abort first.
+   * @param preview - the start of the input, leading comments removed
+   * @param line - the line it starts on
+   */
+  refuseOtherFormat(preview, line) {
+    if (OTHER_FORMATS.some((r) => r.test(preview))) {
+      this.state.report.fail(
+        OTHER_FORMAT_CODE,
+        `the input opens like another format (XML / HTML, JSON, GML, DOT or Pajek), not CSV: ${JSON.stringify(preview.trimStart().slice(0, 60))}`,
+        { line }
+      );
+    }
+  }
+  /**
+   * Whether a column option names a cell of the first row by text.
+   * @param row - the first row
+   * @returns true when sourceColumn, targetColumn, idColumn or typeColumn names one of its cells
+   */
+  namesExplicitColumn(row) {
+    const { csv } = this.state;
+    const names = headerNames(row);
+    return [csv.sourceColumn, csv.targetColumn, csv.idColumn, csv.typeColumn, csv.labelColumn].some(
+      (ref) => typeof ref === "string" && findColumn(names, [ref]) >= 0
+    );
+  }
+  /**
+   * Take the file-level direction from the leading SNAP / KONECT comments of this table: the first
+   * declaring line wins; a later line declaring the other direction, and a declaration that
+   * overrides the caller's explicit defaultDirected, are reported.
+   */
+  applyCommentDirection() {
+    const { state } = this;
+    const { leadingComments, leadingCommentLines } = this.reader;
+    for (let i = 0; i < leadingComments.length; i++) {
+      const comment = leadingComments[i];
+      const directed = commentDirection(comment);
+      if (directed === null) {
+        continue;
+      }
+      const where = { line: leadingCommentLines[i], element: comment };
+      if (state.commentDirected === null) {
+        state.commentDirected = directed;
+        state.commentText = comment;
+        const explicit = state.csv.explicitDirected;
+        if (explicit !== null && explicit !== directed) {
+          state.report.warning(
+            "validation-error",
+            COMMENT_DIRECTION_CODE,
+            `${JSON.stringify(comment)} declares a ${directionName(directed)} graph, which overrides defaultDirected: ${explicit}`,
+            where
+          );
+        }
+      } else if (state.commentDirected !== directed) {
+        state.report.warning(
+          "validation-error",
+          COMMENT_DIRECTION_CODE,
+          `${JSON.stringify(comment)} declares a ${directionName(directed)} graph but ${JSON.stringify(state.commentText)} declared a ${directionName(state.commentDirected)} one; the first applies`,
+          where
+        );
+      }
+    }
+  }
+  /**
+   * Report a leading `#` / `%` line that has the fields of a record (a first id starting with `#`,
+   * swallowed as a comment): its text directly follows the comment character and splits into as
+   * many cells as the table has columns. SNAP and KONECT comment lines put a space after it.
+   * @param width - the number of columns
+   */
+  reportCommentLikeRecords(width) {
+    const { delimiter, leadingComments, leadingCommentLines } = this.reader;
+    if (width < 2 || delimiter === null) {
+      return;
+    }
+    for (let i = 0; i < leadingComments.length; i++) {
+      const comment = leadingComments[i];
+      if (comment.length > 1 && comment[1].trim().length > 0 && comment.split(delimiter).length === width) {
+        this.state.report.warnOnce(
+          "parse-error",
+          COMMENT_LIKE_RECORD_CODE,
+          `${JSON.stringify(comment)} was skipped as a leading comment but has the fields of a record; quote an id that starts with # or %`,
+          { line: leadingCommentLines[i], element: comment }
+        );
+      }
+    }
+  }
+  /**
+   * Report a one-column table whose cells another delimiter would split consistently (a delimiter
+   * option that does not match the file).
+   * @param width - the number of columns
+   * @param rows - the data rows read so far
+   * @param line - the first line
+   */
+  reportSingleColumn(width, rows, line) {
+    if (width !== 1 || rows.length === 0 || this.plan?.kind === "adjacency") {
+      return;
+    }
+    const candidates = DELIMITER_CANDIDATES.filter((d) => d !== this.reader.delimiter);
+    const other = sniffDelimiter(`${rows.map((r) => r[0]).join("\n")}
+`, "\n", candidates);
+    if (other !== null) {
+      this.state.report.warning(
+        "parse-error",
+        SINGLE_COLUMN_CODE,
+        `every row read so far is one cell that ${JSON.stringify(other)} splits consistently; pass delimiter: ${JSON.stringify(other)} if that is the file's delimiter`,
+        { line }
+      );
+    }
+  }
+  /** Report what the record reader noticed while reading: a stray quote. */
+  reportReaderFindings() {
+    const { report } = this.state;
+    const { strayQuoteLine } = this.reader;
+    if (strayQuoteLine > 0) {
+      report.warnOnce(
+        "parse-error",
+        STRAY_QUOTE_CODE,
+        `a quote inside an unquoted field is kept as text (RFC 4180 quotes a whole field)`,
+        { line: strayQuoteLine }
+      );
+    }
   }
   /**
    * Decide the table's columns from its header.
    * @param names - the column names
    * @param header - whether the file has a header row
    * @param line - the header line
+   * @param sample - the data rows read so far
+   * @param optionalLast - whether a row may omit the last cell
    * @returns the plan; the import aborts when no endpoints (or id) resolve
    */
-  resolvePlan(names, header, line) {
-    const { csv, report } = this.state;
+  resolvePlan(names, header, line, sample, optionalLast) {
+    const { csv } = this.state;
     if (this.kind === "adjacency") {
       return { kind: "adjacency", names: [] };
     }
-    const width = names.length;
     let source = -1;
     let target = -1;
     if (this.kind !== "nodes") {
-      if (csv.sourceColumn !== null) {
-        source = resolveColumnRef(names, csv.sourceColumn, "sourceColumn");
-      } else if (header) {
-        source = findColumn(names, SOURCE_NAMES);
-      } else {
-        source = width >= 2 ? 0 : -1;
-      }
-      if (csv.targetColumn !== null) {
-        target = resolveColumnRef(names, csv.targetColumn, "targetColumn");
-      } else if (header) {
-        target = findColumn(names, TARGET_NAMES);
-      } else {
-        target = width >= 2 ? 1 : -1;
-      }
+      source = endpointColumn(names, header, csv.sourceColumn, "sourceColumn", SOURCE_NAMES, 0);
+      target = endpointColumn(names, header, csv.targetColumn, "targetColumn", TARGET_NAMES, 1);
       if (source >= 0 && target >= 0 && source === target) {
         throw new GraphFormatError("E_UNSUPPORTED", "sourceColumn and targetColumn name the same column", {
           option: "targetColumn",
@@ -612,10 +810,33 @@ class TableReader {
       }
     }
     if (source >= 0 && target >= 0) {
-      return this.edgePlan(names, header, source, target);
+      return this.edgePlan(names, header, source, target, line, sample, optionalLast);
     }
+    this.refuseWithoutEndpoints(names, header, source, target, line);
+    return this.nodePlan(names, header, line, optionalLast);
+  }
+  /**
+   * Refuse a table without both endpoint columns, unless it can be a node table: an edge table
+   * was asked for, a single endpoint column was found, or nothing names an id.
+   * @param names - the column names
+   * @param header - whether the file has a header row
+   * @param source - the source column, or -1
+   * @param target - the target column, or -1
+   * @param line - the header line
+   */
+  refuseWithoutEndpoints(names, header, source, target, line) {
+    const { csv, report } = this.state;
     const shown = names.map((n) => JSON.stringify(n)).join(", ");
-    if (this.kind === "edges" || this.kind === "auto" && (csv.sourceColumn !== null || csv.targetColumn !== null)) {
+    if (source >= 0 || target >= 0) {
+      const [has, missing] = source >= 0 ? ["source", "target"] : ["target", "source"];
+      report.fail(
+        NO_ENDPOINT_COLUMNS_CODE,
+        `the header has a ${has} column (${JSON.stringify(names[Math.max(source, target)])}) but no ${missing} column (${shown})`,
+        { line },
+        { columns: [...names] }
+      );
+    }
+    if (this.kind === "edges" || this.kind === "auto" && (csv.sourceColumn !== null || csv.targetColumn !== null || csv.nodes !== null)) {
       report.fail(
         NO_ENDPOINT_COLUMNS_CODE,
         `no source / target columns in the header (${shown}); a node table goes in the nodes option`,
@@ -623,7 +844,7 @@ class TableReader {
         { columns: [...names] }
       );
     }
-    const idResolves = header ? findColumn(names, ID_NAMES) >= 0 : width >= 1;
+    const idResolves = header ? findColumn(names, ID_NAMES) >= 0 : names.length >= 1;
     if (this.kind === "auto" && csv.idColumn === null && !idResolves && !this.rowNumbers) {
       report.fail(
         NO_ENDPOINT_COLUMNS_CODE,
@@ -632,7 +853,6 @@ class TableReader {
         { columns: [...names] }
       );
     }
-    return this.nodePlan(names, header, line);
   }
   /**
    * The columns of an edge table.
@@ -640,50 +860,26 @@ class TableReader {
    * @param header - whether the file has a header row
    * @param source - the source column
    * @param target - the target column
+   * @param line - the header (or first) line
+   * @param sample - the data rows read so far
+   * @param optionalLast - whether a row may omit the last cell
    * @returns the plan
    */
-  edgePlan(names, header, source, target) {
-    const { csv, common, report } = this.state;
+  edgePlan(names, header, source, target, line, sample, optionalLast) {
+    const { csv } = this.state;
     const claimed = /* @__PURE__ */ new Set([source, target]);
-    let weight = -1;
-    if (common.weightFrom !== null) {
-      if (header) {
-        weight = findFree(names, [common.weightFrom], claimed);
-        if (weight < 0 && this.state.weightFromExplicit) {
-          report.warning(
-            "missing-value",
-            COLUMN_MISSING_CODE,
-            `weight column ${JSON.stringify(common.weightFrom)} not found; edges are unweighted`,
-            { line: this.reader.line, element: common.weightFrom }
-          );
-        }
-      } else if (names.length >= 3 && !claimed.has(2)) {
-        weight = 2;
-      }
-    }
+    const weight = this.weightColumn(names, header, claimed, line, sample);
     if (weight >= 0) {
       claimed.add(weight);
     }
-    let type = -1;
-    if (csv.typeColumn === void 0) {
-      if (header && names[source] === "Source" && names[target] === "Target") {
-        type = findFree(names, [TYPE_NAME], claimed);
-        if (type >= 0 && names[type] !== TYPE_NAME) {
-          type = -1;
-        }
-      }
-    } else if (csv.typeColumn !== null) {
-      type = resolveColumnRef(names, csv.typeColumn, "typeColumn");
-      if (claimed.has(type)) {
-        throw new GraphFormatError("E_UNSUPPORTED", "typeColumn names an endpoint or weight column", {
-          option: "typeColumn",
-          found: names[type]
-        });
-      }
+    if (header) {
+      this.reportEndpointRivals(names, source, target, weight, line);
     }
+    const type = this.typeColumn(names, header, source, target, claimed);
     if (type >= 0) {
       claimed.add(type);
     }
+    const typeHint = header && type < 0 && csv.typeColumn === void 0 ? findFree(names, [TYPE_NAME], claimed) : -1;
     const id = header ? findFree(names, EDGE_ID_NAMES, claimed) : -1;
     if (id >= 0) {
       claimed.add(id);
@@ -698,56 +894,162 @@ class TableReader {
         attributes.push(i);
       }
     }
-    return { kind: "edges", names, width: names.length, source, target, weight, type, id, label, attributes };
+    return {
+      kind: "edges",
+      names,
+      width: names.length,
+      source,
+      target,
+      weight,
+      type,
+      typeHint,
+      id,
+      label,
+      attributes,
+      optionalLast
+    };
+  }
+  /**
+   * The weight column of an edge table: the weightFrom column of a header (a warning when it was
+   * asked for and is missing), else the third column of a headerless edge list unless it holds text.
+   * @param names - the column names
+   * @param header - whether the file has a header row
+   * @param claimed - the endpoint columns
+   * @param line - the header (or first) line
+   * @param sample - the data rows read so far
+   * @returns the column index, or -1
+   */
+  weightColumn(names, header, claimed, line, sample) {
+    const { common, report } = this.state;
+    if (common.weightFrom === null) {
+      return -1;
+    }
+    if (header) {
+      const weight = findFree(names, [common.weightFrom], claimed);
+      if (weight < 0 && this.state.weightFromExplicit) {
+        report.warning(
+          "missing-value",
+          COLUMN_MISSING_CODE,
+          `weight column ${JSON.stringify(common.weightFrom)} not found; edges are unweighted`,
+          { line, element: common.weightFrom }
+        );
+      }
+      return weight;
+    }
+    if (names.length < 3 || claimed.has(2)) {
+      return -1;
+    }
+    if (isTextTriple(names.length, sample)) {
+      report.warnOnce(
+        "validation-error",
+        WEIGHT_AS_ATTRIBUTE_CODE,
+        `the third column holds text in the first rows, so it is read as the attribute ${names[2]}, not the weight`,
+        { line, element: names[2] }
+      );
+      return -1;
+    }
+    return 2;
+  }
+  /**
+   * Warn about header columns that name the source, target or weight beside the chosen one.
+   * @param names - the header names
+   * @param source - the source column
+   * @param target - the target column
+   * @param weight - the weight column, or -1
+   * @param line - the header line
+   */
+  reportEndpointRivals(names, source, target, weight, line) {
+    const { csv, common } = this.state;
+    if (csv.sourceColumn === null) {
+      this.reportRivals(names, SOURCE_NAMES, source, "source", line);
+    }
+    if (csv.targetColumn === null) {
+      this.reportRivals(names, TARGET_NAMES, target, "target", line);
+    }
+    if (weight >= 0 && common.weightFrom !== null) {
+      this.reportRivals(names, [common.weightFrom], weight, "weight", line);
+    }
+  }
+  /**
+   * The edge type column: the typeColumn option, else Gephi's `Type` beside `Source` and `Target`.
+   * @param names - the column names
+   * @param header - whether the file has a header row
+   * @param source - the source column
+   * @param target - the target column
+   * @param claimed - the columns other roles took
+   * @returns the column index, or -1
+   */
+  typeColumn(names, header, source, target, claimed) {
+    const { typeColumn } = this.state.csv;
+    if (typeColumn === null) {
+      return -1;
+    }
+    if (typeColumn === void 0) {
+      const gephi = header && names[source] === "Source" && names[target] === "Target";
+      const type2 = gephi ? findFree(names, [TYPE_NAME], claimed) : -1;
+      return type2 >= 0 && names[type2] === TYPE_NAME ? type2 : -1;
+    }
+    const type = resolveColumnRef(names, typeColumn, "typeColumn");
+    if (claimed.has(type)) {
+      throw new GraphFormatError("E_UNSUPPORTED", "typeColumn names an endpoint or weight column", {
+        option: "typeColumn",
+        found: names[type]
+      });
+    }
+    return type;
+  }
+  /**
+   * Warn about header columns that name a role another column was chosen for (`Source,source`,
+   * `from,to,source`, `Weight,weight`): the one not chosen is read as a plain attribute.
+   * @param names - the header names
+   * @param candidates - the names of the role
+   * @param chosen - the column chosen
+   * @param role - the role, for the message
+   * @param line - the header line
+   */
+  reportRivals(names, candidates, chosen, role, line) {
+    const lower2 = new Set(candidates.map((c) => c.toLowerCase()));
+    names.forEach((name, i) => {
+      if (i !== chosen && lower2.has(name.toLowerCase())) {
+        this.state.report.warning(
+          "validation-error",
+          AMBIGUOUS_COLUMN_CODE,
+          `columns ${JSON.stringify(names[chosen])} and ${JSON.stringify(name)} both name the ${role}; ${JSON.stringify(names[chosen])} is used and ${JSON.stringify(name)} is a plain attribute`,
+          { line, element: name }
+        );
+      }
+    });
+  }
+  /**
+   * The label column of a node table: the labelColumn option, else a header column named `label`.
+   * @param names - the column names
+   * @param header - whether the file has a header row
+   * @param claimed - columns another role took
+   * @returns the column index, or -1
+   */
+  labelOf(names, header, claimed) {
+    const { labelColumn } = this.state.csv;
+    if (labelColumn !== null) {
+      return resolveColumnRef(names, labelColumn, "labelColumn");
+    }
+    return header ? findFree(names, LABEL_NAMES, claimed) : -1;
   }
   /**
    * The columns of a node table.
    * @param names - the column names
    * @param header - whether the file has a header row
    * @param line - the header line
+   * @param optionalLast - whether a row may omit the last cell
    * @returns the plan; the import aborts when no id column resolves
    */
-  nodePlan(names, header, line) {
-    const { csv, common, report } = this.state;
+  nodePlan(names, header, line, optionalLast) {
+    const { common } = this.state;
     const claimed = /* @__PURE__ */ new Set();
-    let idColumn = -1;
-    if (csv.idColumn !== null) {
-      idColumn = resolveColumnRef(names, csv.idColumn, "idColumn");
-    } else if (header) {
-      idColumn = findColumn(names, ID_NAMES);
-    } else if (names.length >= 1) {
-      idColumn = 0;
-    }
-    const label = header ? findFree(names, LABEL_NAMES, new Set(idColumn >= 0 ? [idColumn] : [])) : -1;
-    let id;
-    switch (common.nodeIdFrom) {
-      case "label":
-        if (label < 0) {
-          report.fail(NO_ID_COLUMN_CODE, 'nodeIdFrom is "label" but the node table has no label column', {
-            line
-          });
-        }
-        id = label;
-        break;
-      case "index":
-        id = -1;
-        break;
-      default:
-        if (idColumn < 0 && this.rowNumbers) {
-          id = -1;
-          break;
-        }
-        if (idColumn < 0) {
-          report.fail(
-            NO_ID_COLUMN_CODE,
-            `no id column in the node table header (${names.map((n) => JSON.stringify(n)).join(", ")})`,
-            { line },
-            { columns: [...names] }
-          );
-        }
-        id = idColumn;
-        claimed.add(idColumn);
-        break;
+    const idColumn = this.idColumnOf(names, header);
+    const label = this.labelOf(names, header, new Set(idColumn >= 0 ? [idColumn] : []));
+    const id = this.nodeIdColumn(names, idColumn, label, line);
+    if (id >= 0) {
+      claimed.add(id);
     }
     if (label >= 0) {
       claimed.add(label);
@@ -759,7 +1061,60 @@ class TableReader {
       }
     }
     const rowNumber = id < 0 && common.nodeIdFrom !== "index";
-    return { kind: "nodes", names, width: names.length, id, rowNumber, label, attributes };
+    return { kind: "nodes", names, width: names.length, id, rowNumber, label, attributes, optionalLast };
+  }
+  /**
+   * The id column of a node table: the idColumn option, else a header column with an id name,
+   * else the first column of a headerless table.
+   * @param names - the column names
+   * @param header - whether the file has a header row
+   * @returns the column index, or -1
+   */
+  idColumnOf(names, header) {
+    const { idColumn } = this.state.csv;
+    if (idColumn !== null) {
+      return resolveColumnRef(names, idColumn, "idColumn");
+    }
+    if (header) {
+      return findColumn(names, ID_NAMES);
+    }
+    return names.length >= 1 ? 0 : -1;
+  }
+  /**
+   * The column node ids come from, as nodeIdFrom says: the label, none (row numbers), or the id
+   * column. The import aborts when that column is missing.
+   * @param names - the column names
+   * @param idColumn - the id column, or -1
+   * @param label - the label column, or -1
+   * @param line - the header line
+   * @returns the column index, or -1 for row numbers
+   */
+  nodeIdColumn(names, idColumn, label, line) {
+    const { common, report } = this.state;
+    const shown = names.map((n) => JSON.stringify(n)).join(", ");
+    if (common.nodeIdFrom === "index") {
+      return -1;
+    }
+    if (common.nodeIdFrom === "label") {
+      if (label < 0) {
+        report.fail(
+          NO_ID_COLUMN_CODE,
+          `nodeIdFrom is "label", but the node table has no column named "label" (${shown}); pass labelColumn to name the column that holds the labels`,
+          { line },
+          { columns: [...names] }
+        );
+      }
+      return label;
+    }
+    if (idColumn < 0 && !this.rowNumbers) {
+      report.fail(
+        NO_ID_COLUMN_CODE,
+        `no id column in the node table header (${shown})`,
+        { line },
+        { columns: [...names] }
+      );
+    }
+    return idColumn;
   }
   /**
    * Declare the role columns and create a writer per attribute column.
@@ -817,6 +1172,13 @@ class TableReader {
   processRow(row, quoted, line) {
     const plan = this.requirePlan();
     this.dataRows++;
+    if (this.state.csv.decimalComma) {
+      for (let i = 0; i < row.length; i++) {
+        if (DECIMAL_COMMA.test(row[i])) {
+          row[i] = row[i].replace(",", ".");
+        }
+      }
+    }
     if (plan.kind === "edges") {
       this.processEdgeRow(plan, row, quoted, line);
     } else if (plan.kind === "nodes") {
@@ -826,7 +1188,7 @@ class TableReader {
     }
   }
   /**
-   * Push one adjacency row: the node, then one edge per set neighbour cell, in row order.
+   * Push one adjacency row: the node, then one edge per set neighbor cell, in row order.
    * @param row - the cells
    * @param quoted - whether each cell was quoted
    * @param line - the row's line
@@ -837,16 +1199,16 @@ class TableReader {
     const { where } = this;
     where.line = line;
     where.element = null;
-    let neighbours = 0;
+    let neighbors = 0;
     for (let k = 1; k < row.length; k++) {
       if (!isUnset(row[k], quoted[k])) {
-        neighbours++;
+        neighbors++;
       }
     }
     if (isUnset(row[0], quoted[0])) {
-      report.error("missing-value", MISSING_ID_CODE, `line ${line}: blank node cell`, { line });
+      report.error("missing-value", MISSING_ID_CODE, `blank node cell`, { line });
       counts.skippedNodes++;
-      counts.skippedEdges += neighbours;
+      counts.skippedEdges += neighbors;
       return;
     }
     const kind = this.state.commentDirected ?? common.defaultDirected ? "directed" : "undirected";
@@ -865,7 +1227,7 @@ class TableReader {
     } catch (err) {
       report.recordError(err, where);
       counts.skippedNodes++;
-      counts.skippedEdges += neighbours;
+      counts.skippedEdges += neighbors;
       return;
     }
     for (let k = 1; k < row.length; k++) {
@@ -891,19 +1253,15 @@ class TableReader {
    * Push one edge row: endpoints, weight, direction, then the attribute cells.
    * @param plan - the edge plan
    * @param row - the cells
-   * @param quoted - whether each cell was quoted
+   * @param cellQuoted - whether each cell was quoted
    * @param line - the row's line
    */
-  processEdgeRow(plan, row, quoted, line) {
-    const { report, sink, resolver, common } = this.state;
+  processEdgeRow(plan, row, cellQuoted, line) {
+    const { report } = this.state;
     const { counts } = report;
+    const quoted = completeRow(plan, row, cellQuoted, report, line);
     if (row.length !== plan.width) {
-      report.error(
-        "validation-error",
-        FIELD_COUNT_CODE,
-        `line ${line}: ${row.length} field(s), the header has ${plan.width}`,
-        { line }
-      );
+      this.reportRowWidth(plan, row, line);
       counts.skippedEdges++;
       return;
     }
@@ -911,64 +1269,36 @@ class TableReader {
     const targetText = row[plan.target];
     const sourceMissing = isUnset(sourceText, quoted[plan.source]);
     if (sourceMissing || isUnset(targetText, quoted[plan.target])) {
-      report.error(
-        "missing-value",
-        MISSING_ENDPOINT_CODE,
-        `line ${line}: blank ${sourceMissing ? "source" : "target"} cell`,
-        { line }
-      );
+      report.error("missing-value", MISSING_ENDPOINT_CODE, `blank ${sourceMissing ? "source" : "target"} cell`, {
+        line
+      });
       counts.skippedEdges++;
       return;
     }
-    let kind = this.state.commentDirected ?? common.defaultDirected ? "directed" : "undirected";
-    if (plan.type >= 0) {
-      const parsed = parseKind(row[plan.type]);
-      if (parsed === null) {
-        report.error(
-          "validation-error",
-          BAD_TYPE_CODE,
-          `line ${line}: Type ${JSON.stringify(row[plan.type])} is not Directed, Undirected or Mutual`,
-          { line }
-        );
-        counts.skippedEdges++;
-        return;
-      }
-      if (parsed !== void 0) {
-        kind = parsed;
-      }
+    const kind = this.rowKind(plan, row, line);
+    if (kind === null) {
+      counts.skippedEdges++;
+      return;
     }
     const { where } = this;
     where.line = line;
     where.element = null;
     const idText = plan.id >= 0 && !isUnset(row[plan.id], quoted[plan.id]) ? row[plan.id] : null;
-    if (idText !== null) {
-      if (this.edgeIds.has(idText)) {
-        report.error(
-          "validation-error",
-          DUPLICATE_EDGE_ID_CODE,
-          `line ${line}: edge id ${JSON.stringify(idText)} repeats an earlier row's; the row is skipped`,
-          { line, element: idText }
-        );
-        counts.skippedEdges++;
-        return;
-      }
-      this.edgeIds.add(idText);
+    if (idText !== null && this.edgeIds.has(idText)) {
+      report.error(
+        "validation-error",
+        DUPLICATE_EDGE_ID_CODE,
+        `edge id ${JSON.stringify(idText)} repeats an earlier row's; the row is skipped`,
+        { line, element: idText }
+      );
+      counts.skippedEdges++;
+      return;
     }
+    this.checkPadded(sourceText, quoted[plan.source], line);
+    this.checkPadded(targetText, quoted[plan.target], line);
     let edge;
     try {
-      const source = this.coerce(sourceText);
-      const target = this.coerce(targetText);
-      const weight = plan.weight >= 0 ? parseWeightText(row[plan.weight]) : void 0;
-      if (!this.state.headerSet) {
-        this.state.headerSet = true;
-        resolver.setHeader(kind !== "undirected", where);
-      }
-      const sourceNew = sink.indexOf(source) === INVALID_INDEX;
-      const targetNew = source !== target && sink.indexOf(target) === INVALID_INDEX;
-      const before = sink.edgeCount;
-      edge = resolver.addEdge(source, target, kind, weight, where);
-      counts.edges += sink.edgeCount - before;
-      counts.nodes += (sourceNew ? 1 : 0) + (targetNew ? 1 : 0);
+      edge = this.addEdge(sourceText, targetText, kind, plan.weight >= 0 ? row[plan.weight] : null);
     } catch (err) {
       where.element = idText ?? `${sourceText}->${targetText}`;
       report.recordError(err, where);
@@ -976,40 +1306,133 @@ class TableReader {
       return;
     }
     if (idText !== null) {
+      this.edgeIds.add(idText);
       this.writeRole(this.idHandle, "edge", edge, idText, plan.names[plan.id], line);
     }
+    this.warnTypeHint(plan, row, line);
     if (plan.label >= 0 && !isUnset(row[plan.label], quoted[plan.label])) {
       this.writeRole(this.labelHandle, "edge", edge, row[plan.label], plan.names[plan.label], line);
     }
     this.writeAttributes(plan, row, quoted, edge, line);
   }
+  /**
+   * Warn, once, when a column that is not the type column holds a direction word.
+   * @param plan - the edge plan
+   * @param row - the cells
+   * @param line - the row's line
+   */
+  warnTypeHint(plan, row, line) {
+    if (plan.typeHint < 0 || typeof parseKind(row[plan.typeHint]) !== "string") {
+      return;
+    }
+    this.state.report.warnOnce(
+      "unsupported",
+      TYPE_COLUMN_IGNORED_CODE,
+      `column ${JSON.stringify(plan.names[plan.typeHint])} holds the direction word ${JSON.stringify(row[plan.typeHint])} but is a plain attribute; the per-row direction is read from an exact "Type" column beside "Source" and "Target", or from the typeColumn option`,
+      { line, element: plan.names[plan.typeHint] }
+    );
+  }
+  /**
+   * Report a row with the wrong number of cells. The first row too long for an auto table says
+   * what an adjacency list needs, since one reads this way.
+   * @param plan - the edge plan
+   * @param row - the cells
+   * @param line - the row's line
+   */
+  reportRowWidth(plan, row, line) {
+    const hint = this.state.csv.table === "auto" && row.length > plan.width && !this.adjacencyHinted ? '; if each line is a node followed by its neighbors, pass table: "adjacency"' : "";
+    this.adjacencyHinted ||= hint !== "";
+    this.state.report.error(
+      "validation-error",
+      FIELD_COUNT_CODE,
+      `${row.length} field${plural(row.length)}, expected ${plan.width}${hint}`,
+      { line }
+    );
+  }
+  /**
+   * The direction of an edge row: its Type cell, else the file's or the default direction.
+   * @param plan - the edge plan
+   * @param row - the cells
+   * @param line - the row's line
+   * @returns the kind, or null when the Type cell is not a direction (reported)
+   */
+  rowKind(plan, row, line) {
+    const directed = this.state.commentDirected ?? this.state.common.defaultDirected;
+    const kind = directed ? "directed" : "undirected";
+    if (plan.type < 0) {
+      return kind;
+    }
+    const parsed = parseKind(row[plan.type]);
+    if (parsed === null) {
+      this.state.report.error(
+        "validation-error",
+        BAD_TYPE_CODE,
+        `Type ${JSON.stringify(row[plan.type])} is not Directed, Undirected or Mutual`,
+        { line }
+      );
+      return null;
+    }
+    return parsed ?? kind;
+  }
+  /**
+   * Add an edge row's edge, counting the edge and the nodes it brings in.
+   * @param sourceText - the source cell
+   * @param targetText - the target cell
+   * @param kind - the direction
+   * @param weightText - the weight cell, or null
+   * @returns the edge's index
+   */
+  addEdge(sourceText, targetText, kind, weightText) {
+    const { report, sink, resolver } = this.state;
+    const { where } = this;
+    const source = this.coerce(sourceText);
+    const target = this.coerce(targetText);
+    const weight = weightText === null ? void 0 : parseWeightText(weightText, report);
+    if (!this.state.headerSet) {
+      this.state.headerSet = true;
+      resolver.setHeader(kind !== "undirected", where);
+    }
+    const sourceNew = sink.indexOf(source) === INVALID_INDEX;
+    const targetNew = source !== target && sink.indexOf(target) === INVALID_INDEX;
+    const before = sink.edgeCount;
+    const edge = resolver.addEdge(source, target, kind, weight, where);
+    report.counts.edges += sink.edgeCount - before;
+    report.counts.nodes += (sourceNew ? 1 : 0) + (targetNew ? 1 : 0);
+    return edge;
+  }
   /**
    * Push one node row: the id, then the label and attribute cells.
    * @param plan - the node plan
    * @param row - the cells
-   * @param quoted - whether each cell was quoted
+   * @param cellQuoted - whether each cell was quoted
    * @param line - the row's line
    */
-  processNodeRow(plan, row, quoted, line) {
+  processNodeRow(plan, row, cellQuoted, line) {
     const { report, sink } = this.state;
     const { counts } = report;
     const ordinal = this.nodeOrdinal++;
+    const quoted = completeRow(plan, row, cellQuoted, report, line);
     if (row.length !== plan.width) {
       report.error(
         "validation-error",
         FIELD_COUNT_CODE,
-        `line ${line}: ${row.length} field(s), the header has ${plan.width}`,
-        { line }
+        `${row.length} field${plural(row.length)}, expected ${plan.width}`,
+        {
+          line
+        }
       );
       counts.skippedNodes++;
       return;
     }
     const idText = plan.id >= 0 ? row[plan.id] : String(ordinal);
     if (plan.id >= 0 && isUnset(idText, quoted[plan.id])) {
-      report.error("missing-value", MISSING_ID_CODE, `line ${line}: blank id cell`, { line });
+      report.error("missing-value", MISSING_ID_CODE, `blank id cell`, { line });
       counts.skippedNodes++;
       return;
     }
+    if (plan.id >= 0) {
+      this.checkPadded(idText, quoted[plan.id], line);
+    }
     const { where } = this;
     where.line = line;
     where.element = idText;
@@ -1020,7 +1443,7 @@ class TableReader {
         report.warning(
           "merged",
           DUPLICATE_NODE_CODE,
-          `line ${line}: node ${JSON.stringify(id)} already exists; its attributes are overwritten`,
+          `node ${JSON.stringify(id)} already exists; its attributes are overwritten`,
           where
         );
       } else {
@@ -1037,6 +1460,23 @@ class TableReader {
     }
     this.writeAttributes(plan, row, quoted, index, line);
   }
+  /**
+   * Warn once per import about an unquoted id cell with leading or trailing whitespace, which is
+   * a different id from the bare text (RFC 4180 keeps spaces).
+   * @param text - the cell text
+   * @param quoted - whether the cell was quoted
+   * @param line - the row's line
+   */
+  checkPadded(text, quoted, line) {
+    if (isPadded(text, quoted)) {
+      this.state.report.warnOnce(
+        "validation-error",
+        PADDED_ID_CODE,
+        `id ${JSON.stringify(text)} has leading or trailing whitespace and is kept as written, a different id from the trimmed text`,
+        { line, element: text }
+      );
+    }
+  }
   /**
    * Coerce an id cell, reporting a merge under `ids: "number"`.
    * @param text - the cell text
@@ -1102,29 +1542,104 @@ class TableReader {
     }
   }
 }
+function isTextTriple(width, sample) {
+  return width === 3 && sample.length > 0 && sample.every((row) => row.length === 3 && !isBlank(row[2]) && numberOrNull(row[2]) === null);
+}
+function hasExplicitDialect(csv) {
+  return csv.delimiter !== null || csv.header !== "auto" || csv.table !== "auto" || csv.sourceColumn !== null || csv.targetColumn !== null || csv.idColumn !== null || csv.typeColumn !== void 0 && csv.typeColumn !== null;
+}
+function completeRow(plan, row, quoted, report, line) {
+  if (row.length === plan.width + 1 && isUnset(row[plan.width], quoted[plan.width])) {
+    row.pop();
+    report.warnOnce(
+      "validation-error",
+      TRAILING_DELIMITER_CODE,
+      `the row ends in a delimiter the header does not have; the empty last cell is dropped`,
+      { line }
+    );
+    return quoted;
+  }
+  if (!plan.optionalLast || row.length !== plan.width - 1) {
+    return quoted;
+  }
+  const flags = quoted.slice(0, row.length);
+  row.push("");
+  flags.push(false);
+  return flags;
+}
 const HEAD_BYTES = 4096;
-const OTHER_FORMAT = /^\s*(<|[[{]|(strict\s+)?(di)?graph(\s+\S+)?\s*\{|\*vertices|creator\b|graph\s*\[)/i;
+function endpointColumn(names, header, option, optionName, known, position) {
+  if (option !== null) {
+    return resolveColumnRef(names, option, optionName);
+  }
+  if (header) {
+    return findColumn(names, known);
+  }
+  return names.length >= 2 ? position : -1;
+}
+const TAG_NAME = String.raw`<[a-z_][\w.-]*(?::[a-z_][\w.-]*)?`;
+const OTHER_FORMATS = [
+  /^\s*<(?:\?xml|!doctype|!--)/i,
+  // an XML declaration, a doctype or a comment
+  new RegExp(String.raw`^\s*${TAG_NAME}\s*\/?>\s*(?:[^,;|\s]*<|$)`, "i"),
+  // a tag, then another tag
+  new RegExp(String.raw`^\s*${TAG_NAME}\s+[a-z_][\w.:-]*\s*=`, "i"),
+  // a tag with an attribute
+  /^\s*\/[*/]/,
+  // a C comment (DOT)
+  /^\s*\{\s*(?:["}]|$)/,
+  // a JSON object
+  /^\s*\[\s*(?:[[{"\]\d-]|$)/,
+  // a JSON array
+  /^\s*(?:strict\s+)?(?:di)?graph(?:\s+\S+)?\s*\{/i,
+  // a DOT graph
+  /^\s*\*(?:vertices|network|arcs|edges)\b/i,
+  // a Pajek section
+  /^\s*(?:creator\s+"|graph\s*\[)/i
+  // GML
+];
 function sniff(head) {
-  const text = new TextDecoder("utf-8").decode(head.subarray(0, HEAD_BYTES));
-  const body = text.startsWith(String.fromCharCode(65279)) ? text.slice(1) : text;
-  if (body.trim().length === 0 || OTHER_FORMAT.test(body)) {
+  let label = "utf-8";
+  if (head[0] === 255 && head[1] === 254) {
+    label = "utf-16le";
+  } else if (head[0] === 254 && head[1] === 255) {
+    label = "utf-16be";
+  }
+  const body = stripLeadingComments(new TextDecoder(label).decode(head.subarray(0, HEAD_BYTES)), COMMENT_CHARS);
+  if (body.trim().length === 0 || OTHER_FORMATS.some((r) => r.test(body))) {
     return 0;
   }
   const newline = sniffNewline(body);
-  const delimiter = sniffDelimiter(body, newline);
+  const delimiter = sniffDelimiter(body, newline, DELIMITER_CANDIDATES, '"', false, true);
   if (delimiter === null) {
-    return 0;
+    const first = body.split(newline, 1)[0];
+    return DELIMITER_CANDIDATES.some((d) => hasEndpointHeader(first, d)) ? 0.9 : 0;
   }
-  const end = body.indexOf(newline);
-  const firstLine = end < 0 ? body : body.slice(0, end);
-  const names = headerNames(firstLine.replace(/\r$/, "").split(delimiter));
+  const records = splitRecords(body, delimiter, '"', 2, false, true) ?? [];
+  const names = headerNames(records[0] ?? []);
   if (findColumn(names, SOURCE_NAMES) >= 0 && findColumn(names, TARGET_NAMES) >= 0) {
     return 0.9;
   }
-  if (findColumn(names, ID_NAMES) >= 0) {
+  if (delimiter !== " " && findColumn(names, ID_NAMES) >= 0) {
     return 0.6;
   }
-  return 0.3;
+  if (delimiter === " " && names.length > 3) {
+    return 0;
+  }
+  return looksLikeProse(body, newline, delimiter) ? 0 : 0.3;
+}
+const SENTENCE = /[A-Za-z]{2}[.!?](?:\s|$)/;
+function looksLikeProse(body, newline, delimiter) {
+  const lines2 = body.split(newline).filter((l) => l.trim() !== "");
+  if (lines2.length < 2) {
+    return true;
+  }
+  const rows = splitRecords(body, delimiter, '"', 8, false, true) ?? [];
+  return rows.some((row) => row.some((cell) => /\S\s+\S/.test(cell.trim()) && SENTENCE.test(cell.trim())));
+}
+function hasEndpointHeader(line, delimiter) {
+  const names = headerNames(splitRecords(line, delimiter, '"', 1, false, true)?.[0] ?? []);
+  return names.length > 1 && findColumn(names, SOURCE_NAMES) >= 0 && findColumn(names, TARGET_NAMES) >= 0;
 }
 async function importCsv(input, sink, options) {
   const common = resolveImportOptions(options, { ids: "canonical", defaultDirected: true, weightFrom: "weight" });
@@ -1145,7 +1660,8 @@ async function importCsv(input, sink, options) {
     coercer: new IdCoercer(common.ids),
     resolver: new DirectionResolver(sink, report, common.onMixedDirection),
     headerSet: false,
-    commentDirected: null
+    commentDirected: null,
+    commentText: ""
   };
   if (csv.nodes !== null) {
     await new TableReader(state, csv.nodes, "nodes", false).read();
@@ -1155,7 +1671,7 @@ async function importCsv(input, sink, options) {
     report.warning(
       "coercion",
       ID_MERGED_CODE,
-      `${state.coercer.mergeCount} id cell(s) merged into ids other cells already produced under ids: "number"`
+      `${state.coercer.mergeCount} id cell${plural(state.coercer.mergeCount)} merged into ids other cells already produced under ids: "number"`
     );
   }
   throwIfAborted(common.signal);
@@ -1163,15 +1679,39 @@ async function importCsv(input, sink, options) {
 }
 const csvImporter = Object.freeze({
   format: "csv",
+  options: Object.freeze([
+    "decimal",
+    "delimiter",
+    "header",
+    "idColumn",
+    "labelColumn",
+    "nodes",
+    "rowNumberIds",
+    "sourceColumn",
+    "table",
+    "targetColumn",
+    "typeColumn"
+  ]),
   extensions: Object.freeze([".csv", ".tsv", ".edges", ".edgelist"]),
   mimeTypes: Object.freeze(["text/csv", "text/tab-separated-values", "text/plain"]),
   sniff,
   import: importCsv
 });
+function nodesInput(value) {
+  if (value === void 0) {
+    return null;
+  }
+  const object = value;
+  const blob = typeof value === "object" && typeof object.stream === "function" && typeof object.size === "number";
+  return blob ? value.stream() : value;
+}
 const CSV_LOSS = Object.freeze({
-  /** Two node ids share one text (a number and a string); export() throws E_INVALID_ID. */
+  /**
+   * 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: LOSS.ID_TEXT_COLLISION,
-  /** Ids whose text reads back as the other type under the canonical rule. */
+  /** Ids that read back as a different type, such as the text "7" as the number 7. */
   ID_TEXT_TYPE: LOSS.ID_TEXT_TYPE,
   /**
    * The generic dialect has no direction column; an undirected or mixed graph reads back as
@@ -1183,26 +1723,48 @@ const CSV_LOSS = Object.freeze({
   MUTUAL_EXPANDED: LOSS.MUTUAL_EXPANDED,
   /** An attribute column named like a reserved header is not written. */
   RESERVED_NAME: "W_CSV_RESERVED_NAME",
-  /** A column without a role that the importer gives one back by its name. */
+  /**
+   * An attribute without a role is written where the format keeps a role (for example, a `name` column as the label), and
+   * reads back with that role.
+   */
   ROLE_ASSUMED: LOSS.ROLE_ASSUMED,
-  /** A role column (id, label) whose name the importer does not recognise; the role is lost. */
+  /** A role column (id, label) whose name the importer does not recognize; the role is lost. */
   ROLE_NAME: "W_CSV_ROLE_NAME",
-  /** A role column (id, label) that is not string / dict reads back as string. */
+  /** An id or label attribute that is not text reads back as text. */
   TEXT_ROLE: "W_CSV_TEXT_ROLE",
   /** NaN / Infinity in a numeric column read back as text. */
   NONFINITE: "W_CSV_NONFINITE",
-  /** A text column whose every value reads back as a number or boolean. */
+  /**
+   * A text value that reads back as a number or a boolean, because the format does not record that it was text (the
+   * text "42" reads back as the number 42).
+   */
   TEXT_INFERRED: LOSS.TEXT_INFERRED,
-  /** A dict column whose cardinality makes the importer read it back as string, or the reverse. */
+  /**
+   * A text attribute reads back as a dictionary attribute, or the reverse, because the importer chooses by how often
+   * its values repeat. The values are the same.
+   */
   STORAGE_CLASS_CHANGED: LOSS.STORAGE_CLASS,
   /** Node attributes are written by a `table: "nodes"` export only. */
   NODE_TABLE: "W_CSV_NODE_TABLE",
-  /** The edge table carries no node without an edge: isolated nodes vanish on re-import. */
+  /**
+   * The edge table has no row for a node without edges, so isolated nodes are missing when the file is read back.
+   * Write the node table too (`table: "nodes"`).
+   */
   ISOLATED_NODES: "W_CSV_ISOLATED_NODES",
-  /** The edge table lists nodes by first appearance; the node order (and indices) change on re-import. */
+  /**
+   * The edge table lists nodes in the order they first appear in an edge, so the node order changes when the file is
+   * read back.
+   */
   NODE_ORDER: "W_CSV_NODE_ORDER",
   /** An adjacency table holds no edge column but the weight: edge ids, labels and attributes are not written. */
-  EDGE_COLUMNS: "W_CSV_EDGE_COLUMNS"
+  EDGE_COLUMNS: "W_CSV_EDGE_COLUMNS",
+  /**
+   * `header: false` with columns a file without a header cannot name: graph-io reads such a file by position
+   * (source, target, weight, then columns it names column4, column5, ...), so these columns read back under other
+   * names or in the wrong place (for example, an edge id in the weight's place). Write the header, or write only source,
+   * target and weight with `dialect: "generic"`.
+   */
+  HEADERLESS: "W_CSV_HEADERLESS"
 });
 const CSV_CAPABILITIES = capabilities({
   mixedDirection: true,
@@ -1240,7 +1802,7 @@ const SKIPPED_ROLES = /* @__PURE__ */ new Set([
 ]);
 function resolveCsvExportOptions(options) {
   const o = options ?? {};
-  if (o.dialect !== void 0 && o.dialect !== "gephi" && o.dialect !== "generic") {
+  if (o.dialect !== void 0 && o.dialect !== "gephi" && o.dialect !== "generic" && !otherFormatDialect("csv", o.dialect)) {
     throw new GraphFormatError("E_UNSUPPORTED", 'option dialect: expected "gephi" or "generic"', {
       option: "dialect",
       found: o.dialect
@@ -1278,7 +1840,8 @@ function resolveCsvExportOptions(options) {
     });
   }
   return {
-    dialect: DIALECTS[o.dialect ?? "gephi"],
+    // another format's dialect (a JSON "d3" in a shared options object) leaves CSV's default
+    dialect: DIALECTS[o.dialect === "generic" ? "generic" : "gephi"],
     table: o.table ?? "edges",
     delimiter: o.delimiter ?? ",",
     newline: o.newline ?? "\n",
@@ -1338,6 +1901,18 @@ function cellText(column, row) {
     }
   }
 }
+function nodeTableNote(names, table, note) {
+  const written = names.length;
+  if (written > 0) {
+    const shown = names.slice(0, 3).map((n) => JSON.stringify(n)).join(", ") + (written > 3 ? ", ..." : "");
+    note(
+      CSV_LOSS.NODE_TABLE,
+      `the ${table === "adjacency" ? "adjacency" : "edge"} table has no room for node attributes: ${written} node column${plural(written)} (${shown}) ${agree(written, "is", "are")} written only by a second export with table: "nodes"`,
+      null,
+      written
+    );
+  }
+}
 function idNotes(snapshot, values, note) {
   const { ids } = snapshot;
   if (ids.kind === "mixed") {
@@ -1354,7 +1929,7 @@ function idNotes(snapshot, values, note) {
     if (collisions > 0) {
       note(
         CSV_LOSS.ID_TEXT_COLLISION,
-        `${collisions} node id(s) share their text with another id (a number and a string); export() will throw E_INVALID_ID`,
+        `${collisions} node id${plural(collisions)} ${agree(collisions, "shares", "share")} their text with another id (a number and a string); the save fails with E_INVALID_ID`,
         null,
         collisions
       );
@@ -1371,7 +1946,7 @@ function idNotes(snapshot, values, note) {
     if (changed > 0) {
       note(
         CSV_LOSS.ID_TEXT_TYPE,
-        `${changed} node id(s) read back as the other type under ids: "canonical" (a string "1" becomes 1, a number 1.5 becomes "1.5")`,
+        `${changed} node id${plural(changed)} ${agree(changed, "reads", "read")} back as the other type under ids: "canonical" (a string "1" becomes 1, a number 1.5 becomes "1.5")`,
         null,
         changed
       );
@@ -1401,14 +1976,14 @@ function planExport(snapshot, options, values) {
     if (!snapshot.directed) {
       note(
         CSV_LOSS.DIRECTION_DROPPED,
-        `${where} has no direction column; ${snapshot.edgeCount} undirected edge(s) read back as directed unless the importer is told otherwise`,
+        `${where} has no direction column; ${snapshot.edgeCount} undirected edge${plural(snapshot.edgeCount)} ${agree(snapshot.edgeCount, "reads", "read")} back as directed unless the importer is told otherwise`,
         null,
         snapshot.edgeCount
       );
     } else if (mixed > 0) {
       note(
         CSV_LOSS.DIRECTION_DROPPED,
-        `${where} has no direction column; ${mixed} undirected edge(s) of a mixed graph read back as one directed edge each`,
+        `${where} has no direction column; ${mixed} undirected edge${plural(mixed)} of a mixed graph read back as one directed edge each`,
         null,
         mixed
       );
@@ -1424,7 +1999,7 @@ function planExport(snapshot, options, values) {
   if (folding.mutualCount > 0) {
     note(
       CSV_LOSS.MUTUAL_EXPANDED,
-      `${folding.mutualCount} mutual pair(s) are written as two directed rows; the mutual mark is lost`,
+      `${folding.mutualCount} mutual pair${plural(folding.mutualCount)} ${agree(folding.mutualCount, "is", "are")} written as two directed rows; the mutual mark is lost`,
       null,
       folding.mutualCount
     );
@@ -1452,7 +2027,7 @@ function planExport(snapshot, options, values) {
     if (dropped > 0) {
       note(
         CSV_LOSS.EDGE_COLUMNS,
-        `${dropped} edge column(s) are not written: an adjacency table holds the weight only`,
+        `${dropped} edge column${plural(dropped)} ${agree(dropped, "is", "are")} not written: an adjacency table holds the weight only`,
         null,
         dropped
       );
@@ -1489,15 +2064,11 @@ function planExport(snapshot, options, values) {
       }
     }
   } else {
-    const written = nodeColumns.length + (nodeLabel === null ? 0 : 1);
-    if (written > 0) {
-      note(
-        CSV_LOSS.NODE_TABLE,
-        `${written} node column(s) are written by a table: "nodes" export only`,
-        null,
-        written
-      );
-    }
+    nodeTableNote(
+      [...nodeLabel === null ? [] : [nodeLabel.meta.name], ...nodeColumns.map((c) => c.column.meta.name)],
+      csv.table,
+      note
+    );
   }
   return {
     csv,
@@ -1541,7 +2112,7 @@ function noteNodeCoverage(snapshot, edgeRows, note) {
   if (isolated > 0) {
     note(
       CSV_LOSS.ISOLATED_NODES,
-      `${isolated} node(s) have no edge and cannot be written by the edge table; write the node table (table: "nodes") to keep them`,
+      `${isolated} node${plural(isolated)} ${agree(isolated, "has", "have")} no edge and cannot be written by the edge table; write the node table (table: "nodes") to keep them`,
       null,
       isolated
     );
@@ -1549,7 +2120,7 @@ function noteNodeCoverage(snapshot, edgeRows, note) {
   if (reordered > 0) {
     note(
       CSV_LOSS.NODE_ORDER,
-      `${reordered} node(s) are first mentioned by an edge row out of index order; a re-import numbers nodes by first appearance`,
+      `${reordered} node${plural(reordered)} ${agree(reordered, "is", "are")} first mentioned by an edge row out of index order; a re-import numbers nodes by first appearance`,
       null,
       reordered
     );
@@ -1654,7 +2225,12 @@ function checkValues(column, domain, rows, note, roleColumn = false) {
       }
     }
     if (nonFinite > 0) {
-      note(CSV_LOSS.NONFINITE, `${label}: ${nonFinite} non-finite value(s) read back as text`, name, nonFinite);
+      note(
+        CSV_LOSS.NONFINITE,
+        `${label}: ${nonFinite} non-finite value${plural(nonFinite)} ${agree(nonFinite, "reads", "read")} back as text`,
+        name,
+        nonFinite
+      );
     }
     return;
   }
@@ -1716,7 +2292,7 @@ function neighbourCell(id, weight) {
 }
 function* adjacencyLines(snapshot, plan) {
   const { delimiter, newline } = plan.csv;
-  const forced = (text) => `"${text.replace(/"/g, '""')}"`;
+  const forced = (text) => `"${text.replaceAll('"', '""')}"`;
   const quote = (text) => DELIMITER_CANDIDATES.some((c) => text.includes(c)) ? forced(text) : quoteCsvCell(text, delimiter);
   const first = (text) => /^[#%]/.test(text) ? forced(text) : quote(text);
   const list = snapshot.edgeList();
@@ -1862,15 +2438,58 @@ function prepare(snapshot, options) {
   }
   return plan;
 }
+function headerlessNotes(plan) {
+  const { csv } = plan;
+  if (csv.header || csv.table === "adjacency") {
+    return [];
+  }
+  const names = csv.table === "nodes" ? headerlessNodeColumns(plan) : headerlessEdgeColumns(plan);
+  if (names.length === 0) {
+    return [];
+  }
+  const shown = names.map((n) => JSON.stringify(n)).join(", ");
+  return [
+    Object.freeze({
+      code: CSV_LOSS.HEADERLESS,
+      message: `without a header the file is read back by position (${csv.table === "nodes" ? "id" : "source, target, weight"}, then unnamed columns), so ${names.length === 1 ? "the column" : "the columns"} ${shown} ${agree(names.length, "reads", "read")} back unnamed or in another column's place; write the header, or for an edge list pass dialect: "generic" and write only source, target and weight`,
+      column: null,
+      count: names.length
+    })
+  ];
+}
+function headerlessNodeColumns(plan) {
+  const label = plan.nodeLabel === null ? [] : [plan.nodeLabel.meta.name];
+  return [...label, ...plan.nodeColumns.map((c) => c.header)];
+}
+function headerlessEdgeColumns(plan) {
+  const { dialect } = plan.csv;
+  const names = [];
+  if (dialect.type !== null) {
+    names.push(dialect.type);
+  }
+  if (plan.edgeId !== null) {
+    names.push(plan.edgeId.meta.name);
+  }
+  if (plan.edgeLabel !== null) {
+    names.push(plan.edgeLabel.meta.name);
+  }
+  if (plan.weights.weighted && names.length > 0) {
+    names.push(dialect.weight);
+  }
+  names.push(...plan.edgeColumns.map((c) => c.header));
+  return names;
+}
 function check(snapshot, options) {
   const plan = planExport(snapshot, options, true);
   return Object.freeze([
     ...checkCapabilities(snapshot, CSV_CAPABILITIES, plan.common, { roles: KEPT_ROLES }),
-    ...plan.notes
+    ...plan.notes,
+    ...headerlessNotes(plan)
   ]);
 }
 const csvExporter = Object.freeze({
   format: "csv",
+  options: Object.freeze(["delimiter", "dialect", "header", "newline", "table"]),
   capabilities: CSV_CAPABILITIES,
   check,
   export(snapshot, options) {
@@ -1881,21 +2500,37 @@ const csvExporter = Object.freeze({
   }
 });
 const CSV_ISSUE = Object.freeze({
-  /** The input is empty (fatal). */
+  ...INPUT_ISSUE,
+  ...ELEMENT_ISSUE,
+  /** An integer beyond 2^53 was stored as the nearest 64-bit float; reported once per column. */
+  PRECISION: PRECISION_CODE,
+  /** The input is empty. The import stops. */
   EMPTY_INPUT: EMPTY_INPUT_CODE,
-  /** The input holds invalid UTF-8 (fatal). */
+  /** 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,
-  /** The header names neither endpoint columns nor an id column (fatal). */
+  /**
+   * The header names no source and target columns and no id column. Pass `sourceColumn` and `targetColumn` to name
+   * the columns. The import stops.
+   */
   NO_ENDPOINT_COLUMNS: NO_ENDPOINT_COLUMNS_CODE,
-  /** A node table without an id column (fatal). */
+  /**
+   * The node table has no id column. Pass `idColumn` to name it, or `rowNumberIds: true` to number the rows. The
+   * import stops.
+   */
   NO_ID_COLUMN: NO_ID_COLUMN_CODE,
-  /** A row with a different field count than the header. */
+  /**
+   * A row with a different number of fields than the header; the row is skipped. An adjacency list read without
+   * `table: "adjacency"` gives one per long row, and the first one's message suggests the option.
+   */
   FIELD_COUNT: FIELD_COUNT_CODE,
   /** An edge row with a blank source or target. */
   MISSING_ENDPOINT: MISSING_ENDPOINT_CODE,
@@ -1903,9 +2538,12 @@ const CSV_ISSUE = Object.freeze({
   MISSING_ID: MISSING_ID_CODE,
   /** A Type cell outside Directed / Undirected / Mutual. */
   BAD_TYPE: BAD_TYPE_CODE,
-  /** An unterminated quoted field (fatal). */
+  /** A quoted field is never closed. The import stops. */
   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.
+   */
   QUOTE: BAD_QUOTE_CODE,
   /** A header and no data rows. */
   NO_DATA_ROWS: NO_DATA_ROWS_CODE,
@@ -1913,26 +2551,78 @@ const CSV_ISSUE = Object.freeze({
   DUPLICATE_NODE: DUPLICATE_NODE_CODE,
   /** An edge row repeating an edge id (skipped). */
   DUPLICATE_EDGE_ID: DUPLICATE_EDGE_ID_CODE,
-  /** Two id cells merged into one number under ids "number". */
+  /** Two different id cells became the same number because `ids` is "number", so their nodes were merged. */
   ID_MERGED: ID_MERGED_CODE,
   /** An explicitly named weight column the file does not have. */
   COLUMN_MISSING: COLUMN_MISSING_CODE,
-  /** A column whose role another column of the 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 column renamed `<name>#<position>` (a repeated header, or a name the sink holds with another shape). */
+  /**
+   * 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 common option the importer has no use for was given. */
+  /** 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. */
+  /**
+   * 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,
-  /** The sink refused the file's direction. */
+  /**
+   * You read into a graph builder whose direction is already set, or which already holds edges, so the file is read
+   * with the builder's direction instead of its own.
+   */
   DIRECTION_REFUSED: DIRECTION_REFUSED_CODE,
-  /** Edges forced to the policy's direction. */
+  /** Edges of the other direction were read with the direction `onMixedDirection` chose. */
   DIRECTION_FORCED: DIRECTION_FORCED_CODE,
-  /** A mixed file under onMixedDirection "error" (fatal). */
+  /**
+   * The graph has both directed and undirected edges and `onMixedDirection` is "error". An import stops; a save to a
+   * format that holds one direction per file fails with E_DIRECTED. Pass "directed" or "undirected" to read or write
+   * it anyway.
+   */
   MIXED_DIRECTION: MIXED_DIRECTION_CODE,
-  /** A text column the sink could not widen to the dtype its cells imply. */
-  WIDENING_UNSUPPORTED: WIDENING_UNSUPPORTED_CODE
+  /**
+   * Your graph builder cannot change an attribute's type after its first value, so a text column keeps the type of
+   * its first values.
+   */
+  WIDENING_UNSUPPORTED: WIDENING_UNSUPPORTED_CODE,
+  /** The input starts like another format (XML or HTML, JSON, GML, DOT or Pajek), not CSV. The import stops. */
+  OTHER_FORMAT: OTHER_FORMAT_CODE,
+  /**
+   * A quote inside a field that does not start with a quote is kept as part of the text. Reported once per import.
+   */
+  STRAY_QUOTE: STRAY_QUOTE_CODE,
+  /** A leading comment's direction disagrees with defaultDirected or an earlier comment. */
+  COMMENT_DIRECTION: COMMENT_DIRECTION_CODE,
+  /**
+   * A column named like `Type` holds direction words (Directed, Undirected), but graph-io reads direction only from
+   * a `Type` column beside `Source` and `Target`, or from the `typeColumn` option. Reported once per import.
+   */
+  TYPE_COLUMN_IGNORED: TYPE_COLUMN_IGNORED_CODE,
+  /** The header ends in a delimiter; rows without the empty last cell are complete. */
+  TRAILING_HEADER_DELIMITER: TRAILING_HEADER_DELIMITER_CODE,
+  /** Every row is one cell another delimiter would split (a likely wrong delimiter option). */
+  SINGLE_COLUMN: SINGLE_COLUMN_CODE,
+  /** Several header columns name one role; the one not chosen is a plain attribute. */
+  AMBIGUOUS_COLUMN: AMBIGUOUS_COLUMN_CODE,
+  /**
+   * An id that is not quoted has spaces at its start or end; they are kept, so it is a different id from the trimmed
+   * text. Reported once per import.
+   */
+  PADDED_ID: PADDED_ID_CODE,
+  /** A leading # / % line skipped as a comment has the fields of a record. */
+  COMMENT_LIKE_RECORD: COMMENT_LIKE_RECORD_CODE,
+  /** Every data row ends in one extra delimiter; the empty last cell is dropped. Reported once per import. */
+  TRAILING_DELIMITER: TRAILING_DELIMITER_CODE,
+  /**
+   * In a file without a header, the third column holds text, so it is read as an attribute, not as the edge weight.
+   * Reported once per import.
+   */
+  WEIGHT_AS_ATTRIBUTE: WEIGHT_AS_ATTRIBUTE_CODE
 });
 export {
   CSV_CAPABILITIES,