@graphty/graph-io 0.3.24 → 0.3.26

package/dist/src/formats/cx/importer.js

@@ -22,40 +22,47 @@
  */
 import { INVALID_INDEX, } from "@graphty/graph-format";
 import { declareResolved, uniqueColumnName } from "../../common/attributes.js";
-import { AMBIGUOUS_GRAPH_NAME_CODE, ASPECT_ORDER_CODE, BAD_ASPECT_BLOCK_CODE, BAD_VALUE_CODE, COLUMN_RENAMED_CODE, COUNT_MISMATCH_CODE, DANGLING_REFERENCE_CODE, DIRECTION_FORCED_CODE, DIRECTION_REFUSED_CODE, DUPLICATE_ATTRIBUTE_CODE, DUPLICATE_EDGE_ID_CODE, DUPLICATE_NODE_CODE, EMPTY_INPUT_CODE, ENCODING_FALLBACK_CODE, GRAPH_NOT_FOUND_CODE, ID_MERGED_CODE, ID_TEXT_TYPE_CODE, INVALID_ENCODING_CODE, INVALID_UTF8_CODE, MISSING_ENDPOINT_CODE, MISSING_ID_CODE, MULTIPLE_GRAPHS_CODE, NO_GRAPH_CODE, OPTION_IGNORED_CODE, PARENT_CYCLE_CODE, PRECISION_CODE, ROLE_TAKEN_CODE, SINK_OPTION_CODE, STATUS_FAILED_CODE, STATUS_WARNING_CODE, STYLES_NOT_IMPORTED_CODE, SYNTAX_CODE, TOO_LARGE_CODE, UNKNOWN_ATTR_TYPE_CODE, UNKNOWN_ENCODING_CODE, UNKNOWN_PARENT_CODE, WIDENED_CODE, } from "../../common/codes.js";
+import { AMBIGUOUS_GRAPH_NAME_CODE, ASPECT_ORDER_CODE, BAD_ASPECT_BLOCK_CODE, BAD_VALUE_CODE, COLUMN_RENAMED_CODE, COUNT_MISMATCH_CODE, DANGLING_REFERENCE_CODE, DIRECTION_FORCED_CODE, DIRECTION_REFUSED_CODE, DUPLICATE_ATTRIBUTE_CODE, DUPLICATE_EDGE_ID_CODE, DUPLICATE_NODE_CODE, ELEMENT_ISSUE, EMPTY_INPUT_CODE, ENCODING_FALLBACK_CODE, GRAPH_NOT_FOUND_CODE, ID_MERGED_CODE, ID_TEXT_TYPE_CODE, INPUT_ISSUE, INVALID_ENCODING_CODE, INVALID_UTF8_CODE, JSON_NONSTANDARD_NUMBER_CODE, MISSING_ENDPOINT_CODE, MISSING_ID_CODE, MULTI_ASPECT_FRAGMENT_CODE, MULTIPLE_GRAPHS_CODE, NO_GRAPH_CODE, OPTION_IGNORED_CODE, PARENT_CYCLE_CODE, PRECISION_CODE, ROLE_TAKEN_CODE, SINGLE_OBJECT_ASPECT_CODE, SINK_OPTION_CODE, STATUS_FAILED_CODE, STATUS_WARNING_CODE, STYLES_NOT_IMPORTED_CODE, SYNTAX_CODE, TOO_LARGE_CODE, UNKNOWN_ATTR_TYPE_CODE, UNKNOWN_ELEMENT_CODE, UNKNOWN_ENCODING_CODE, UNKNOWN_PARENT_CODE, WIDENED_CODE, } from "../../common/codes.js";
 import { DirectionResolver } from "../../common/direction.js";
 import { IdCoercer } from "../../common/ids.js";
 import { textChunks, throwIfAborted } from "../../common/input.js";
-import { cxId, CxStructure, declareFresh, ExactInteger, flipY, inexactLiteral, isRecord, JsonScanError, plainJson, positionDecl, reportTooDeep, scanAspects, zDecl, } from "../../common/json-elements.js";
-import { chooseGraph, reportSinkOptions, reportUnusedOptions, resolveImportOptions, } from "../../common/options.js";
+import { cxId, CxStructure, declareFresh, ExactInteger, fitsF32, flipY, headText, inexactLiteral, isRecord, JsonScanError, keptPrecision, plainJson, positionDecl, reportSharedBlock, reportTooDeep, scanAspects, zDecl, } from "../../common/json-elements.js";
+import { chooseGraph, graphChosen, reportSinkOptions, reportUnusedOptions, resolveImportOptions, } from "../../common/options.js";
+import { agree, plural } from "../../common/plural.js";
 import { ImportReportBuilder } from "../../common/report.js";
 import { weightFromValue } from "../../common/weights.js";
-import { zAsOption } from "../cx2/importer.js";
+import { ORIGINAL_ID_ATTRIBUTE, zAsOption } from "../cx2/importer.js";
 /** The format name. */
 const CX_FORMAT = "cx";
 /** The origin namespace of the per-element visual property columns. */
 const CX_BYPASS_NAMESPACE = "cx.bypass";
 /**
- * The issue codes the CX importer records (design section 1.2), by name: the codes shared with
- * the other importers (src/common/codes.ts) and the CX-specific ones. A key is the code without
+ * The issue codes the CX importer records, by name: the codes shared with
+ * the other importers and the CX-specific ones. A key is the code without
  * its severity and format prefixes.
+ * @category Built-in formats
  */
 export const CX_ISSUE = Object.freeze({
-    /** The input is empty (fatal). */
+    ...INPUT_ISSUE,
+    ...ELEMENT_ISSUE,
+    /** The input is empty. The import stops. */
     EMPTY_INPUT: EMPTY_INPUT_CODE,
-    /** The text is not JSON (fatal). */
+    /** The text is not valid JSON. The import stops. */
     SYNTAX: SYNTAX_CODE,
-    /** 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 or the encoding option chose (fatal). */
+    /**
+     * Some bytes are not valid in the encoding that was chosen (by a byte order mark or the `encoding` option). The
+     * import stops.
+     */
     INVALID_ENCODING: INVALID_ENCODING_CODE,
     /** Bytes that are not UTF-8 were read as windows-1252. */
     ENCODING_FALLBACK: ENCODING_FALLBACK_CODE,
     /** An encoding the platform cannot decode was ignored. */
     UNKNOWN_ENCODING: UNKNOWN_ENCODING_CODE,
-    /** The document is not a CX array, or it is CX2 (fatal; the message names CX2). */
+    /** The document is not a CX array, or it is CX2 (the message says so; read it as `cx2`). The import stops. */
     NOT_CX: "E_CX_NOT_CX",
-    /** numberVerification holds another value than 2^48 - 1, or comes twice. */
+    /** NumberVerification holds another value than 2^48 - 1, or comes twice. */
     NUMBER_VERIFICATION: "W_CX_NUMBER_VERIFICATION",
     /** An old Cytoscape aspect name (visualProperties, subNetworks, ...) read under its cy name. */
     OLD_ASPECT_NAME: "W_CX_OLD_ASPECT_NAME",
@@ -63,11 +70,14 @@ export const CX_ISSUE = Object.freeze({
     GROUP_NODE_ADDED: "W_CX_GROUP_NODE_ADDED",
     /** Nodes or edges of the root network that no subnetwork holds: Cytoscape shows them in no network; not read. */
     ROOT_ONLY: "W_CX_ROOT_ONLY",
-    /** The producer marked the document as failed (fatal). */
+    /** The program that wrote the file marked it as failed, so it is incomplete. The import stops. */
     STATUS_FAILED: STATUS_FAILED_CODE,
-    /** The producer marked the document as successful with an error text. */
+    /** The program that wrote the file marked it as successful but added an error message; the message is shown. */
     STATUS_WARNING: STATUS_WARNING_CODE,
-    /** A member of the array that is not a one-key aspect block, or an element that is not an object. */
+    /**
+     * A member of the file's top-level array that is not a block with one key (`{"nodes": [...]}`), or an element of a
+     * block that is not an object. It is skipped; the rest of the file is read.
+     */
     BAD_ASPECT_BLOCK: BAD_ASPECT_BLOCK_CODE,
     /** An aspect after the post-metadata or after the status, a third metaData. */
     ASPECT_ORDER: ASPECT_ORDER_CODE,
@@ -75,7 +85,10 @@ export const CX_ISSUE = Object.freeze({
     COUNT_MISMATCH: COUNT_MISMATCH_CODE,
     /** A value that does not parse as its data type; the cell is unset. */
     BAD_VALUE: BAD_VALUE_CODE,
-    /** One attribute name with several data types: the column takes the wider one. */
+    /**
+     * An attribute's type was widened because a later value did not fit: an integer above 2^31 in an integer column,
+     * or two declared types for one attribute.
+     */
     WIDENED: WIDENED_CODE,
     /** A data type CX does not define; the value is kept as text. */
     UNKNOWN_ATTR_TYPE: UNKNOWN_ATTR_TYPE_CODE,
@@ -87,9 +100,9 @@ export const CX_ISSUE = Object.freeze({
     UNKNOWN_PARENT: UNKNOWN_PARENT_CODE,
     /** A group membership that would close a parent cycle; dropped. */
     PARENT_CYCLE: PARENT_CYCLE_CODE,
-    /** The style rules of cyVisualProperties are not applied (issue #706). */
+    /** The style rules of cyVisualProperties are not applied; they are kept so a CX export writes them back. */
     STYLES_NOT_IMPORTED: STYLES_NOT_IMPORTED_CODE,
-    /** A node without an @id. */
+    /** A node without an id (its `@id` key). The node is skipped. */
     MISSING_ID: MISSING_ID_CODE,
     /** An edge without s or t. */
     MISSING_ENDPOINT: MISSING_ENDPOINT_CODE,
@@ -99,37 +112,63 @@ export const CX_ISSUE = Object.freeze({
     DUPLICATE_EDGE_ID: DUPLICATE_EDGE_ID_CODE,
     /** An id that is not an integer. */
     INVALID_ID: "E_INVALID_ID",
+    /**
+     * A node or edge key CX does not define, an aspect graph-io keeps for writing back, or a table CX does not define;
+     * it is skipped.
+     */
+    UNKNOWN_ELEMENT: UNKNOWN_ELEMENT_CODE,
+    /** A member holding several aspects; each array-valued key is read as its own fragment. */
+    MULTI_ASPECT_FRAGMENT: MULTI_ASPECT_FRAGMENT_CODE,
+    /** An aspect written as one object, not an array of elements; read as one element. */
+    SINGLE_OBJECT_ASPECT: SINGLE_OBJECT_ASPECT_CODE,
+    /** The bare tokens NaN / Infinity / -Infinity (Python's json writes them), read as numbers. */
+    JSON_NONSTANDARD_NUMBER: JSON_NONSTANDARD_NUMBER_CODE,
     /** An edge endpoint naming no node of the graph (addMissingNodes false, the default). */
     UNKNOWN_NODE: "E_UNKNOWN_NODE",
     /** A weight that is not a number. */
     INVALID_WEIGHT: "E_INVALID_WEIGHT",
     /** An id spelled as a string or a non-integer literal; read as the integer. */
     ID_TEXT_TYPE: ID_TEXT_TYPE_CODE,
-    /** An integer beyond 2^53: an id kept as its digits, a value stored as the nearest f64. */
+    /** An integer beyond 2^53 was stored as the nearest 64-bit float; pass `long: "string"` to keep every digit. */
     PRECISION: PRECISION_CODE,
     /** Two id texts merged under `ids: "number"`. */
     ID_MERGED: ID_MERGED_CODE,
-    /** A collection read by import(): the other subnetworks are skipped. */
+    /**
+     * The file holds several graphs and only the first was read. It is not added when `graphIndex` or `graphName` chose the graph.
+     * `importAllGraphs()` reads every one.
+     */
     MULTIPLE_GRAPHS: MULTIPLE_GRAPHS_CODE,
-    /** graphIndex or graphName names no subnetwork (fatal). */
+    /** `graphIndex` or `graphName` matches no subnetwork. The import stops. */
     GRAPH_NOT_FOUND: GRAPH_NOT_FOUND_CODE,
-    /** graphName names several subnetworks (fatal). */
+    /** `graphName` matches several subnetworks. The import stops. */
     AMBIGUOUS_GRAPH_NAME: AMBIGUOUS_GRAPH_NAME_CODE,
-    /** The input holds no graph (fatal). */
+    /** The input holds no graph. The import stops. */
     NO_GRAPH: NO_GRAPH_CODE,
-    /** A column renamed because its name was taken. */
+    /**
+     * An attribute was renamed `<name>#<suffix>` because another attribute already has its name, for example
+     * two attributes declared with the same name.
+     */
     COLUMN_RENAMED: COLUMN_RENAMED_CODE,
-    /** A column that lost its role because another column holds it. */
+    /**
+     * 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,
-    /** The sink refused the 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 common option CX has no use for. */
+    /** 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 option the caller's 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 input is beyond a size limit (fatal). */
+    /** The input is larger than graph-io's size limit. The import stops. */
     TOO_LARGE: TOO_LARGE_CODE,
 });
 const USED_OPTIONS = new Set([
@@ -141,6 +180,7 @@ const USED_OPTIONS = new Set([
     "weightFrom",
     "weightDtype",
     "long",
+    "restoreMangledIds",
     "errorLimit",
     "signal",
     "onProgress",
@@ -156,12 +196,18 @@ const ABORT_CHECK_INTERVAL = 64;
 /** The numberVerification values a reader accepts: 2^48 - 1 and Java's Long.MAX_VALUE. */
 const NUMBER_VERIFICATION_VALUES = new Set(["281474976710655", "9223372036854775807"]);
 /** Old Cytoscape aspect names and the names they are read under. */
-const OLD_ASPECT_NAMES = {
-    visualProperties: "cyVisualProperties",
-    subNetworks: "cySubNetworks",
-    networkRelations: "cyNetworkRelations",
-    hiddenAttributes: "cyHiddenAttributes",
-};
+const OLD_ASPECT_NAMES = new Map([
+    ["visualProperties", "cyVisualProperties"],
+    ["subNetworks", "cySubNetworks"],
+    ["networkRelations", "cyNetworkRelations"],
+    ["hiddenAttributes", "cyHiddenAttributes"],
+]);
+/** The keys a nodes element defines. */
+const NODE_KEYS = new Set(["@id", "n", "r"]);
+/** The keys an edges element defines. */
+const EDGE_KEYS = new Set(["@id", "s", "t", "i"]);
+/** The tables cyTableColumn applies to. */
+const TABLES = new Set(["node_table", "edge_table", "network_table"]);
 /** The aspects the importer reads into the graph (everything else is kept verbatim). */
 const READ_ASPECTS = new Set([
     "nodes",
@@ -200,6 +246,8 @@ const ALSO_KEPT = new Set([
 ]);
 /** Cytoscape's table-cell style aspects (both spellings): style rules, kept and reported, never read. */
 const TABLE_STYLE_ASPECTS = ["tableVisualProperties", "cyTableVisualProperties"];
+/** The importer's own entries of meta.extra.cx, which an aspect of the same name would collide with. */
+const OWN_EXTRA_KEYS = ["groups", "subnetwork"];
 /** The first keys that make a head CX for sure, and the other aspect names a CX document may start with. */
 const CX_FIRST_KEYS = ["numberVerification", "metaData"];
 const CX_ASPECT_KEYS = [
@@ -228,14 +276,14 @@ const CX_ASPECT_KEYS = [
     "functionTerms",
 ];
 /** The CX data types, with the Java reader's float aliases. */
-const SCALARS = {
-    string: "string",
-    boolean: "boolean",
-    integer: "integer",
-    long: "long",
-    double: "double",
-    float: "double",
-};
+const SCALARS = new Map([
+    ["string", "string"],
+    ["boolean", "boolean"],
+    ["integer", "integer"],
+    ["long", "long"],
+    ["double", "double"],
+    ["float", "double"],
+]);
 /**
  * Resolve a `d` value.
  * @param d - the data type (undefined: string)
@@ -249,7 +297,7 @@ function cxType(d) {
         return null;
     }
     const list = d.startsWith("list_of_");
-    const scalar = SCALARS[list ? d.slice("list_of_".length) : d];
+    const scalar = SCALARS.get(list ? d.slice("list_of_".length) : d);
     return scalar === undefined ? null : { scalar, list };
 }
 /**
@@ -367,7 +415,15 @@ function parseScalar(value, scalar, long, onPrecision) {
             if (value === "Infinity" || value === "-Infinity") {
                 return Number(value);
             }
-            return DECIMAL_TEXT.test(value) ? Number(value) : BAD;
+            if (!DECIMAL_TEXT.test(value)) {
+                return BAD;
+            }
+            const n = Number(value);
+            if (!Number.isFinite(n)) {
+                // beyond the range of a double: Java's parseDouble gives Infinity too, but say so
+                onPrecision(value);
+            }
+            return n;
         }
     }
 }
@@ -492,15 +548,16 @@ function aspect(doc, name) {
  * The inexact-literal bits of an element.
  * @param text - the element's JSON text
  * @param keys - the id keys to check, bit 1, 2, 4 in order
+ * @param depth - the depth of the element's own keys in the text (2: a member's single object)
  * @returns the bits
  */
-function inexactBits(text, keys) {
+function inexactBits(text, keys, depth = 1) {
     if (!/[0-9][.eE]/.test(text)) {
         return 0;
     }
     let bits = 0;
     keys.forEach((key, i) => {
-        if (inexactLiteral(text, key)) {
+        if (inexactLiteral(text, key, depth)) {
             bits |= 1 << i;
         }
     });
@@ -540,6 +597,85 @@ function checkNumberVerification(value, count, report, line) {
             : `numberVerification holds ${shown(raw === undefined ? null : digits)}, not 281474976710655`, { line, element: "numberVerification" });
     }
 }
+/**
+ * Whether an aspect name is one CX (or NDEx, or Cytoscape) defines.
+ * @param name - the aspect name as written
+ * @returns true for a known aspect
+ */
+function isCxAspect(name) {
+    return (READ_ASPECTS.has(name) ||
+        OLD_ASPECT_NAMES.has(name) ||
+        CX_ASPECT_KEYS.includes(name) ||
+        TABLE_STYLE_ASPECTS.includes(name));
+}
+/** The id keys of the aspects whose ids are checked for precision. */
+const ID_KEYS = new Map([
+    ["nodes", ["@id"]],
+    ["edges", ["@id", "s", "t"]],
+]);
+/**
+ * File an attribute element by its attribute name n; one without a usable name is reported and skipped.
+ * @param table - the aspect's attribute table
+ * @param name - the aspect
+ * @param held - the element
+ * @param report - the report
+ */
+function fileAttribute(table, name, held, report) {
+    const { value, line } = held;
+    const n = isRecord(value) ? value.n : undefined;
+    if (n === undefined || n === null) {
+        report.error("missing-value", MISSING_ID_CODE, `a ${name} element has no attribute name n; skipped`, {
+            line,
+            element: name,
+        });
+        return;
+    }
+    if (typeof n !== "string" || n === "") {
+        report.error("validation-error", BAD_VALUE_CODE, `a ${name} element has the attribute name n ${shown(n)}, not a non-empty string; skipped`, { line, element: name });
+        return;
+    }
+    if (!table.has(n)) {
+        table.set(n, []);
+    }
+    table.get(n)?.push(held);
+}
+/**
+ * File one parsed aspect element: kept verbatim, checked (numberVerification), filed by attribute
+ * name (an attribute element without a usable name n is reported and skipped) or by aspect.
+ * @param state - the document being collected
+ * @param element - the element
+ */
+function collectElement(state, element) {
+    const { doc, report } = state;
+    const { name, value, text, line, exact, depth } = element;
+    doc.structure.element(name, value, line);
+    if (ALSO_KEPT.has(name) || !READ_ASPECTS.has(name)) {
+        if (!doc.kept.has(name)) {
+            doc.kept.set(name, []);
+        }
+        // numberVerification holds Java's Long.MAX_VALUE in every Cytoscape file: checked, never warned
+        const onPrecision = name === "numberVerification" ? undefined : state.onKeptPrecision;
+        doc.kept.get(name)?.push(exact ? plainJson(value, onPrecision) : value);
+    }
+    if (!READ_ASPECTS.has(name) || name === "metaData" || name === "status") {
+        return;
+    }
+    if (name === "numberVerification") {
+        checkNumberVerification(value, ++state.verifications, report, line);
+        return;
+    }
+    const ids = ID_KEYS.get(name);
+    const held = { value, line, inexact: ids === undefined ? 0 : inexactBits(text, ids, depth) };
+    const table = attributeTable(doc, name);
+    if (table !== null) {
+        fileAttribute(table, name, held, report);
+        return;
+    }
+    if (!doc.aspects.has(name)) {
+        doc.aspects.set(name, []);
+    }
+    doc.aspects.get(name)?.push(held);
+}
 /**
  * Read the whole document through the streaming scanner, checking its structure.
  * @param input - the input
@@ -548,76 +684,56 @@ function checkNumberVerification(value, count, report, line) {
  * @returns what was read
  */
 async function readDocument(input, report, options) {
-    const structure = new CxStructure(report);
+    const structure = new CxStructure(report, (name) => OLD_ASPECT_NAMES.get(name) ?? name);
     const doc = {
         aspects: new Map(),
         attributes: { node: new Map(), edge: new Map(), network: new Map() },
         kept: new Map(),
         structure,
     };
+    const state = {
+        doc,
+        report,
+        verifications: 0,
+        onKeptPrecision: keptPrecision(report, "meta.extra.cx"),
+    };
     let sinceCheck = 0;
-    let verifications = 0;
+    let members = 0;
+    let known = 0;
+    const unknownNames = new Set();
+    const lastMember = { block: -1 };
+    const countMember = (block, name) => {
+        if (block !== lastMember.block) {
+            lastMember.block = block;
+            members++;
+        }
+        if (name !== null && isCxAspect(name)) {
+            known++;
+        }
+        else if (name !== null) {
+            unknownNames.add(name);
+        }
+    };
     const canonical = (name, line) => {
-        const renamed = OLD_ASPECT_NAMES[name];
+        const renamed = OLD_ASPECT_NAMES.get(name);
         if (renamed === undefined) {
             return name;
         }
         report.warnOnce("coercion", CX_ISSUE.OLD_ASPECT_NAME, `the old aspect name "${name}" is read as "${renamed}"`, { line, element: name }, `${CX_ISSUE.OLD_ASPECT_NAME}:${name}`);
         return renamed;
     };
-    const collect = (name, value, text, line, exact) => {
-        structure.element(name, value, line);
-        if (ALSO_KEPT.has(name) || !READ_ASPECTS.has(name)) {
-            if (!doc.kept.has(name)) {
-                doc.kept.set(name, []);
-            }
-            doc.kept.get(name)?.push(exact ? plainJson(value) : value);
-        }
-        if (!READ_ASPECTS.has(name) || name === "metaData" || name === "status") {
-            return;
-        }
-        if (name === "numberVerification") {
-            checkNumberVerification(value, ++verifications, report, line);
-            return;
-        }
-        let inexact = 0;
-        if (name === "nodes") {
-            inexact = inexactBits(text, ["@id"]);
-        }
-        else if (name === "edges") {
-            inexact = inexactBits(text, ["@id", "s", "t"]);
-        }
-        const held = { value, line, inexact };
-        const table = attributeTable(doc, name);
-        if (table !== null) {
-            if (!isRecord(value) || typeof value.n !== "string") {
-                report.error("missing-value", MISSING_ID_CODE, `a ${name} element has no attribute name n; skipped`, {
-                    line,
-                    element: name,
-                });
-                return;
-            }
-            const key = value.n;
-            if (!table.has(key)) {
-                table.set(key, []);
-            }
-            table.get(key)?.push(held);
-            return;
-        }
-        if (!doc.aspects.has(name)) {
-            doc.aspects.set(name, []);
-        }
-        doc.aspects.get(name)?.push(held);
+    const collect = (name, value, text, line, exact, depth = 1) => {
+        collectElement(state, { name, value, text, line, exact, depth });
     };
     try {
-        for await (const event of scanAspects(textChunks(input, report, options))) {
+        for await (const event of scanAspects(textChunks(input, report, options), report)) {
             if (++sinceCheck >= ABORT_CHECK_INTERVAL) {
                 sinceCheck = 0;
                 throwIfAborted(options.signal);
             }
             switch (event.kind) {
                 case "root":
-                    report.fail(CX_ISSUE.NOT_CX, `a CX document is a JSON array of aspects; found ${isRecord(event.value) ? "an object" : shown(event.value)}`, { line: event.line });
+                    report.fail(CX_ISSUE.NOT_CX, `a CX document is a JSON array of aspects; found ${event.object ? "an object" : shown(event.value)}`, { line: event.line });
                     break;
                 case "member": {
                     const { value } = event;
@@ -626,27 +742,35 @@ async function readDocument(input, report, options) {
                     }
                     const keys = isRecord(value) ? Object.keys(value) : [];
                     if (isRecord(value) && keys.length === 1 && isRecord(value[keys[0]])) {
+                        countMember(event.block, keys[0]);
                         const name = canonical(keys[0], event.line);
+                        if (isCxAspect(name)) {
+                            report.warning("validation-error", CX_ISSUE.SINGLE_OBJECT_ASPECT, `the "${keys[0]}" aspect is one object, not an array of elements; read as one element`, { line: event.line, element: keys[0] });
+                        }
                         structure.block(name, event.line);
-                        collect(name, value[keys[0]], "", event.line, event.exact);
+                        collect(name, value[keys[0]], event.text, event.line, event.exact, 2);
                         break;
                     }
+                    countMember(event.block, null);
                     report.error("parse-error", BAD_ASPECT_BLOCK_CODE, `a member of the document is ${keys.length > 1 ? `an object with ${keys.length} keys (${keys.join(", ")})` : shown(value)}, not a one-key aspect fragment; skipped`, { line: event.line, element: keys[0] ?? null });
                     break;
                 }
                 case "block":
+                    countMember(event.block, event.aspect);
+                    reportSharedBlock(report, event);
                     structure.block(canonical(event.aspect, event.line), event.line);
                     break;
                 case "element": {
-                    const name = OLD_ASPECT_NAMES[event.aspect] ?? event.aspect;
+                    const name = OLD_ASPECT_NAMES.get(event.aspect) ?? event.aspect;
                     collect(name, event.value, event.text, event.line, event.exact);
                     break;
                 }
                 case "deep":
+                    countMember(event.block, event.aspect);
                     reportTooDeep(report, event);
                     break;
                 case "extraKeys":
-                    report.error("parse-error", BAD_ASPECT_BLOCK_CODE, `the "${event.aspect}" fragment holds more keys (${event.keys.join(", ")}); a fragment has one key, the others are skipped`, { line: event.line, element: event.aspect });
+                    report.error("parse-error", BAD_ASPECT_BLOCK_CODE, `the "${event.aspect}" fragment holds more keys (${event.keys.join(", ")}) whose values are not arrays; a fragment has one key, the others are skipped`, { line: event.line, element: event.aspect });
                     break;
                 default:
                     break;
@@ -659,6 +783,15 @@ async function readDocument(input, report, options) {
         }
         throw err;
     }
+    if (members > 0 && known === 0) {
+        const found = [...unknownNames].slice(0, 5).map((n) => JSON.stringify(n));
+        const hint = unknownNames.has("data") ? ": Cytoscape.js elements?" : "";
+        const seen = found.length > 0 ? ` (found ${found.join(", ")}${hint})` : "";
+        report.fail(CX_ISSUE.NOT_CX, `no member of the array is a CX aspect${seen}; the input is not CX`);
+    }
+    if (structure.hasStatus && !structure.statusWellFormed()) {
+        report.error("validation-error", BAD_VALUE_CODE, `the status element is ${shown(structure.status ?? null)}, not an object with a boolean success; ignored`, { element: "status" });
+    }
     structure.checkCounts();
     return doc;
 }
@@ -676,11 +809,13 @@ function refId(raw) {
     }
 }
 /**
- * A member list: the ids of an array, or null for "all".
+ * A member list: the ids of an array, or null for "all" (an absent list is empty).
  * @param raw - the list
+ * @param onBad - told about a list that is neither an array nor "all" (BAD_VALUE) and about a
+ * member that is not an id (INVALID_ID)
  * @returns the set, or null for every element
  */
-function memberSet(raw) {
+function memberSet(raw, onBad) {
     if (raw === "all") {
         return null;
     }
@@ -688,86 +823,64 @@ function memberSet(raw) {
     if (Array.isArray(raw)) {
         for (const item of raw) {
             const id = refId(item);
-            if (id !== null) {
+            if (id === null) {
+                onBad?.(CX_ISSUE.INVALID_ID, `the member ${shown(item)} is not an id; ignored`);
+            }
+            else {
                 out.add(id);
             }
         }
     }
+    else if (raw !== undefined) {
+        onBad?.(BAD_VALUE_CODE, `the member list ${shown(raw)} is neither a list of ids nor "all"; read as empty`);
+    }
     return out;
 }
 /**
- * The graphs of a document, in the order Cytoscape opens them.
- * @param doc - the document
- * @returns one plan per graph (at least one)
+ * The id of an element of a structural aspect (cySubNetworks, cyViews, cyNetworkRelations), or
+ * null with an issue: E_BAD_ASPECT_BLOCK for an element that is not an object, E_MISSING_ID or
+ * E_INVALID_ID for its id.
+ * @param held - the element
+ * @param name - the aspect
+ * @param key - the id key
+ * @param report - the report
+ * @returns the element and its id, or null
  */
-function graphPlans(doc) {
-    const subs = new Map();
-    for (const { value } of aspect(doc, "cySubNetworks")) {
-        const id = isRecord(value) ? refId(value["@id"]) : null;
-        if (id !== null && isRecord(value) && !subs.has(id)) {
-            subs.set(id, { nodes: memberSet(value.nodes), edges: memberSet(value.edges) });
-        }
-    }
-    const relationNames = new Map();
-    const order = [];
-    const views = new Map();
-    const addView = (sub, view) => {
-        const list = views.get(sub) ?? [];
-        if (!list.includes(view)) {
-            list.push(view);
-        }
-        views.set(sub, list);
-    };
-    for (const { value } of aspect(doc, "cyNetworkRelations")) {
-        if (!isRecord(value)) {
-            continue;
-        }
-        const child = refId(value.c);
-        if (child === null) {
-            continue;
-        }
-        if (value.r === "view") {
-            const parent = refId(value.p);
-            if (parent !== null) {
-                addView(parent, child);
-            }
-            continue;
-        }
-        if (typeof value.name === "string") {
-            relationNames.set(child, value.name);
-        }
-        if (subs.has(child) && !order.includes(child)) {
-            order.push(child);
-        }
+function structuralId(held, name, key, report) {
+    const { value, line } = held;
+    if (!isRecord(value)) {
+        report.error("parse-error", BAD_ASPECT_BLOCK_CODE, `a ${name} element is ${shown(value)}, not an object; skipped`, {
+            line,
+            element: name,
+        });
+        return null;
     }
-    for (const { value } of aspect(doc, "cyViews")) {
-        const view = isRecord(value) ? refId(value["@id"]) : null;
-        const sub = isRecord(value) ? refId(value.s) : null;
-        if (view !== null && sub !== null) {
-            addView(sub, view);
-        }
+    if (value[key] === undefined || value[key] === null) {
+        report.error("missing-value", MISSING_ID_CODE, `a ${name} element has no ${key}; skipped`, {
+            line,
+            element: name,
+        });
+        return null;
     }
-    for (const id of subs.keys()) {
-        if (!order.includes(id)) {
-            order.push(id);
-        }
+    const id = refId(value[key]);
+    if (id === null) {
+        report.error("validation-error", CX_ISSUE.INVALID_ID, `a ${name} element has the ${key} ${shown(value[key])}, not an integer id; skipped`, {
+            line,
+            element: name,
+        });
+        return null;
     }
-    const networkName = (sub) => {
-        let found = null;
-        for (const { value } of doc.attributes.network.get("name") ?? []) {
-            if (!isRecord(value) || typeof value.v !== "string") {
-                continue;
-            }
-            const scope = value.s === undefined ? null : refId(value.s);
-            if (scope === sub) {
-                return value.v;
-            }
-            if (scope === null) {
-                found ?? (found = value.v);
-            }
-        }
-        return found;
-    };
+    return { value, id };
+}
+/**
+ * The graphs of a document, in the order Cytoscape opens them.
+ * @param doc - the document
+ * @param report - where malformed subnetworks, views and relations are recorded
+ * @returns one plan per graph (at least one)
+ */
+function graphPlans(doc, report) {
+    const subs = readSubnetworks(doc, report);
+    const { relationNames, order, views } = readRelations(doc, subs, report);
     if (order.length <= 1) {
         const sub = order.length === 1 ? order[0] : null;
         const members = sub === null ? undefined : subs.get(sub);
@@ -778,10 +891,11 @@ function graphPlans(doc) {
         if (graphViews.length === 0) {
             graphViews = layoutViews(doc);
         }
+        const relationName = sub === null ? null : (relationNames.get(sub) ?? null);
         return [
             {
                 index: 0,
-                name: (sub === null ? null : (relationNames.get(sub) ?? null)) ?? networkName(sub),
+                name: relationName ?? networkName(doc, sub),
                 subnetwork: sub,
                 nodes: members?.nodes ?? null,
                 edges: members?.edges ?? null,
@@ -791,13 +905,125 @@ function graphPlans(doc) {
     }
     return order.map((sub, index) => ({
         index,
-        name: relationNames.get(sub) ?? networkName(sub),
+        name: relationNames.get(sub) ?? networkName(doc, sub),
         subnetwork: sub,
         nodes: subs.get(sub)?.nodes ?? null,
         edges: subs.get(sub)?.edges ?? null,
         views: views.get(sub) ?? [],
     }));
 }
+/**
+ * The subnetworks a document declares (cySubNetworks), by id; a repeated id is reported and skipped.
+ * @param doc - the document
+ * @param report - the report
+ * @returns the subnetworks
+ */
+function readSubnetworks(doc, report) {
+    const subs = new Map();
+    for (const held of aspect(doc, "cySubNetworks")) {
+        const sub = structuralId(held, "cySubNetworks", "@id", report);
+        if (sub === null) {
+            continue;
+        }
+        const { value, id } = sub;
+        if (subs.has(id)) {
+            report.error("validation-error", BAD_ASPECT_BLOCK_CODE, `a second cySubNetworks element has the @id ${String(id)}; skipped, the first is used`, { line: held.line, element: "cySubNetworks" });
+            continue;
+        }
+        const onBad = (code, message) => {
+            report.error("validation-error", code, `subnetwork ${String(id)}: ${message}`, {
+                line: held.line,
+                element: "cySubNetworks",
+            });
+        };
+        subs.set(id, { nodes: memberSet(value.nodes, onBad), edges: memberSet(value.edges, onBad) });
+    }
+    return subs;
+}
+/**
+ * The network relations of a document: each subnetwork's name, the order Cytoscape opens them in
+ * (the relations' order, then the other subnetworks), and each one's views.
+ * @param doc - the document
+ * @param subs - the subnetworks
+ * @param report - the report
+ * @returns the names, the order and the views
+ */
+function readRelations(doc, subs, report) {
+    const relationNames = new Map();
+    const order = [];
+    const views = new Map();
+    const addView = (sub, view) => {
+        const list = views.get(sub) ?? [];
+        if (!list.includes(view)) {
+            list.push(view);
+        }
+        views.set(sub, list);
+    };
+    for (const held of aspect(doc, "cyNetworkRelations")) {
+        const relation = structuralId(held, "cyNetworkRelations", "c", report);
+        if (relation !== null) {
+            fileRelation(relation, subs, { relationNames, order, addView });
+        }
+    }
+    for (const held of aspect(doc, "cyViews")) {
+        const view = structuralId(held, "cyViews", "@id", report);
+        const sub = view === null ? null : refId(view.value.s);
+        if (view !== null && sub !== null) {
+            addView(sub, view.id);
+        }
+    }
+    order.push(...[...subs.keys()].filter((id) => !order.includes(id)));
+    return { relationNames, order, views };
+}
+/**
+ * File one network relation: a view of a subnetwork, or a subnetwork's name and its place in the order.
+ * @param relation - the relation element and its child id
+ * @param relation.value - the element
+ * @param relation.id - the child: a view or a subnetwork
+ * @param subs - the subnetworks
+ * @param out - where the relation is filed
+ * @param out.relationNames - each subnetwork's name
+ * @param out.order - the subnetworks in relation order
+ * @param out.addView - records a view of a subnetwork
+ */
+function fileRelation(relation, subs, out) {
+    const { value, id: child } = relation;
+    if (value.r === "view") {
+        const parent = refId(value.p);
+        if (parent !== null) {
+            out.addView(parent, child);
+        }
+        return;
+    }
+    if (typeof value.name === "string") {
+        out.relationNames.set(child, value.name);
+    }
+    if (subs.has(child) && !out.order.includes(child)) {
+        out.order.push(child);
+    }
+}
+/**
+ * A subnetwork's name from the network attributes: the one scoped to it, else the unscoped one.
+ * @param doc - the document
+ * @param sub - the subnetwork, or null
+ * @returns the name, or null
+ */
+function networkName(doc, sub) {
+    let found = null;
+    for (const { value } of doc.attributes.network.get("name") ?? []) {
+        if (!isRecord(value) || typeof value.v !== "string") {
+            continue;
+        }
+        const scope = value.s === undefined ? null : refId(value.s);
+        if (scope === sub) {
+            return value.v;
+        }
+        if (scope === null) {
+            found ?? (found = value.v);
+        }
+    }
+    return found;
+}
 /**
  * The distinct views the layout entries name, in order of appearance.
  * @param doc - the document
@@ -838,10 +1064,14 @@ class CxReader {
         this.rootNodes = new Set();
         /** Every edge id of the root network. */
         this.rootEdges = new Set();
-        /** CX node id -> sink node index, for this graph. */
+        /** CX node id (as written, before the `ids` option) -> sink node index, for this graph. */
         this.nodeRows = new Map();
-        /** CX edge id -> sink edge index, for this graph. */
+        /** Sink node id -> sink node index: two CX ids the `ids` option makes one are one node. */
+        this.sinkRows = new Map();
+        /** CX edge id (as written) -> sink edge index, for this graph. */
         this.edgeRows = new Map();
+        /** CX node id -> the id given to the sink, for the nodes whose original id was restored. */
+        this.sinkIds = new Map();
         /** The subnetwork ids of the document. */
         this.subnetworks = new Set();
         this.dangling = new Map();
@@ -854,8 +1084,8 @@ class CxReader {
         this.weighted = false;
         /** The core field values written per row (n, r), to detect a differing name attribute. */
         this.coreValues = new Map();
-        /** The weight attribute values of the edges, by edge id (built once). */
-        this.weights = null;
+        /** The weight attribute values of the edges, by edge id. */
+        this.weights = new Map();
         this.sink = sink;
         this.report = report;
         this.options = options;
@@ -889,6 +1119,7 @@ class CxReader {
         this.direction.setHeader(true);
         this.checkMembers();
         this.checkRootOnly();
+        this.checkTableColumns();
         const nodeColumns = this.declareAttributes("node");
         this.readNodes();
         this.readGroups();
@@ -901,7 +1132,7 @@ class CxReader {
         this.readVisualProperties();
         this.readProvenance();
         for (const [kind, count] of this.dangling) {
-            report.warning("validation-error", DANGLING_REFERENCE_CODE, `${count} ${kind}(s) name nothing; ignored`, {
+            report.warning("validation-error", DANGLING_REFERENCE_CODE, `${count} ${kind}${plural(count)} ${agree(count, "names", "name")} nothing; ignored`, {
                 element: kind,
             });
         }
@@ -930,15 +1161,6 @@ class CxReader {
     inGraph(id) {
         return this.plan.nodes === null || this.plan.nodes.has(id);
     }
-    /**
-     * The key of the node and edge row maps for a CX id as an aspect writes it: the id the `ids`
-     * option makes of it, which is what idOf() stored the element under.
-     * @param raw - the CX id
-     * @returns the row key
-     */
-    key(raw) {
-        return this.options.ids === "keep" ? raw : this.coercer.value(raw);
-    }
     /**
      * Whether a scoped value applies to this graph: unscoped, or scoped to its subnetwork. A scope
      * naming no subnetwork is counted as dangling.
@@ -959,41 +1181,97 @@ class CxReader {
         return 0;
     }
     /**
-     * The id of an element, by the CX id rule and the `ids` option.
+     * The id of an element by the CX id rule, as the document's references name it (the `ids`
+     * option applies only to the id the sink holds, sinkId()).
      * @param raw - the parsed id
      * @param inexact - whether the literal was not a plain integer
      * @param element - the element name for issues
+     * @param line - the element's line
      * @param edgeId - whether this is an edge's own id (stored in the f64 id column, not kept as digits)
      * @returns the id, or null when it was reported
      */
-    idOf(raw, inexact, element, edgeId = false) {
+    idOf(raw, inexact, element, line, edgeId = false) {
         try {
             const parsed = cxId(raw, inexact);
             if (parsed.note === "text") {
-                this.report.warnOnce("coercion", ID_TEXT_TYPE_CODE, `${element}: the id ${shown(raw)} is not written as an integer; read as ${String(parsed.id)}`, { element });
+                this.report.warnOnce("coercion", ID_TEXT_TYPE_CODE, `${element}: the id ${shown(raw)} is not written as an integer; read as ${String(parsed.id)}`, { line, element });
             }
             else if (parsed.note === "precision" && edgeId) {
                 // the edge is told apart by its digits, but the id column is f64
-                this.report.warnOnce("precision", PRECISION_CODE, `${element}: the edge id ${String(parsed.id)} is beyond 2^53; the id column holds the nearest double`, { element }, `${PRECISION_CODE}:edge`);
+                this.report.warnOnce("precision", PRECISION_CODE, `${element}: the edge id ${String(parsed.id)} is beyond 2^53; the id column holds the nearest double`, { line, element }, `${PRECISION_CODE}:edge`);
             }
             else if (parsed.note === "precision") {
                 this.idType = "mixed";
-                this.report.warnOnce("precision", PRECISION_CODE, `${element}: the id ${String(parsed.id)} is beyond 2^53; kept as its digits (a string id)`, { element });
+                this.report.warnOnce("precision", PRECISION_CODE, `${element}: the id ${String(parsed.id)} is beyond 2^53; kept as its digits (a string id)`, { line, element });
             }
-            return this.options.ids === "keep" ? parsed.id : this.coercer.value(parsed.id);
+            return parsed.id;
         }
         catch (err) {
-            this.report.recordError(err, { element });
+            this.report.recordError(err, { line, element });
             return null;
         }
     }
+    /**
+     * The id the sink holds a CX node under: its restored original id, else the `ids` option applied.
+     * @param id - the CX id
+     * @returns the sink id
+     */
+    sinkId(id) {
+        const original = this.sinkIds.get(id);
+        if (original !== undefined) {
+            return original;
+        }
+        return this.options.ids === "keep" ? id : this.coercer.value(id);
+    }
+    /**
+     * Add a node to the sink (once per sink id) and map its CX id to the row.
+     * @param id - the CX id
+     * @returns the row, and whether the sink id was new
+     */
+    addNode(id) {
+        const sinkId = this.sinkId(id);
+        const existing = this.sinkRows.get(sinkId);
+        if (existing !== undefined) {
+            this.nodeRows.set(id, existing);
+            return { row: existing, added: false };
+        }
+        const row = this.sink.addNode(sinkId);
+        this.sinkRows.set(sinkId, row);
+        this.nodeRows.set(id, row);
+        return { row, added: true };
+    }
     /**
      * Record a long value beyond 2^53 (once).
      * @param name - the attribute
      * @param digits - the value
      */
     precision(name, digits) {
-        this.report.warnOnce("precision", PRECISION_CODE, `"${name}": ${digits} is beyond 2^53; stored as the nearest double`, { element: name }, `${PRECISION_CODE}:value`);
+        const overflow = !Number.isFinite(Number(digits));
+        this.report.warnOnce("precision", PRECISION_CODE, overflow
+            ? `"${name}": ${digits} is beyond the range of a double; stored as ${String(Number(digits))}`
+            : `"${name}": ${digits} is beyond 2^53; stored as the nearest double`, { element: name }, `${PRECISION_CODE}:value`);
+    }
+    /**
+     * Report the keys of a node or edge element CX does not define, once per key.
+     * @param record - the element
+     * @param known - the keys it defines
+     * @param what - nodes or edges
+     * @param line - its line
+     */
+    unknownKeys(record, known, what, line) {
+        for (const key of Object.keys(record)) {
+            if (!known.has(key)) {
+                this.report.warnOnce("unsupported", UNKNOWN_ELEMENT_CODE, `the ${what} key "${key}" is not defined by CX; its values are not read`, { line, element: key }, `${UNKNOWN_ELEMENT_CODE}:${what}:${key}`);
+            }
+        }
+    }
+    /** Report cyTableColumn entries for a table CX does not define (once per table name). */
+    checkTableColumns() {
+        for (const { value, line } of aspect(this.doc, "cyTableColumn")) {
+            if (isRecord(value) && typeof value.applies_to === "string" && !TABLES.has(value.applies_to)) {
+                this.report.warnOnce("unsupported", UNKNOWN_ELEMENT_CODE, `a cyTableColumn entry applies to "${value.applies_to}", which is not node_table, edge_table or network_table; ignored`, { line, element: value.applies_to }, `${UNKNOWN_ELEMENT_CODE}:table:${value.applies_to}`);
+            }
+        }
     }
     /** Count the subnetwork members that name no node or edge. */
     checkMembers() {
@@ -1037,7 +1315,7 @@ class CxReader {
         const nodes = lost("nodes", this.rootNodes);
         const edges = lost("edges", this.rootEdges);
         if (nodes + edges > 0) {
-            this.report.warning("unsupported", CX_ISSUE.ROOT_ONLY, `${nodes} node(s) and ${edges} edge(s) of the root network belong to no subnetwork (cySubNetworks); they are not read`, { element: "cySubNetworks" });
+            this.report.warning("unsupported", CX_ISSUE.ROOT_ONLY, `${nodes} node${plural(nodes)} and ${edges} edge${plural(edges)} of the root network belong to no subnetwork (cySubNetworks); they are not read`, { element: "cySubNetworks" });
         }
     }
     /**
@@ -1063,7 +1341,8 @@ class CxReader {
         const declared = this.tableColumns(domain === "node" ? "node_table" : "edge_table");
         const names = new Set([...declared.keys(), ...this.doc.attributes[domain].keys()]);
         for (const name of names) {
-            if (name === "" || (domain === "edge" && name === this.options.weightFrom)) {
+            if ((domain === "edge" && name === this.options.weightFrom) ||
+                (domain === "node" && name === ORIGINAL_ID_ATTRIBUTE && this.options.restoreMangledIds)) {
                 continue;
             }
             const types = [];
@@ -1144,7 +1423,10 @@ class CxReader {
                 continue;
             }
             const type = cxType(value.d);
-            if (type !== null) {
+            if (type === null) {
+                this.report.warnOnce("unsupported", UNKNOWN_ATTR_TYPE_CODE, `cyTableColumn declares "${value.n}" with the data type ${shown(value.d)}, which CX does not define; its values are typed by their own d`, { element: value.n }, `${UNKNOWN_ATTR_TYPE_CODE}:table:${table}:${value.n}`);
+            }
+            else {
                 out.set(value.n, type);
             }
         }
@@ -1196,14 +1478,6 @@ class CxReader {
                 if (scope === 0) {
                     continue;
                 }
-                const target = refId(value.po);
-                const row = target === null ? undefined : rows.get(this.key(target));
-                if (row === undefined) {
-                    if (target === null || !root.has(target)) {
-                        this.dangle(`${domain} attribute target`);
-                    }
-                    continue;
-                }
                 if (value.v === undefined) {
                     this.report.error("missing-value", BAD_VALUE_CODE, `a ${domain}Attributes element for "${column.name}" has no v; skipped`, {
                         line,
@@ -1211,18 +1485,29 @@ class CxReader {
                     });
                     continue;
                 }
-                if (value.v === null) {
-                    continue;
-                }
-                const previous = chosen.get(row);
-                if (previous !== undefined && previous.scope > scope) {
-                    continue;
-                }
-                if (previous?.scope === scope &&
-                    JSON.stringify(previous.value) !== JSON.stringify(plainJson(value.v))) {
-                    this.report.warnOnce("validation-error", DUPLICATE_ATTRIBUTE_CODE, `${domain} ${shown(value.po)} has the attribute "${column.name}" twice; the later value wins`, { line, element: column.name }, `${DUPLICATE_ATTRIBUTE_CODE}:${domain}:${column.name}`);
+                // po names one element, or (cxio's shared values) a list of them
+                for (const raw of Array.isArray(value.po) ? value.po : [value.po]) {
+                    const target = refId(raw);
+                    const row = target === null ? undefined : rows.get(target);
+                    if (row === undefined) {
+                        if (target === null || !root.has(target)) {
+                            this.dangle(`${domain} attribute target`);
+                        }
+                        continue;
+                    }
+                    if (value.v === null) {
+                        continue;
+                    }
+                    const previous = chosen.get(row);
+                    if (previous !== undefined && previous.scope > scope) {
+                        continue;
+                    }
+                    if (previous?.scope === scope &&
+                        JSON.stringify(previous.value) !== JSON.stringify(plainJson(value.v))) {
+                        this.report.warnOnce("validation-error", DUPLICATE_ATTRIBUTE_CODE, `${domain} ${shown(raw)} has the attribute "${column.name}" twice; the later value wins`, { line, element: column.name }, `${DUPLICATE_ATTRIBUTE_CODE}:${domain}:${column.name}`);
+                    }
+                    chosen.set(row, { scope, value: value.v, d: value.d, line });
                 }
-                chosen.set(row, { scope, value: value.v, d: value.d, line });
             }
             for (const [row, { value, d, line }] of chosen) {
                 this.writeCell(domain, column, row, value, d, line);
@@ -1264,6 +1549,10 @@ class CxReader {
         }
         let { handle } = column;
         if (this.isStructural(domain, column.name)) {
+            if (Array.isArray(raw)) {
+                this.report.error("validation-error", BAD_VALUE_CODE, `${element}: ${shown(raw)} is a list; "${column.name}" holds one string, the cell is unset`, { line, element: column.name });
+                return;
+            }
             handle = this.coreColumn(domain, column.name);
             const prior = this.coreValue(domain, row, column.name);
             if (prior !== undefined && prior !== value) {
@@ -1329,7 +1618,8 @@ class CxReader {
     // ------------------------------------------------------------ nodes, groups, layout
     /** Read the nodes of this graph. */
     readNodes() {
-        const { report, sink } = this;
+        const { report } = this;
+        const originals = this.originalIds();
         for (const held of aspect(this.doc, "nodes")) {
             this.checkAbort();
             const { value, line } = held;
@@ -1346,36 +1636,61 @@ class CxReader {
                 report.counts.skippedNodes++;
                 continue;
             }
+            this.unknownKeys(value, NODE_KEYS, "node", line);
             const element = `node ${shown(value["@id"])}`;
-            const id = this.idOf(value["@id"], (held.inexact & 1) !== 0, element);
+            const id = this.idOf(value["@id"], (held.inexact & 1) !== 0, element, line);
             if (id === null) {
                 report.counts.skippedNodes++;
                 continue;
             }
-            // membership lists hold CX ids as written, before the ids option coerces them
-            if (!this.inGraph(refId(value["@id"]) ?? id)) {
+            if (!this.inGraph(id)) {
                 continue;
             }
             let row = this.nodeRows.get(id);
-            if (row !== undefined) {
-                report.warning("merged", DUPLICATE_NODE_CODE, `${element} is declared more than once; its fields are merged (the later values win)`, { line, element });
-            }
-            else {
+            let added = false;
+            if (row === undefined) {
+                const original = originals.get(refId(value["@id"]) ?? id);
+                if (original !== undefined) {
+                    this.idType = "mixed";
+                    this.sinkIds.set(id, original);
+                }
                 try {
-                    row = sink.addNode(id);
+                    ({ row, added } = this.addNode(id));
                 }
                 catch (err) {
                     report.recordError(err, { line, element });
                     report.counts.skippedNodes++;
                     continue;
                 }
-                this.nodeRows.set(id, row);
+            }
+            if (added) {
                 report.counts.nodes++;
             }
+            else {
+                report.warning("merged", DUPLICATE_NODE_CODE, `${element} is declared more than once; its fields are merged (the later values win)`, { line, element });
+            }
             this.writeCore("node", row, "name", value.n, element, line);
             this.writeCore("node", row, "represents", value.r, element, line);
         }
     }
+    /**
+     * The original ids the exporter's `sanitizeIds: "mangle"` kept in the `graphty:originalId`
+     * attribute, when they are to be restored.
+     * @returns CX node id -> original id
+     */
+    originalIds() {
+        const out = new Map();
+        if (!this.options.restoreMangledIds) {
+            return out;
+        }
+        for (const { value } of this.doc.attributes.node.get(ORIGINAL_ID_ATTRIBUTE) ?? []) {
+            const po = isRecord(value) && this.scopePeek(value.s) !== 0 ? refId(value.po) : null;
+            if (po !== null && isRecord(value) && typeof value.v === "string") {
+                out.set(po, value.v);
+            }
+        }
+        return out;
+    }
     /**
      * Write a core string field (n, r, i).
      * @param domain - node or edge
@@ -1423,31 +1738,31 @@ class CxReader {
         }
         const parents = new Map();
         const collapsed = [];
-        for (const { value, line } of groups) {
-            if (!isRecord(value)) {
+        for (const held of groups) {
+            const group = structuralId(held, "cyGroups", "@id", this.report);
+            if (group === null) {
                 continue;
             }
-            const id = refId(value["@id"]);
-            if (id === null) {
-                this.report.error("missing-value", MISSING_ID_CODE, "a cyGroups element has no @id", {
-                    line,
-                    element: "cyGroups",
-                });
-                continue;
+            const { value, id } = group;
+            const { line } = held;
+            if (value.nodes !== undefined && value.nodes !== null && !Array.isArray(value.nodes)) {
+                this.report.error("validation-error", BAD_VALUE_CODE, `group ${String(id)}: nodes is ${shown(value.nodes)}, not a list of node ids; no member is read`, { line, element: String(id) });
             }
-            let groupRow = this.nodeRows.get(this.key(id));
+            if (value.collapsed !== undefined && value.collapsed !== null && typeof value.collapsed !== "boolean") {
+                this.report.error("validation-error", BAD_VALUE_CODE, `group ${String(id)}: collapsed is ${shown(value.collapsed)}, not a boolean; unset`, { line, element: String(id) });
+            }
+            let groupRow = this.nodeRows.get(id);
             if (groupRow === undefined) {
                 if (this.rootNodes.has(id) || !this.hasMemberIn(value.nodes)) {
                     continue;
                 }
                 try {
-                    groupRow = this.sink.addNode(this.key(id));
+                    groupRow = this.addNode(id).row;
                 }
                 catch (err) {
                     this.report.recordError(err, { line, element: String(id) });
                     continue;
                 }
-                this.nodeRows.set(this.key(id), groupRow);
                 this.report.counts.nodes++;
                 this.report.warning("coercion", CX_ISSUE.GROUP_NODE_ADDED, `group ${String(id)} is not a node; its group node is added`, { line, element: String(id) });
             }
@@ -1459,7 +1774,7 @@ class CxReader {
             }
             for (const raw of Array.isArray(value.nodes) ? value.nodes : []) {
                 const member = refId(raw);
-                const row = member === null ? undefined : this.nodeRows.get(this.key(member));
+                const row = member === null ? undefined : this.nodeRows.get(member);
                 if (row === undefined) {
                     if (member === null || !this.rootNodes.has(member)) {
                         this.report.error("missing-value", UNKNOWN_PARENT_CODE, `group ${String(id)}: the member ${shown(raw)} is not a node`, { line, element: String(id) });
@@ -1499,7 +1814,7 @@ class CxReader {
         return (Array.isArray(raw) &&
             raw.some((item) => {
                 const id = refId(item);
-                return id !== null && this.nodeRows.has(this.key(id));
+                return id !== null && this.nodeRows.has(id);
             }));
     }
     /**
@@ -1562,6 +1877,7 @@ class CxReader {
         for (const { value, line } of entries) {
             this.checkAbort();
             if (!isRecord(value)) {
+                this.report.error("parse-error", BAD_ASPECT_BLOCK_CODE, `a cartesianLayout element is ${shown(value)}, not an object; skipped`, { line, element: "cartesianLayout" });
                 continue;
             }
             const view = value.view === undefined || value.view === null ? null : refId(value.view);
@@ -1577,14 +1893,21 @@ class CxReader {
                 this.report.error("validation-error", BAD_VALUE_CODE, `a cartesianLayout element for node ${shown(value.node)} has no numeric x and y; skipped`, { line, element: "cartesianLayout" });
                 continue;
             }
+            if (!fitsF32(value.x) || !fitsF32(value.y)) {
+                this.report.error("validation-error", BAD_VALUE_CODE, `a cartesianLayout element for node ${shown(value.node)} has the coordinates ${String(value.x)}, ${String(value.y)}, beyond what the f32 position column holds; skipped`, { line, element: "cartesianLayout" });
+                continue;
+            }
             const node = refId(value.node);
-            const row = node === null ? undefined : this.nodeRows.get(this.key(node));
+            const row = node === null ? undefined : this.nodeRows.get(node);
             if (row === undefined) {
                 if (node === null || !this.rootNodes.has(node)) {
                     this.dangle("layout entry");
                 }
                 continue;
             }
+            if (value.z !== undefined && value.z !== null && typeof value.z !== "number") {
+                this.report.error("validation-error", BAD_VALUE_CODE, `a cartesianLayout element for node ${shown(value.node)} has the z ${shown(value.z)}, not a number; z is unset`, { line, element: "cartesianLayout" });
+            }
             const key = `${slot}:${row}`;
             if (seen.has(key)) {
                 this.report.warnOnce("validation-error", DUPLICATE_ATTRIBUTE_CODE, `node ${shown(value.node)} has two layout entries for one view; the later wins`, { line, element: "cartesianLayout" }, `${DUPLICATE_ATTRIBUTE_CODE}:layout`);
@@ -1652,6 +1975,7 @@ class CxReader {
     readEdges() {
         const { report, sink } = this;
         const members = this.plan.edges;
+        this.weights = this.edgeWeights();
         for (const held of aspect(this.doc, "edges")) {
             this.checkAbort();
             const { value, line } = held;
@@ -1668,13 +1992,14 @@ class CxReader {
                 report.counts.skippedEdges++;
                 continue;
             }
+            this.unknownKeys(value, EDGE_KEYS, "edge", line);
             const element = `edge ${shown(value["@id"])}`;
-            const id = this.idOf(value["@id"], (held.inexact & 1) !== 0, element, true);
+            const id = this.idOf(value["@id"], (held.inexact & 1) !== 0, element, line, true);
             if (id === null) {
                 report.counts.skippedEdges++;
                 continue;
             }
-            if (members !== null && !members.has(refId(value["@id"]) ?? id)) {
+            if (members !== null && !members.has(id)) {
                 continue;
             }
             if (value.s === undefined || value.s === null || value.t === undefined || value.t === null) {
@@ -1685,8 +2010,8 @@ class CxReader {
                 report.counts.skippedEdges++;
                 continue;
             }
-            const s = this.idOf(value.s, (held.inexact & 2) !== 0, element);
-            const t = s === null ? null : this.idOf(value.t, (held.inexact & 4) !== 0, element);
+            const s = this.idOf(value.s, (held.inexact & 2) !== 0, element, line);
+            const t = s === null ? null : this.idOf(value.t, (held.inexact & 4) !== 0, element, line);
             if (s === null || t === null) {
                 report.counts.skippedEdges++;
                 continue;
@@ -1712,7 +2037,7 @@ class CxReader {
             const before = sink.edgeCount;
             let edge;
             try {
-                edge = this.direction.addEdge(s, t, "directed", weight, { line, element });
+                edge = this.direction.addEdge(this.sinkId(s), this.sinkId(t), "directed", weight, { line, element });
             }
             catch (err) {
                 report.recordError(err, { line, element });
@@ -1750,35 +2075,71 @@ class CxReader {
             return false;
         }
         try {
-            this.nodeRows.set(id, this.sink.addNode(id));
+            if (this.addNode(id).added) {
+                this.report.counts.nodes++;
+            }
         }
         catch (err) {
             this.report.recordError(err, { line, element });
             return false;
         }
-        this.report.counts.nodes++;
         return true;
     }
     /**
-     * The weight of an edge: its weightFrom attribute, parsed as a number.
-     * @param id - the edge id
-     * @returns the weight, or undefined; E_INVALID_WEIGHT for a non-number
+     * The weightFrom attribute values by edge id: this subnetwork's own value beats the unscoped
+     * one, and of two in one scope the later wins (W_DUPLICATE_ATTRIBUTE when they differ), as
+     * writeAttributes() rules every other attribute.
+     * @returns the values (parsed JSON) by edge id
      */
-    weightOf(id) {
+    edgeWeights() {
         const { weightFrom } = this.options;
+        const chosen = new Map();
         if (weightFrom === null) {
-            return undefined;
+            return new Map();
         }
-        if (this.weights === null) {
-            this.weights = new Map();
-            for (const { value } of this.doc.attributes.edge.get(weightFrom) ?? []) {
-                if (isRecord(value) && this.scopePeek(value.s) !== 0) {
-                    const po = refId(value.po);
-                    if (po !== null && value.v !== undefined && value.v !== null) {
-                        this.weights.set(this.key(po), plainJson(value.v));
-                    }
-                }
+        for (const { value, line } of this.doc.attributes.edge.get(weightFrom) ?? []) {
+            const scope = isRecord(value) ? this.scopePeek(value.s) : 0;
+            if (!isRecord(value) || scope === 0 || value.v === undefined || value.v === null) {
+                continue;
             }
+            const v = plainJson(value.v);
+            for (const raw of Array.isArray(value.po) ? value.po : [value.po]) {
+                this.chooseWeight(chosen, raw, { scope, value: v }, line, weightFrom);
+            }
+        }
+        return new Map([...chosen].map(([id, { value }]) => [id, value]));
+    }
+    /**
+     * Keep one weight attribute element's value for one edge, unless a more specific scope already
+     * gave it one; a second value in the same scope wins, with a warning.
+     * @param chosen - the value chosen so far per edge
+     * @param raw - the edge reference as written
+     * @param weight - the value and the scope it applies in
+     * @param weight.scope - the scope: higher is more specific
+     * @param weight.value - the value
+     * @param line - the element's line
+     * @param weightFrom - the attribute name
+     */
+    chooseWeight(chosen, raw, weight, line, weightFrom) {
+        const po = refId(raw);
+        const previous = po === null ? undefined : chosen.get(po);
+        if (po === null || (previous !== undefined && previous.scope > weight.scope)) {
+            return;
+        }
+        if (previous?.scope === weight.scope && JSON.stringify(previous.value) !== JSON.stringify(weight.value)) {
+            this.report.warnOnce("validation-error", DUPLICATE_ATTRIBUTE_CODE, `edge ${shown(raw)} has the attribute "${weightFrom}" twice; the later value wins`, { line, element: weightFrom }, `${DUPLICATE_ATTRIBUTE_CODE}:edge:${weightFrom}`);
+        }
+        chosen.set(po, weight);
+    }
+    /**
+     * The weight of an edge: its weightFrom attribute, parsed as a number (the declared d is not
+     * consulted: a value that is not a number is E_INVALID_WEIGHT whatever its type says).
+     * @param id - the edge id
+     * @returns the weight, or undefined; E_INVALID_WEIGHT for a non-number
+     */
+    weightOf(id) {
+        if (this.options.weightFrom === null) {
+            return undefined;
         }
         const raw = this.weights.get(id);
         if (typeof raw === "string" && isNullText(raw)) {
@@ -1792,17 +2153,29 @@ class CxReader {
         for (const [name, elements] of this.doc.attributes.network) {
             let chosen = null;
             let chosenScope = 0;
-            for (const { value } of elements) {
+            for (const { value, line } of elements) {
                 if (!isRecord(value)) {
                     continue;
                 }
                 const scope = this.scopeOf(value.s);
-                if (scope !== 0 && scope >= chosenScope) {
+                if (scope === 0) {
+                    continue;
+                }
+                if (value.v === undefined) {
+                    this.report.error("missing-value", BAD_VALUE_CODE, `a networkAttributes element for "${name}" has no v; skipped`, { line, element: name });
+                    continue;
+                }
+                if (chosen !== null &&
+                    scope === chosenScope &&
+                    JSON.stringify(plainJson(chosen.v)) !== JSON.stringify(plainJson(value.v))) {
+                    this.report.warnOnce("validation-error", DUPLICATE_ATTRIBUTE_CODE, `the network attribute "${name}" is given twice; the later value wins`, { line, element: name }, `${DUPLICATE_ATTRIBUTE_CODE}:network:${name}`);
+                }
+                if (scope >= chosenScope) {
                     chosen = value;
                     chosenScope = scope;
                 }
             }
-            if (chosen === null || chosen.v === undefined || chosen.v === null || name === "") {
+            if (chosen?.v === undefined || chosen.v === null) {
                 continue;
             }
             const type = cxType(chosen.d);
@@ -1869,7 +2242,7 @@ class CxReader {
                     const domain = value.properties_of === "nodes" ? "node" : "edge";
                     const target = refId(value.applies_to);
                     const rows = domain === "node" ? this.nodeRows : this.edgeRows;
-                    const row = target === null ? undefined : rows.get(this.key(target));
+                    const row = target === null ? undefined : rows.get(target);
                     if (row === undefined) {
                         if (target === null || !(domain === "node" ? this.rootNodes : this.rootEdges).has(target)) {
                             this.dangle(`${domain} visual property entry`);
@@ -1899,7 +2272,7 @@ class CxReader {
                     name: property,
                     dtype: "string",
                     nullable: true,
-                    origin: { format: CX_FORMAT, id: null, namespace: CX_BYPASS_NAMESPACE },
+                    origin: { format: CX_FORMAT, id: property, namespace: CX_BYPASS_NAMESPACE },
                 }, this.report);
                 for (const [row, text] of cells) {
                     if (domain === "node") {
@@ -1924,12 +2297,12 @@ class CxReader {
         }
         if (defaults + mappings + dependencies + tableStyles > 0) {
             const parts = [
-                `cyVisualProperties: ${defaults} default(s), ${mappings} mapping(s), ${dependencies} dependenc(ies)`,
+                `cyVisualProperties: ${defaults} default${plural(defaults)}, ${mappings} mapping${plural(mappings)}, ${dependencies} dependenc(ies)`,
             ];
             if (tableStyles > 0) {
-                parts.push(`${tableStyles} table style element(s)`);
+                parts.push(`${tableStyles} table style element${plural(tableStyles)}`);
             }
-            this.report.warning("unsupported", STYLES_NOT_IMPORTED_CODE, `the file's style rules are not applied (${parts.join("; ")}); they are kept in meta.extra.cx (style import is issue #706)`, { element: "cyVisualProperties" });
+            this.report.warning("unsupported", STYLES_NOT_IMPORTED_CODE, `the file's style rules are not applied (${parts.join("; ")}); they are kept in meta.extra.cx`, { element: "cyVisualProperties" });
         }
     }
     /**
@@ -1955,7 +2328,7 @@ class CxReader {
                 continue;
             }
             const po = refId(value.po);
-            const row = po === null ? undefined : this.nodeRows.get(this.key(po));
+            const row = po === null ? undefined : this.nodeRows.get(po);
             if (row === undefined) {
                 if (po === null || !this.rootNodes.has(po)) {
                     this.dangle("functionTerms entry");
@@ -1973,8 +2346,8 @@ class CxReader {
             }
             const node = refId(value.node);
             const edge = refId(value.edge);
-            const row = node === null ? undefined : this.nodeRows.get(this.key(node));
-            const edgeRow = edge === null ? undefined : this.edgeRows.get(this.key(edge));
+            const row = node === null ? undefined : this.nodeRows.get(node);
+            const edgeRow = edge === null ? undefined : this.edgeRows.get(edge);
             if (row === undefined || edgeRow === undefined) {
                 if (node === null || !this.rootNodes.has(node) || edge === null || !this.rootEdges.has(edge)) {
                     this.dangle("reifiedEdges entry");
@@ -2007,16 +2380,30 @@ class CxReader {
             return;
         }
         const fields = [...new Set(records.flatMap((r) => Object.keys(r)).filter((k) => k !== "@id"))];
+        const names = new Set(["id"]);
         const decls = [
             { name: "id", dtype: "f64", nullable: true },
-            ...fields.map((field) => ({ name: field, dtype: "json", nullable: true })),
+            ...fields.map((field) => {
+                const column = uniqueColumnName(field, null, (n) => names.has(n));
+                names.add(column);
+                if (column !== field) {
+                    this.report.warning("coercion", COLUMN_RENAMED_CODE, `${name} column "${field}" renamed to "${column}": the table's own id column holds that name`, { element: field });
+                }
+                return { name: column, dtype: "json", nullable: true };
+            }),
         ];
         const table = this.sink.addExtensionTable(name, decls);
+        const precision = (digits) => {
+            this.precision(name, digits);
+        };
         for (const record of records) {
             const id = refId(record["@id"]);
+            if (typeof id === "string") {
+                precision(id);
+            }
             this.sink.addExtensionRow(table, [
                 id === null ? null : Number(id),
-                ...fields.map((field) => (record[field] === undefined ? null : plainJson(record[field]))),
+                ...fields.map((field) => (record[field] === undefined ? null : plainJson(record[field], precision))),
             ]);
         }
     }
@@ -2041,7 +2428,7 @@ class CxReader {
                 .map(Number);
             for (const raw of targets) {
                 const target = refId(raw);
-                const row = target === null ? undefined : rows.get(this.key(target));
+                const row = target === null ? undefined : rows.get(target);
                 if (row === undefined) {
                     if (target === null || !root.has(target)) {
                         this.dangle(`${aspectName} entry`);
@@ -2101,12 +2488,19 @@ class CxReader {
         };
         const extra = Object.fromEntries(this.doc.kept);
         const groups = aspect(this.doc, "cyGroups").map((h) => plainJson(h.value));
+        const own = {};
         if (groups.length > 0) {
-            extra.groups = groups;
+            own.groups = groups;
         }
         if (this.plan.subnetwork !== null) {
-            extra.subnetwork = this.plan.subnetwork;
+            own.subnetwork = this.plan.subnetwork;
+        }
+        for (const key of OWN_EXTRA_KEYS) {
+            if (key in own && this.doc.kept.has(key)) {
+                this.report.warning("unsupported", UNKNOWN_ELEMENT_CODE, `the aspect "${key}" is not kept: meta.extra.cx.${key} holds the importer's own ${key === "groups" ? "cyGroups" : "subnetwork"} data`, { element: key });
+            }
         }
+        Object.assign(extra, own);
         const { weightFrom } = this.options;
         const name = this.plan.name ?? describe("name");
         const description = describe("description");
@@ -2139,7 +2533,7 @@ async function run(input, options, sinkFor, pick) {
     const first = new ImportReportBuilder(CX_FORMAT, resolved.errorLimit);
     reportUnusedOptions(options, first, USED_OPTIONS);
     const doc = await readDocument(input, first, resolved);
-    const plans = graphPlans(doc);
+    const plans = graphPlans(doc, first);
     const chosen = pick(plans, first);
     const reports = [];
     chosen.forEach((index, k) => {
@@ -2153,10 +2547,12 @@ async function run(input, options, sinkFor, pick) {
     return reports;
 }
 /**
- * The CX version 1 importer plugin (design section 1.2).
+ * The CX version 1 importer plugin.
+ * @category Built-in formats
  */
 export const cxImporter = Object.freeze({
     format: CX_FORMAT,
+    options: Object.freeze(["zAs"]),
     extensions: Object.freeze([".cx"]),
     mimeTypes: Object.freeze(["application/json"]),
     /**
@@ -2167,8 +2563,7 @@ export const cxImporter = Object.freeze({
      * @returns the confidence
      */
     sniff(head) {
-        const text = new TextDecoder("utf-8").decode(head.subarray(0, 1024)).replace(/^\uFEFF/, "");
-        const match = /^\s*\[\s*\{\s*"((?:[^"\\]|\\.)*)"\s*:/.exec(text);
+        const match = /^\s*\[\s*\{\s*"((?:[^"\\]|\\.)*)"\s*:/.exec(headText(head));
         if (match === null) {
             return 0;
         }
@@ -2188,8 +2583,8 @@ export const cxImporter = Object.freeze({
     async import(input, sink, options) {
         const [report] = await run(input, options, () => sink, (plans, first) => {
             const index = chooseGraph(plans.map((p) => p.name), options, first);
-            if (plans.length > 1) {
-                first.warning("unsupported", MULTIPLE_GRAPHS_CODE, `the collection holds ${plans.length} subnetworks; graph ${index} is read and ${plans.length - 1} skipped (importAll() reads every one)`);
+            if (plans.length > 1 && !graphChosen(options)) {
+                first.warning("unsupported", MULTIPLE_GRAPHS_CODE, `the collection holds ${plans.length} subnetworks; graph ${index} is read and ${plans.length - 1} skipped (importAllGraphs() reads every one)`);
             }
             return [index];
         });
@@ -2218,7 +2613,7 @@ export const cxImporter = Object.freeze({
         const doc = await readDocument(input, report, resolved);
         const nodes = aspect(doc, "nodes").length;
         const edges = aspect(doc, "edges").length;
-        return graphPlans(doc).map((plan) => Object.freeze({
+        return graphPlans(doc, report).map((plan) => Object.freeze({
             index: plan.index,
             name: plan.name,
             nodes: memberCount(plan.nodes, nodes),