@graphty/graph-io 0.3.39 → 0.3.41

package/dist/chunks/{text-Bjfa1xYL.js → text-Bh9SaAob.js}

@@ -1,5 +1,5 @@
 import { INVALID_INDEX, GraphFormatError } from "@graphty/graph-format";
-import { P as PRECISION_CODE } from "./export-B-aVCwyG.js";
+import { P as PRECISION_CODE } from "./export-DD3Lvw-F.js";
 const I32_TEXT = /^-?(0|[1-9]\d*)$/;
 const F64_TEXT = /^[+-]?((0|[1-9]\d*)(\.\d*)?|\.\d+)([eE][+-]?\d+)?$/;
 const I32_MIN = -2147483648;
@@ -97,15 +97,7 @@ class TextCellWriter {
   write(row, text) {
     const kind = inferTextDtype(text);
     const value = parseTextCell(text);
-    if (typeof value === "number" && !Number.isSafeInteger(value) && I32_TEXT.test(text) && BigInt(text) !== BigInt(value)) {
-      this.report.warnOnce(
-        "precision",
-        PRECISION_CODE,
-        `${this.domain} column "${this.name}": integers beyond 2^53 are stored as the nearest double (first: ${text})`,
-        { element: this.name },
-        `${PRECISION_CODE}:${this.domain}:${this.name}`
-      );
-    }
+    this.warnIfImprecise(text, value);
     const wasString = this.textDtype === "string";
     const textDtype = this.textDtype === null || textDtypeRank(kind) > textDtypeRank(this.textDtype) ? kind : this.textDtype;
     this.set(row, textDtype === "string" ? text : value);
@@ -132,6 +124,23 @@ class TextCellWriter {
       this.widen("f64");
     }
   }
+  /**
+   * Warn, once per column, when the cell is an integer beyond 2^53 that is stored as the nearest
+   * double.
+   * @param text - the cell text
+   * @param value - the parsed value
+   */
+  warnIfImprecise(text, value) {
+    if (typeof value === "number" && !Number.isSafeInteger(value) && I32_TEXT.test(text) && BigInt(text) !== BigInt(value)) {
+      this.report.warnOnce(
+        "precision",
+        PRECISION_CODE,
+        `${this.domain} column "${this.name}": integers beyond 2^53 are stored as the nearest double (first: ${text})`,
+        { element: this.name },
+        `${PRECISION_CODE}:${this.domain}:${this.name}`
+      );
+    }
+  }
   /**
    * Write a value (the parsed scalar, or a text into a widened column).
    * @param row - the row
@@ -204,4 +213,4 @@ export {
   parseTextCell as p,
   trimTrailingZeros as t
 };
-//# sourceMappingURL=text-Bjfa1xYL.js.map
+//# sourceMappingURL=text-Bh9SaAob.js.map

package/dist/chunks/text-Bh9SaAob.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-Bh9SaAob.js","sources":["../../src/common/text.ts"],"sourcesContent":["/**\n * The fixed lexical grammar of design section 5.1 for untyped text sources (CSV cells, GML\n * values, DOT strings, Pajek tokens), reproduced from the core's reference implementation so the\n * two agree (invariant I15). Text importers parse each cell with parseTextCell() and push the JS\n * value; the sink's per-column inference then widens `bool -> i32 -> f64 -> string` and never per\n * cell, so a column that saw `1` and then `\"01\"` becomes string for all rows.\n *\n * - `bool` is exactly `true` / `false` (case-sensitive);\n * - `i32` is `/^-?(0|[1-9][0-9]*)$/` within `[-2^31, 2^31)`; `0` / `1` are i32, never bool;\n * - `f64` is a decimal or exponent literal accepted by `Number()` that is not empty, not\n *   whitespace, not `Infinity` / `NaN`, not a hex / octal / binary form, has no leading zeros in\n *   its integer part, and whose value is finite (an integer literal outside i32 range is f64);\n * - everything else is `string`.\n */\n\nimport { type ColumnHandle, GraphFormatError, type GraphSink, INVALID_INDEX } from \"@graphty/graph-format\";\n\nimport { PRECISION_CODE } from \"./codes.js\";\nimport { type ImportReportBuilder } from \"./report.js\";\n\nconst I32_TEXT = /^-?(0|[1-9]\\d*)$/;\nconst F64_TEXT = /^[+-]?((0|[1-9]\\d*)(\\.\\d*)?|\\.\\d+)([eE][+-]?\\d+)?$/;\nconst I32_MIN = -2147483648;\nconst I32_MAX = 2147483647;\n\n/**\n * The dtype a text cell parses as under the fixed text grammar.\n * @public\n * @category Plugin helpers\n */\nexport type TextDtype = \"bool\" | \"i32\" | \"f64\" | \"string\";\n\n/**\n * A digit string without its trailing zeros (`\"1200\"` becomes `\"12\"`).\n * @param digits - the digits\n * @returns the digits up to the last one that is not 0\n */\nexport function trimTrailingZeros(digits: string): string {\n    let end = digits.length;\n    while (end > 0 && digits[end - 1] === \"0\") {\n        end--;\n    }\n    return digits.slice(0, end);\n}\n\n/**\n * Classify one text cell by the fixed grammar.\n * @param text - the cell text, exactly as read (no trimming)\n * @returns bool, i32, f64 or string\n * @category Plugin helpers\n */\nexport function inferTextDtype(text: string): TextDtype {\n    if (text === \"true\" || text === \"false\") {\n        return \"bool\";\n    }\n    if (I32_TEXT.test(text)) {\n        const n = Number(text);\n        if (n >= I32_MIN && n <= I32_MAX) {\n            return \"i32\";\n        }\n        return Number.isFinite(n) ? \"f64\" : \"string\";\n    }\n    if (F64_TEXT.test(text) && Number.isFinite(Number(text))) {\n        return \"f64\";\n    }\n    return \"string\";\n}\n\n/**\n * Parse one text cell into the JS value its grammar class implies: a boolean for bool, a number for\n * i32 / f64, the text itself for string. The sink infers the column dtype from the value.\n * @param text - the cell text, exactly as read\n * @returns the value\n * @category Plugin helpers\n */\nexport function parseTextCell(text: string): boolean | number | string {\n    switch (inferTextDtype(text)) {\n        case \"bool\":\n            return text === \"true\";\n        case \"i32\":\n        case \"f64\":\n            return Number(text);\n        case \"string\":\n            return text;\n        default:\n            return text;\n    }\n}\n\n/**\n * Whether a text cell is a number under the f64 grammar (an i32 or f64 literal).\n * @param text - the cell text\n * @returns true when parseTextCell(text) returns a number\n * @category Plugin helpers\n */\nexport function isNumericText(text: string): boolean {\n    const dtype = inferTextDtype(text);\n    return dtype === \"i32\" || dtype === \"f64\";\n}\n\n/**\n * Whether a numeric cell text is the canonical spelling of its value (`String(value) === text`),\n * so that the sink's own re-formatting of the value would reproduce it.\n * @param text - the cell text\n * @param value - the parsed value\n * @returns true when the lexical form survives a widening to string\n */\nfunction isCanonicalNumberText(text: string, value: number): boolean {\n    return String(value) === text;\n}\n\n/**\n * The widening rank of a text dtype in the design section 5.1 order.\n * @param dtype - the text dtype\n * @returns 0 for bool, 1 for i32, 2 for f64, 3 for string\n */\nfunction textDtypeRank(dtype: TextDtype): number {\n    switch (dtype) {\n        case \"bool\":\n            return 0;\n        case \"i32\":\n            return 1;\n        case \"f64\":\n            return 2;\n        case \"string\":\n            return 3;\n        default: {\n            const name: string = dtype;\n            throw new GraphFormatError(\"E_UNSUPPORTED\", `unknown text dtype ${name}`, { dtype: name });\n        }\n    }\n}\n\n/**\n * Writes the cells of one attribute of a text format whose values carry no type (CSV, DOT, Pajek):\n * you hand it each cell's text and it stores a number, a boolean or text, choosing one type for the\n * whole attribute. A column of `2.0`, `3.5` stays a number column with decimals even though `2.0`\n * alone looks like an integer, and once one cell turns out to be text, earlier cells such as `1e5`\n * are kept as written instead of as `100000`. Create one writer per attribute name and per kind\n * (\"node\" or \"edge\"), and call `write(index, text)` with the node or edge index the sink gave you:\n *\n * ```ts\n * const color = new TextCellWriter(\"color\", \"node\", sink, report);\n * color.write(sink.addNode(\"a\"), \"red\");\n * ```\n *\n * A sink that cannot change a column's type after the fact (one of your own without\n * `widenNodeColumn` / `widenEdgeColumn`) keeps the type the first values implied, with one W_WIDENING_UNSUPPORTED warning\n * per attribute.\n * @public\n * @category Writing a format\n */\nexport class TextCellWriter {\n    /** The column name in the sink. */\n    readonly name: string;\n\n    private readonly domain: \"node\" | \"edge\";\n\n    private readonly sink: GraphSink;\n\n    private readonly report: ImportReportBuilder;\n\n    private handle: ColumnHandle = INVALID_INDEX as ColumnHandle;\n\n    /** The widest text dtype seen (the column's dtype under the 5.1 grammar). */\n    private textDtype: TextDtype | null = null;\n\n    /** The widest dtype the pushed values imply (what the sink inferred on its own). */\n    private valueDtype: TextDtype | null = null;\n\n    private readonly keptRows: number[] = [];\n\n    private readonly keptTexts: string[] = [];\n\n    /**\n     * Create a writer. The attribute is added to the sink on the first write.\n     * @param name - the attribute name\n     * @param domain - \"node\" for a node attribute, \"edge\" for an edge attribute\n     * @param sink - the sink the importer fills\n     * @param report - the import report, for warnings about the values\n     */\n    constructor(name: string, domain: \"node\" | \"edge\", sink: GraphSink, report: ImportReportBuilder) {\n        this.name = name;\n        this.domain = domain;\n        this.sink = sink;\n        this.report = report;\n    }\n\n    /**\n     * The sink's handle of the attribute's column, for reading it back.\n     * @returns the handle, or INVALID_INDEX before the first write\n     */\n    get column(): ColumnHandle {\n        return this.handle;\n    }\n\n    /**\n     * Write one cell.\n     * @param row - the node or edge index, as the sink's addNode() or addEdge() returned it\n     * @param text - the cell text, exactly as read from the file\n     */\n    write(row: number, text: string): void {\n        const kind = inferTextDtype(text);\n        const value = parseTextCell(text);\n        this.warnIfImprecise(text, value);\n        const wasString = this.textDtype === \"string\";\n        const textDtype =\n            this.textDtype === null || textDtypeRank(kind) > textDtypeRank(this.textDtype) ? kind : this.textDtype;\n        // a string column keeps every cell's lexical form; a numeric text is never re-spelled. The\n        // sink may refuse the value (a declared column of another dtype): the state advances only\n        // once the cell is written, so a refused cell leaves the writer as it was.\n        this.set(row, textDtype === \"string\" ? text : value);\n        this.textDtype = textDtype;\n        const valueKind = kindOfValue(value);\n        if (this.valueDtype === null || textDtypeRank(valueKind) > textDtypeRank(this.valueDtype)) {\n            this.valueDtype = valueKind;\n        }\n        if (this.textDtype === \"string\") {\n            if (!wasString && this.keptRows.length > 0) {\n                // the sink just widened the column to string from the values; restore the texts\n                // whose lexical form the values did not carry\n                for (let i = 0; i < this.keptRows.length; i++) {\n                    this.set(this.keptRows[i], this.keptTexts[i]);\n                }\n                this.keptRows.length = 0;\n                this.keptTexts.length = 0;\n            }\n            return;\n        }\n        if (typeof value === \"number\" && !isCanonicalNumberText(text, value)) {\n            this.keptRows.push(row);\n            this.keptTexts.push(text);\n        }\n        if (this.textDtype === \"f64\" && this.valueDtype !== \"f64\") {\n            this.widen(\"f64\");\n        }\n    }\n\n    /**\n     * Warn, once per column, when the cell is an integer beyond 2^53 that is stored as the nearest\n     * double.\n     * @param text - the cell text\n     * @param value - the parsed value\n     */\n    private warnIfImprecise(text: string, value: unknown): void {\n        if (\n            typeof value === \"number\" &&\n            !Number.isSafeInteger(value) &&\n            I32_TEXT.test(text) &&\n            BigInt(text) !== BigInt(value)\n        ) {\n            this.report.warnOnce(\n                \"precision\",\n                PRECISION_CODE,\n                `${this.domain} column \"${this.name}\": integers beyond 2^53 are stored as the nearest double (first: ${text})`,\n                { element: this.name },\n                `${PRECISION_CODE}:${this.domain}:${this.name}`,\n            );\n        }\n    }\n\n    /**\n     * Write a value (the parsed scalar, or a text into a widened column).\n     * @param row - the row\n     * @param value - the value\n     */\n    private set(row: number, value: unknown): void {\n        if (this.handle === INVALID_INDEX) {\n            if (this.domain === \"node\") {\n                this.sink.setNodeValue(this.name, row, value);\n                this.handle = this.sink.nodeColumn(this.name);\n            } else {\n                this.sink.setEdgeValue(this.name, row, value);\n                this.handle = this.sink.edgeColumn(this.name);\n            }\n            return;\n        }\n        if (this.domain === \"node\") {\n            this.sink.setNodeValue(this.handle, row, value);\n        } else {\n            this.sink.setEdgeValue(this.handle, row, value);\n        }\n    }\n\n    /**\n     * Widen the column to the dtype the text grammar implies, through the sink's optional call.\n     * @param dtype - the dtype\n     */\n    private widen(dtype: \"f64\"): void {\n        const { sink } = this;\n        const supported =\n            this.domain === \"node\" ? sink.widenNodeColumn !== undefined : sink.widenEdgeColumn !== undefined;\n        if (!supported) {\n            this.report.warnOnce(\n                \"coercion\",\n                WIDENING_UNSUPPORTED_CODE,\n                `column \"${this.name}\" holds ${dtype} text but the sink cannot widen an inferred column; it keeps the value-inferred dtype`,\n                { element: this.name },\n            );\n            this.valueDtype = dtype;\n            return;\n        }\n        try {\n            if (this.domain === \"node\") {\n                sink.widenNodeColumn?.(this.handle, dtype);\n            } else {\n                sink.widenEdgeColumn?.(this.handle, dtype);\n            }\n            this.valueDtype = dtype;\n        } catch (err) {\n            if (!(err instanceof GraphFormatError) || err.code !== \"E_COLUMN_TYPE\") {\n                throw err;\n            }\n            // a caller's declared column of the name: its dtype stands\n            this.valueDtype = dtype;\n        }\n    }\n}\n\n/**\n * Your graph builder cannot change an attribute's type after its first value, so a text column keeps the type of its\n * first values.\n * @category Issue and loss codes\n */\nexport const WIDENING_UNSUPPORTED_CODE = \"W_WIDENING_UNSUPPORTED\";\n\n/**\n * The text dtype a parsed cell value implies on its own (what the sink's inference sees). It must\n * be graph-format's inference rule exactly: -0 is an integer there, so a column holding only\n * `-0.0` is inferred i32 and must be widened to f64, or the sign is lost.\n * @param value - the parsed value\n * @returns the dtype\n */\nfunction kindOfValue(value: boolean | number | string): TextDtype {\n    if (typeof value === \"boolean\") {\n        return \"bool\";\n    }\n    if (typeof value === \"string\") {\n        return \"string\";\n    }\n    return Number.isInteger(value) && value >= -2147483648 && value <= 2147483647 ? \"i32\" : \"f64\";\n}\n"],"names":[],"mappings":"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"}

package/dist/csv.js

@@ -1,8 +1,8 @@
-import { b as plural, bU 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, aK 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, bD as countMixedEdges, $ as agree, e as explicitWeights, b_ as otherFormatDialect, bS 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-B-aVCwyG.js";
-import { i as inferTextDtype, T as TextCellWriter, p as parseTextCell, W as WIDENING_UNSUPPORTED_CODE } from "./chunks/text-Bjfa1xYL.js";
+import { b as plural, bU 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, aK 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, bD as countMixedEdges, $ as agree, e as explicitWeights, b_ as otherFormatDialect, bS 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-DD3Lvw-F.js";
+import { i as inferTextDtype, T as TextCellWriter, p as parseTextCell, W as WIDENING_UNSUPPORTED_CODE } from "./chunks/text-Bh9SaAob.js";
 import { GraphFormatError, INVALID_INDEX } from "@graphty/graph-format";
-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-C9jd7yLD.js";
-import { o as quoteCsvCell } from "./chunks/escape-BpYMQZVa.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-Uc3LkABx.js";
+import { o as quoteCsvCell } from "./chunks/escape-DBb8zuNE.js";
 import { j as joinText, e as encodeChunks } from "./chunks/writer-DxjgHwSe.js";
 const SOURCE_NAMES = Object.freeze([
   "source",
@@ -433,6 +433,15 @@ function isBlank(text) {
 function isUnset(text, quoted) {
   return quoted !== true && isBlank(text);
 }
+function setNeighborCells(row, quoted) {
+  let neighbors = 0;
+  for (let k = 1; k < row.length; k++) {
+    if (!isUnset(row[k], quoted[k])) {
+      neighbors++;
+    }
+  }
+  return neighbors;
+}
 const ABORT_CHECK_INTERVAL = 64;
 function uniqueNames(names, report, line) {
   const seen = /* @__PURE__ */ new Set();
@@ -1199,12 +1208,7 @@ class TableReader {
     const { where } = this;
     where.line = line;
     where.element = null;
-    let neighbors = 0;
-    for (let k = 1; k < row.length; k++) {
-      if (!isUnset(row[k], quoted[k])) {
-        neighbors++;
-      }
-    }
+    const neighbors = setNeighborCells(row, quoted);
     if (isUnset(row[0], quoted[0])) {
       report.error("missing-value", MISSING_ID_CODE, `blank node cell`, { line });
       counts.skippedNodes++;
@@ -1926,19 +1930,23 @@ function nodeTableNote(names, table, notes) {
     );
   }
 }
+function idTextCollisions(ids) {
+  const seen = /* @__PURE__ */ new Set();
+  let collisions = 0;
+  for (let i = 0; i < ids.size; i++) {
+    const text = String(ids.idOf(i));
+    if (seen.has(text)) {
+      collisions++;
+    } else {
+      seen.add(text);
+    }
+  }
+  return collisions;
+}
 function idNotes(snapshot, values, note) {
   const { ids } = snapshot;
   if (ids.kind === "mixed") {
-    const seen = /* @__PURE__ */ new Set();
-    let collisions = 0;
-    for (let i = 0; i < ids.size; i++) {
-      const text = String(ids.idOf(i));
-      if (seen.has(text)) {
-        collisions++;
-      } else {
-        seen.add(text);
-      }
-    }
+    const collisions = idTextCollisions(ids);
     if (collisions > 0) {
       note(
         CSV_LOSS.ID_TEXT_COLLISION,
@@ -2152,39 +2160,44 @@ function attributeColumns(table, domain, reserved, idColumn, labelColumn, note)
     if (role !== null && SKIPPED_ROLES.has(role)) {
       continue;
     }
-    const low = lower(name);
     const set = column.length - column.nullCount;
-    const isIdName = domain === "edge" ? findColumn([name], EDGE_ID_NAMES) >= 0 : false;
-    if (reserved.has(low) || isIdName || idColumn !== null && lower(idColumn.meta.name) === low) {
-      note?.(
-        CSV_LOSS.RESERVED_NAME,
-        `${domain} column "${name}" is not written: the name is reserved for the ${isIdName ? "edge id" : low} column`,
-        name,
-        set
-      );
+    if (isReservedName(name, domain, reserved, idColumn, set, note)) {
       continue;
     }
-    if (findColumn([name], LABEL_NAMES) >= 0) {
-      if (labelColumn !== null) {
-        note?.(
-          CSV_LOSS.RESERVED_NAME,
-          `${domain} column "${name}" is not written: the name is reserved for the label column`,
-          name,
-          set
-        );
-        continue;
-      }
-      note?.(
-        CSV_LOSS.ROLE_ASSUMED,
-        `${domain} column "${name}" reads back with the label role (string)`,
-        name,
-        set
-      );
+    if (findColumn([name], LABEL_NAMES) >= 0 && !labelNameWritten(name, domain, labelColumn, set, note)) {
+      continue;
     }
     out.push({ column, header: name });
   }
   return out;
 }
+function isReservedName(name, domain, reserved, idColumn, set, note) {
+  const low = lower(name);
+  const isIdName = domain === "edge" ? findColumn([name], EDGE_ID_NAMES) >= 0 : false;
+  if (reserved.has(low) || isIdName || idColumn !== null && lower(idColumn.meta.name) === low) {
+    note?.(
+      CSV_LOSS.RESERVED_NAME,
+      `${domain} column "${name}" is not written: the name is reserved for the ${isIdName ? "edge id" : low} column`,
+      name,
+      set
+    );
+    return true;
+  }
+  return false;
+}
+function labelNameWritten(name, domain, labelColumn, set, note) {
+  if (labelColumn !== null) {
+    note?.(
+      CSV_LOSS.RESERVED_NAME,
+      `${domain} column "${name}" is not written: the name is reserved for the label column`,
+      name,
+      set
+    );
+    return false;
+  }
+  note?.(CSV_LOSS.ROLE_ASSUMED, `${domain} column "${name}" reads back with the label role (string)`, name, set);
+  return true;
+}
 function checkRoleColumn(column, role, names, domain, rows, note) {
   if (column === null) {
     return;
@@ -2303,6 +2316,14 @@ function neighbourCell(id, weight) {
   }
   return id.includes(":") ? `${id}:` : id;
 }
+function sourceRunEnd(src, edgeRows, r) {
+  const source = src[edgeRows[r]];
+  let end = r;
+  while (end < edgeRows.length && src[edgeRows[end]] === source) {
+    end++;
+  }
+  return end;
+}
 function* adjacencyLines(snapshot, plan) {
   const { delimiter, newline } = plan.csv;
   const forced = (text) => `"${text.replaceAll('"', '""')}"`;
@@ -2329,10 +2350,7 @@ function* adjacencyLines(snapshot, plan) {
   let r = 0;
   while (r < edgeRows.length) {
     const source = list.src[edgeRows[r]];
-    let end = r;
-    while (end < edgeRows.length && list.src[edgeRows[end]] === source) {
-      end++;
-    }
+    const end = sourceRunEnd(list.src, edgeRows, r);
     const fresh = [];
     let highest = -1;
     let inOrder = true;