@graphty/graph-io 0.3.27 → 0.3.29

package/src/common/export.ts

@@ -318,6 +318,12 @@ export interface CheckExtras {
      * W_WEIGHTS_DROPPED note. Default true.
      */
     readonly weights?: boolean | undefined;
+    /**
+     * The tables the export writes, of "node", "edge" and "graph"; a gap in a table it does not
+     * write is not a loss of this export and gets no note. Default all three. A CSV node table is
+     * `["node"]`, so its notes are about node ids and node columns only.
+     */
+    readonly tables?: readonly ("node" | "edge" | "graph")[] | undefined;
     /**
      * How the format's importer turns id text back into ids ("canonical" for most text formats), so
      * an id that comes back with another type (the text "7" as the number 7) is reported as
@@ -353,60 +359,11 @@ export function checkCapabilities(
     const note = (code: string, message: string, column: string | null = null, count: number | null = null): void => {
         notes.push(Object.freeze({ code, message, column, count }));
     };
+    const tables = extras.tables ?? ["node", "edge", "graph"];
+    const edges = tables.includes("edge");
 
-    // mixed direction (design section 3.6): an expanded snapshot carries the pair / directed roles
-    const mixed = countMixedEdges(snapshot);
-    if (mixed > 0 && !caps.mixedDirection) {
-        if (options.onMixedDirection === "error") {
-            note(
-                LOSS.MIXED_DIRECTION_ERROR,
-                `${mixed} undirected edge${plural(mixed)} in a directed graph, and the format holds one direction per file, so the save fails unless onMixedDirection is "directed" or "undirected"`,
-                null,
-                mixed,
-            );
-        } else {
-            note(
-                LOSS.MIXED_DIRECTION,
-                `${mixed} undirected edge${plural(mixed)} in a directed graph ${agree(mixed, "is", "are")} written as ${options.onMixedDirection} (onMixedDirection), and the format holds one direction per file`,
-                null,
-                mixed,
-            );
-        }
-    }
-
-    if (snapshot.flags.multigraph && !caps.multiEdges) {
-        const parallel = countParallelArcs(snapshot);
-        note(
-            LOSS.MULTI_EDGES,
-            `${parallel} parallel edge${plural(parallel)}; the format has no parallel edges`,
-            null,
-            parallel,
-        );
-    }
-    if (snapshot.selfLoopCount > 0 && !caps.selfLoops) {
-        note(
-            LOSS.SELF_LOOPS,
-            `${snapshot.selfLoopCount} self-loop${plural(snapshot.selfLoopCount)}; the format has no self-loops`,
-            null,
-            snapshot.selfLoopCount,
-        );
-    }
-
-    const edgeIds = snapshot.edges.byRole("id");
-    if (caps.edgeIds === "required" && edgeIds === null && snapshot.edgeCount > 0) {
-        note(
-            LOSS.EDGE_IDS_GENERATED,
-            "the format requires edge ids, and the graph has none; the edges are written with generated ids, which read back as a new edge id column",
-            null,
-            snapshot.edgeCount,
-        );
-    } else if (caps.edgeIds === "none" && edgeIds !== null) {
-        note(
-            LOSS.EDGE_IDS_DROPPED,
-            `edge id column "${edgeIds.meta.name}" cannot be written`,
-            edgeIds.meta.name,
-            snapshot.edgeCount,
-        );
+    if (edges) {
+        checkEdgeStructure(snapshot, caps, options, note);
     }
 
     const unrepresentable = countUnrepresentableIds(snapshot, caps.idCharset);
@@ -455,24 +412,40 @@ export function checkCapabilities(
         }
     }
 
-    checkWeights(snapshot, extras, note);
-    checkColumns(snapshot.nodes, "node", caps, extras, note);
-    checkColumns(snapshot.edges, "edge", caps, extras, note);
-    const graphColumns = snapshot.graph.names();
+    if (edges) {
+        checkWeights(snapshot, extras, note);
+    }
+    if (tables.includes("node")) {
+        checkColumns(snapshot.nodes, "node", caps, extras, note);
+    }
+    if (edges) {
+        checkColumns(snapshot.edges, "edge", caps, extras, note);
+    }
+    const graphColumns = tables.includes("graph") ? snapshot.graph.names() : [];
     if (graphColumns.length > 0) {
         if (caps.graphAttributes) {
             checkColumns(snapshot.graph, "graph", caps, extras, note);
         } else {
-            note(
-                LOSS.GRAPH_ATTRIBUTES,
-                `${graphColumns.length} graph attribute${plural(graphColumns.length)} cannot be written`,
-                null,
-                graphColumns.length,
+            notes.push(
+                Object.freeze({
+                    code: LOSS.GRAPH_ATTRIBUTES,
+                    message: `${graphColumns.length} graph attribute${plural(graphColumns.length)} cannot be written`,
+                    column: null,
+                    count: graphColumns.length,
+                    columns: Object.freeze([...graphColumns]),
+                }),
             );
         }
     }
 
     for (const [name, table] of snapshot.extensions) {
+        // "temporal:node:<column>" is the node table's, "temporal:edge:<column>" the edge table's;
+        // any other extension table is the graph's.
+        const [, kind] = name.split(":");
+        const owner = name.startsWith("temporal:") && (kind === "node" || kind === "edge") ? kind : "graph";
+        if (!tables.includes(owner)) {
+            continue;
+        }
         if (name.startsWith("temporal:")) {
             if (caps.temporal !== "dynamic-values") {
                 note(
@@ -494,6 +467,76 @@ export function checkCapabilities(
     return notes;
 }
 
+/**
+ * The edge-structure checks of checkCapabilities(): direction, parallel edges, self-loops and
+ * edge ids. Skipped for an export that writes no edge table.
+ * @param snapshot - the snapshot about to be exported
+ * @param caps - the exporter's capabilities
+ * @param options - the resolved common export options
+ * @param note - the recorder
+ */
+function checkEdgeStructure(
+    snapshot: GraphSnapshot,
+    caps: ExportCapabilities,
+    options: ResolvedExportOptions,
+    note: NoteFn,
+): void {
+    // mixed direction (design section 3.6): an expanded snapshot carries the pair / directed roles
+    const mixed = countMixedEdges(snapshot);
+    if (mixed > 0 && !caps.mixedDirection) {
+        if (options.onMixedDirection === "error") {
+            note(
+                LOSS.MIXED_DIRECTION_ERROR,
+                `${mixed} undirected edge${plural(mixed)} in a directed graph, and the format holds one direction per file, so the save fails unless onMixedDirection is "directed" or "undirected"`,
+                null,
+                mixed,
+            );
+        } else {
+            note(
+                LOSS.MIXED_DIRECTION,
+                `${mixed} undirected edge${plural(mixed)} in a directed graph ${agree(mixed, "is", "are")} written as ${options.onMixedDirection} (onMixedDirection), and the format holds one direction per file`,
+                null,
+                mixed,
+            );
+        }
+    }
+
+    if (snapshot.flags.multigraph && !caps.multiEdges) {
+        const parallel = countParallelArcs(snapshot);
+        note(
+            LOSS.MULTI_EDGES,
+            `${parallel} parallel edge${plural(parallel)}; the format has no parallel edges`,
+            null,
+            parallel,
+        );
+    }
+    if (snapshot.selfLoopCount > 0 && !caps.selfLoops) {
+        note(
+            LOSS.SELF_LOOPS,
+            `${snapshot.selfLoopCount} self-loop${plural(snapshot.selfLoopCount)}; the format has no self-loops`,
+            null,
+            snapshot.selfLoopCount,
+        );
+    }
+
+    const edgeIds = snapshot.edges.byRole("id");
+    if (caps.edgeIds === "required" && edgeIds === null && snapshot.edgeCount > 0) {
+        note(
+            LOSS.EDGE_IDS_GENERATED,
+            "the format requires edge ids, and the graph has none; the edges are written with generated ids, which read back as a new edge id column",
+            null,
+            snapshot.edgeCount,
+        );
+    } else if (caps.edgeIds === "none" && edgeIds !== null) {
+        note(
+            LOSS.EDGE_IDS_DROPPED,
+            `edge id column "${edgeIds.meta.name}" cannot be written`,
+            edgeIds.meta.name,
+            snapshot.edgeCount,
+        );
+    }
+}
+
 /**
  * The ids a charset cannot hold, as a message phrase.
  * @param charset - the format's id charset

package/src/common/zip.ts

@@ -317,7 +317,7 @@ function zip64Extra(
     fields: { compressedSize: number; size: number; localOffset: number },
 ): { compressedSize: number; size: number; localOffset: number } {
     const out = { ...fields };
-    for (let p = at; p + 4 <= at + length; ) {
+    for (let p = at; p + 4 <= at + length;) {
         const id = view.getUint16(p, true);
         const dataLength = view.getUint16(p + 2, true);
         if (id === 1) {

package/src/formats/csv/exporter.ts

@@ -385,13 +385,9 @@ function cellText(column: Column, row: number): string | null {
  * W_CSV_NODE_TABLE: the node columns an edge-table or adjacency export leaves for a second, node-table export.
  * @param names - the node columns, label first
  * @param table - the table being written ("edges" or "adjacency")
- * @param note - the recorder
+ * @param notes - receives the note
  */
-function nodeTableNote(
-    names: readonly string[],
-    table: string,
-    note: (code: string, message: string, column?: string | null, count?: number | null) => void,
-): void {
+function nodeTableNote(names: readonly string[], table: string, notes: LossNote[]): void {
     const written = names.length;
     if (written > 0) {
         const shown =
@@ -399,11 +395,14 @@ function nodeTableNote(
                 .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,
+        notes.push(
+            Object.freeze({
+                code: CSV_LOSS.NODE_TABLE,
+                message: `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"`,
+                column: null,
+                count: written,
+                columns: Object.freeze([...names]),
+            }),
         );
     }
 }
@@ -483,7 +482,8 @@ function planExport(
             edgeRows.push(e);
         }
     }
-    if (csv.dialect.type === null || csv.table === "adjacency") {
+    // A node table holds no edge: the direction and mutual notes are the edge table's.
+    if (csv.table !== "nodes" && (csv.dialect.type === null || csv.table === "adjacency")) {
         const where = csv.table === "adjacency" ? "an adjacency table" : "the generic dialect";
         const mixed = countMixedEdges(snapshot);
         if (!snapshot.directed) {
@@ -509,7 +509,7 @@ function planExport(
             0,
         );
     }
-    if (folding.mutualCount > 0) {
+    if (folding.mutualCount > 0 && csv.table !== "nodes") {
         note(
             CSV_LOSS.MUTUAL_EXPANDED,
             `${folding.mutualCount} mutual pair${plural(folding.mutualCount)} ${agree(folding.mutualCount, "is", "are")} written as two directed rows; the mutual mark is lost`,
@@ -586,7 +586,7 @@ function planExport(
         nodeTableNote(
             [...(nodeLabel === null ? [] : [nodeLabel.meta.name]), ...nodeColumns.map((c) => c.column.meta.name)],
             csv.table,
-            note,
+            notes,
         );
     }
 
@@ -1116,6 +1116,7 @@ function headerlessNotes(plan: Plan): LossNote[] {
             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,
+            columns: Object.freeze([...names]),
         }),
     ];
 }
@@ -1166,7 +1167,10 @@ function headerlessEdgeColumns(plan: Plan): string[] {
 function check(snapshot: GraphSnapshot, options?: CsvExportOptions & CommonExportOptions): readonly LossNote[] {
     const plan = planExport(snapshot, options, true);
     return Object.freeze([
-        ...checkCapabilities(snapshot, CSV_CAPABILITIES, plan.common, { roles: KEPT_ROLES }),
+        ...checkCapabilities(snapshot, CSV_CAPABILITIES, plan.common, {
+            roles: KEPT_ROLES,
+            ...(plan.csv.table === "nodes" ? { tables: ["node"] as const } : {}),
+        }),
         ...plan.notes,
         ...headerlessNotes(plan),
     ]);

package/src/formats/csv/importer.ts

@@ -2016,7 +2016,8 @@ const OTHER_FORMATS: readonly RegExp[] = [
 /**
  * Sniff confidence for the registry: 0 for XML, JSON, GML, DOT (also a leading C comment) and Pajek
  * openings after the leading `#` / `%` comment lines the reader skips, and 0 for a head that is
- * only such comments (the comments of another format, too long to see past); otherwise a
+ * only such comments (the comments of another format, too long to see past), and 0 for text
+ * holding a C0 control character (hasControlCharacter); otherwise a
  * delimited first row with endpoint headers is 0.9 (even when a later row has the wrong width, which
  * the importer reports), with an id header 0.6, and other consistently delimited rows 0.3, except
  * rows of more than three space-separated words, which is plain text such as a sentence, not a
@@ -2033,7 +2034,7 @@ function sniff(head: Uint8Array): number {
     }
     // the decoder drops the BOM it was chosen by; the reader skips leading comment lines
     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))) {
+    if (body.trim().length === 0 || hasControlCharacter(body) || OTHER_FORMATS.some((r) => r.test(body))) {
         return 0;
     }
     const newline = sniffNewline(body);
@@ -2060,6 +2061,24 @@ function sniff(head: Uint8Array): number {
     return looksLikeProse(body, newline, delimiter) ? 0 : 0.3;
 }
 
+/**
+ * Whether text holds a C0 control character other than TAB, LF and CR (a final Ctrl-Z, the DOS
+ * end-of-file marker, aside): such text is binary data or another format, never a CSV a reader
+ * means to load, so it is only read as CSV when the caller names the format.
+ * @param text - the decoded head
+ * @returns whether it holds one
+ */
+function hasControlCharacter(text: string): boolean {
+    const last = text.length - 1;
+    for (let i = 0; i <= last; i++) {
+        const c = text.codePointAt(i) ?? 0;
+        if (c < 0x20 && c !== 0x09 && c !== 0x0a && c !== 0x0d && !(c === 0x1a && i === last)) {
+            return true;
+        }
+    }
+    return false;
+}
+
 /** A cell that reads as part of a sentence: words with a sentence end after a letter (`Monday.`, `world. Thanks`). */
 const SENTENCE = /[A-Za-z]{2}[.!?](?:\s|$)/;
 

package/src/formats/cx2/exporter.ts

@@ -270,18 +270,26 @@ function planAttributes(
     return plans;
 }
 
+/** A note-recording callback. */
+type Note = (code: string, message: string, column?: string | null, count?: number | null) => void;
+
 /**
- * Plan an export: the notes, the fatal condition and what is written.
+ * The generic notes of checkCapabilities(), adapted to CX2: bypass columns hold any JSON value,
+ * ids are counted by planNodeIds(), nested values are written as JSON text, and only the node
+ * label is written into the "n" slot (an edge label keeps its own name but loses its role).
  * @param snapshot - the snapshot
  * @param common - the resolved common options
- * @returns the plan
+ * @param notes - the notes so far, appended to
+ * @param note - the recorder
+ * @returns the fatal condition, or null
  */
-function plan(snapshot: GraphSnapshot, common: ResolvedExportOptions): Plan {
-    const notes: LossNote[] = [];
+function capabilityNotes(
+    snapshot: GraphSnapshot,
+    common: ResolvedExportOptions,
+    notes: LossNote[],
+    note: Note,
+): GraphFormatError | null {
     let fatal: GraphFormatError | null = null;
-    const note = (code: string, message: string, column: string | null = null, count: number | null = null): void => {
-        notes.push(Object.freeze({ code, message, column, count }));
-    };
     // bypass columns are written as bypasses, which hold any JSON value
     const bypassNames = new Set(
         [...snapshot.nodes, ...snapshot.edges].filter((c) => isBypass(c) || isZ(c)).map((c) => c.meta.name),
@@ -290,11 +298,7 @@ function plan(snapshot: GraphSnapshot, common: ResolvedExportOptions): Plan {
         roles: SLOT_ROLES,
         roleNames: ROLE_NAMES,
     })) {
-        if (gen.column !== null && bypassNames.has(gen.column) && (gen.code === LOSS.JSON || gen.code === LOSS.DTYPE)) {
-            continue;
-        }
-        if (gen.code === LOSS.ID_CHARSET || gen.code === LOSS.ID_MANGLED) {
-            // counted below: CX2 also keeps integer ids beyond 2^53, which the generic rule refuses
+        if (!keepGenericNote(gen, bypassNames)) {
             continue;
         }
         if (gen.code === LOSS.JSON) {
@@ -311,27 +315,83 @@ function plan(snapshot: GraphSnapshot, common: ResolvedExportOptions): Plan {
         }
         notes.push(gen);
     }
+    const edgeLabel = snapshot.edges.byRole("label");
+    if (edgeLabel !== null) {
+        note(
+            LOSS.ROLE,
+            `edge column "${edgeLabel.meta.name}" (label) is written as a plain attribute; CX2 edges have no label slot and the role is lost`,
+            edgeLabel.meta.name,
+            edgeLabel.length - edgeLabel.nullCount,
+        );
+    }
+    return fatal;
+}
 
-    const folding = pairFolding(snapshot);
-    directionNotes(snapshot, folding, common, CX2_LOSS.UNDIRECTED_AS_DIRECTED, note);
+/**
+ * Whether a generic note applies to CX2 as it stands.
+ * @param gen - the generic note
+ * @param bypassNames - the names of the columns written as bypasses
+ * @returns false for a note CX2 drops or replaces
+ */
+function keepGenericNote(gen: LossNote, bypassNames: ReadonlySet<string>): boolean {
+    if (gen.column !== null && bypassNames.has(gen.column) && (gen.code === LOSS.JSON || gen.code === LOSS.DTYPE)) {
+        return false;
+    }
+    if (gen.code === LOSS.COLUMN_NAME_CHANGED && gen.message.startsWith("edge column")) {
+        // only the node label is written into the "n" slot; an edge label keeps its own name
+        return false;
+    }
+    // ids are counted by planNodeIds(): CX2 also keeps integer ids beyond 2^53, which the generic rule refuses
+    return gen.code !== LOSS.ID_CHARSET && gen.code !== LOSS.ID_MANGLED;
+}
 
-    const planned = planNodeIds(snapshot, common, "CX2", ORIGINAL_ID_ATTRIBUTE, note);
-    const ids = planned instanceof GraphFormatError ? null : planned;
-    if (planned instanceof GraphFormatError) {
-        fatal ??= planned;
+/**
+ * Note the NaN and infinite values written as null: attribute cells, explicit weights, positions.
+ * @param snapshot - the snapshot
+ * @param attrs - every planned attribute
+ * @param weights - the explicit weights
+ * @param position - the position column, or null
+ * @param note - the recorder
+ */
+function nonFiniteNote(
+    snapshot: GraphSnapshot,
+    attrs: readonly AttributePlan[],
+    weights: ExplicitWeights,
+    position: Column | null,
+    note: Note,
+): void {
+    let nonfinite = 0;
+    for (const p of attrs) {
+        nonfinite += nonFiniteCount(p.column);
+    }
+    for (let e = 0; e < snapshot.edgeCount; e++) {
+        if (weights.isExplicit(e) && !Number.isFinite(weights.value(e))) {
+            nonfinite++;
+        }
     }
+    if (position !== null) {
+        nonfinite += nonFinitePositions(position);
+    }
+    if (nonfinite > 0) {
+        note(
+            CX2_LOSS.NONFINITE_AS_NULL,
+            `${nonfinite} NaN or infinite value${plural(nonfinite)} cannot be written in CX2; written as null, they read back unset`,
+            null,
+            nonfinite,
+        );
+    }
+}
 
-    const weights = explicitWeights(snapshot);
-    const label = snapshot.nodes.byRole("label");
-    const nodeAttrs = planAttributes(
-        snapshot.nodes,
-        (c) => (c.meta.role !== null && SKIPPED_ROLES.has(c.meta.role)) || isBypass(c) || isZ(c),
-        (c) => (c === label && !snapshot.nodes.has("name") ? "name" : c.meta.name),
-        ids !== null && ids.changed > 0 ? new Set([ORIGINAL_ID_ATTRIBUTE]) : new Set(),
-    );
+/**
+ * Plan the edge attributes, noting a plain `weight` column that clashes with the weight key.
+ * @param snapshot - the snapshot
+ * @param weights - the explicit weights
+ * @param note - the recorder
+ * @returns the edge attribute plans
+ */
+function planEdgeAttributes(snapshot: GraphSnapshot, weights: ExplicitWeights, note: Note): AttributePlan[] {
     const plainWeight = snapshot.edges.get(WEIGHT_ATTRIBUTE);
-    const weightColumnClash = plainWeight !== null && plainWeight.meta.role === null;
-    if (weightColumnClash) {
+    if (plainWeight !== null && plainWeight.meta.role === null) {
         note(
             LOSS.WEIGHT_KEY_CLASH,
             weights.weighted
@@ -341,7 +401,7 @@ function plan(snapshot: GraphSnapshot, common: ResolvedExportOptions): Plan {
             null,
         );
     }
-    const edgeAttrs = planAttributes(
+    return planAttributes(
         snapshot.edges,
         (c) =>
             (c.meta.role !== null && (SKIPPED_ROLES.has(c.meta.role) || c.meta.role === "id")) ||
@@ -350,33 +410,47 @@ function plan(snapshot: GraphSnapshot, common: ResolvedExportOptions): Plan {
         (c) => c.meta.name,
         weights.weighted ? new Set([WEIGHT_ATTRIBUTE]) : new Set(),
     );
+}
+
+/**
+ * Plan an export: the notes, the fatal condition and what is written.
+ * @param snapshot - the snapshot
+ * @param common - the resolved common options
+ * @returns the plan
+ */
+function plan(snapshot: GraphSnapshot, common: ResolvedExportOptions): Plan {
+    const notes: LossNote[] = [];
+    const note: Note = (code, message, column = null, count = null) => {
+        notes.push(Object.freeze({ code, message, column, count }));
+    };
+    let fatal = capabilityNotes(snapshot, common, notes, note);
+
+    const folding = pairFolding(snapshot);
+    directionNotes(snapshot, folding, common, CX2_LOSS.UNDIRECTED_AS_DIRECTED, note);
+
+    const planned = planNodeIds(snapshot, common, "CX2", ORIGINAL_ID_ATTRIBUTE, note);
+    const ids = planned instanceof GraphFormatError ? null : planned;
+    if (planned instanceof GraphFormatError) {
+        fatal ??= planned;
+    }
+
+    const weights = explicitWeights(snapshot);
+    const label = snapshot.nodes.byRole("label");
+    const nodeAttrs = planAttributes(
+        snapshot.nodes,
+        (c) => (c.meta.role !== null && SKIPPED_ROLES.has(c.meta.role)) || isBypass(c) || isZ(c),
+        (c) => (c === label && !snapshot.nodes.has("name") ? "name" : c.meta.name),
+        ids !== null && ids.changed > 0 ? new Set([ORIGINAL_ID_ATTRIBUTE]) : new Set(),
+    );
+    const edgeAttrs = planEdgeAttributes(snapshot, weights, note);
     const graphAttrs = planAttributes(
         snapshot.graph,
         () => false,
         (c) => c.meta.name,
     ).map((p) => ({ ...p, key: p.name }));
 
-    let nonfinite = 0;
-    for (const p of [...nodeAttrs, ...edgeAttrs, ...graphAttrs]) {
-        nonfinite += nonFiniteCount(p.column);
-    }
-    for (let e = 0; e < snapshot.edgeCount; e++) {
-        if (weights.isExplicit(e) && !Number.isFinite(weights.value(e))) {
-            nonfinite++;
-        }
-    }
     const position = snapshot.nodes.byRole("position");
-    if (position !== null) {
-        nonfinite += nonFinitePositions(position);
-    }
-    if (nonfinite > 0) {
-        note(
-            CX2_LOSS.NONFINITE_AS_NULL,
-            `${nonfinite} NaN or infinite value${plural(nonfinite)} cannot be written in CX2; written as null, they read back unset`,
-            null,
-            nonfinite,
-        );
-    }
+    nonFiniteNote(snapshot, [...nodeAttrs, ...edgeAttrs, ...graphAttrs], weights, position, note);
 
     const edgeIds = planEdgeIds(snapshot, note);
     const z = [...snapshot.nodes].find(isZ) ?? null;

package/src/formats/dot/exporter.ts

@@ -377,6 +377,11 @@ class ExportPlan {
 
     private readonly targetPort: Column | null;
 
+    /** The node and edge label role columns, written under `label` whatever their name. */
+    private readonly nodeLabel: Column | null;
+
+    private readonly edgeLabel: Column | null;
+
     private readonly children: ChildrenCsr;
 
     private readonly extraNotes: LossNote[] = [];
@@ -417,6 +422,8 @@ class ExportPlan {
         this.folding = pairFolding(snapshot);
         this.sourcePort = edges.byRole("sourcePort");
         this.targetPort = edges.byRole("targetPort");
+        this.nodeLabel = nodes.byRole("label");
+        this.edgeLabel = edges.byRole("label");
         this.nodeColumns = [...nodes].filter((c) => this.writesNodeColumn(c));
         this.edgeColumns = [...edges].filter((c) => this.writesEdgeColumn(c));
         this.graphColumns = [...graph].filter(
@@ -444,7 +451,7 @@ class ExportPlan {
             this.clash("node", name, "the position role is written as pos");
             return false;
         }
-        return true;
+        return this.labelFree("node", column, this.nodeLabel);
     }
 
     /**
@@ -468,7 +475,23 @@ class ExportPlan {
             this.clash("edge", name, "the weight is written as weight");
             return false;
         }
-        return true;
+        return this.labelFree("edge", column, this.edgeLabel);
+    }
+
+    /**
+     * Whether a column may be written: false (reported) for a plain `label` column when the label
+     * role column is named otherwise, since that one is written as `label`.
+     * @param domain - the table
+     * @param column - the column
+     * @param labelRole - the table's label role column, or null
+     * @returns true when written
+     */
+    private labelFree(domain: string, column: Column, labelRole: Column | null): boolean {
+        if (column.meta.name !== LABEL_ATTRIBUTE || labelRole === null || labelRole === column) {
+            return true;
+        }
+        this.clash(domain, column.meta.name, "the label role is written as label");
+        return false;
     }
 
     /**
@@ -703,7 +726,7 @@ class ExportPlan {
         }
         for (const columns of [this.nodeColumns, this.edgeColumns, this.graphColumns]) {
             for (const column of columns) {
-                visit(column.meta.name, "attribute name");
+                visit(this.attributeName(column), "attribute name");
                 if (column.dtype === "string" || column.dtype === "dict") {
                     for (let r = 0; r < column.length; r++) {
                         if (column.isSet(r)) {
@@ -844,6 +867,16 @@ class ExportPlan {
         return parts.join(",");
     }
 
+    /**
+     * The attribute a column is written as: `label` for a node or edge label role column (the
+     * importer gives that attribute the role back), the column name otherwise.
+     * @param column - the column
+     * @returns the attribute name
+     */
+    private attributeName(column: Column): string {
+        return column === this.nodeLabel || column === this.edgeLabel ? LABEL_ATTRIBUTE : column.meta.name;
+    }
+
     /**
      * The `name=value` attributes of one row over a column list (set cells only).
      * @param columns - the columns
@@ -858,7 +891,7 @@ class ExportPlan {
             }
             const text = cellText(column, row);
             if (text !== null) {
-                out.push(`${quoteDotId(column.meta.name)}=${writeId(text)}`);
+                out.push(`${quoteDotId(this.attributeName(column))}=${writeId(text)}`);
             }
         }
         return out;

package/src/formats/dot/importer.ts

@@ -514,7 +514,7 @@ function countGraphs(lexer: DotTokenizer, first: DotToken): number {
         if (!isPunct(token, "{")) {
             throw new DotSyntaxError(`expected "{" after the graph header, found ${describeToken(token)}`, token.line);
         }
-        for (let depth = 1; depth > 0; ) {
+        for (let depth = 1; depth > 0;) {
             token = lexer.next();
             if (token.kind === "eof") {
                 throw new DotSyntaxError('missing "}" at the end of a graph', token.line);