@graphty/graph-io 0.3.24 → 0.3.26

package/src/formats/cx/importer.ts

@@ -46,21 +46,26 @@ import {
     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,
@@ -68,6 +73,7 @@ import {
     SYNTAX_CODE,
     TOO_LARGE_CODE,
     UNKNOWN_ATTR_TYPE_CODE,
+    UNKNOWN_ELEMENT_CODE,
     UNKNOWN_ENCODING_CODE,
     UNKNOWN_PARENT_CODE,
     WIDENED_CODE,
@@ -80,24 +86,30 @@ import {
     CxStructure,
     declareFresh,
     ExactInteger,
+    fitsF32,
     flipY,
+    headText,
     inexactLiteral,
     isRecord,
     JsonScanError,
+    keptPrecision,
     plainJson,
     positionDecl,
+    reportSharedBlock,
     reportTooDeep,
     scanAspects,
     zDecl,
 } from "../../common/json-elements.js";
 import {
     chooseGraph,
+    graphChosen,
     type ImportFormatDefaults,
     reportSinkOptions,
     reportUnusedOptions,
     type ResolvedImportOptions,
     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 {
@@ -108,7 +120,7 @@ import {
     type ImportInput,
     type ImportReport,
 } from "../../types.js";
-import { zAsOption } from "../cx2/importer.js";
+import { ORIGINAL_ID_ATTRIBUTE, zAsOption } from "../cx2/importer.js";
 
 /** The format name. */
 const CX_FORMAT = "cx";
@@ -116,36 +128,46 @@ const CX_FORMAT = "cx";
 /** The origin namespace of the per-element visual property columns. */
 const CX_BYPASS_NAMESPACE = "cx.bypass";
 
-/** The format-specific options of the CX importer. */
-export interface CxImportOptions extends GraphChoiceOptions {
+/**
+ * The format-specific options of the CX importer.
+ * @category Built-in formats
+ */
+export interface CxImportOptions extends GraphChoiceOptions, CommonImportOptions {
     /**
-     * Where a node's `z` goes: "column" (default) keeps it in the f64 node column `z` (Cytoscape
-     * writes a stacking order there); "position" makes it the third component of the position.
+     * Where Cytoscape's `z` value (a drawing order, not a depth) goes: "column" keeps it as a node
+     * attribute named `z`; "position" makes it the third coordinate of the position.
+     * @defaultValue "column"
      */
     zAs?: "column" | "position" | undefined;
 }
 
 /**
- * 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",
@@ -153,11 +175,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,
@@ -165,7 +190,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,
@@ -177,9 +205,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,
@@ -189,37 +217,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,
 });
 
@@ -232,6 +286,7 @@ const USED_OPTIONS: ReadonlySet<keyof CommonImportOptions> = new Set<keyof Commo
     "weightFrom",
     "weightDtype",
     "long",
+    "restoreMangledIds",
     "errorLimit",
     "signal",
     "onProgress",
@@ -251,12 +306,21 @@ const ABORT_CHECK_INTERVAL = 64;
 const NUMBER_VERIFICATION_VALUES: ReadonlySet<string> = new Set(["281474976710655", "9223372036854775807"]);
 
 /** Old Cytoscape aspect names and the names they are read under. */
-const OLD_ASPECT_NAMES: Readonly<Record<string, string>> = {
-    visualProperties: "cyVisualProperties",
-    subNetworks: "cySubNetworks",
-    networkRelations: "cyNetworkRelations",
-    hiddenAttributes: "cyHiddenAttributes",
-};
+const OLD_ASPECT_NAMES: ReadonlyMap<string, string> = new Map([
+    ["visualProperties", "cyVisualProperties"],
+    ["subNetworks", "cySubNetworks"],
+    ["networkRelations", "cyNetworkRelations"],
+    ["hiddenAttributes", "cyHiddenAttributes"],
+]);
+
+/** The keys a nodes element defines. */
+const NODE_KEYS: ReadonlySet<string> = new Set(["@id", "n", "r"]);
+
+/** The keys an edges element defines. */
+const EDGE_KEYS: ReadonlySet<string> = new Set(["@id", "s", "t", "i"]);
+
+/** The tables cyTableColumn applies to. */
+const TABLES: ReadonlySet<string> = new Set(["node_table", "edge_table", "network_table"]);
 
 /** The aspects the importer reads into the graph (everything else is kept verbatim). */
 const READ_ASPECTS: ReadonlySet<string> = new Set([
@@ -299,6 +363,9 @@ const ALSO_KEPT: ReadonlySet<string> = new Set([
 /** Cytoscape's table-cell style aspects (both spellings): style rules, kept and reported, never read. */
 const TABLE_STYLE_ASPECTS: readonly string[] = ["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: readonly string[] = ["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: readonly string[] = ["numberVerification", "metaData"];
 const CX_ASPECT_KEYS: readonly string[] = [
@@ -339,14 +406,14 @@ interface CxType {
 }
 
 /** The CX data types, with the Java reader's float aliases. */
-const SCALARS: Readonly<Record<string, CxScalar>> = {
-    string: "string",
-    boolean: "boolean",
-    integer: "integer",
-    long: "long",
-    double: "double",
-    float: "double",
-};
+const SCALARS: ReadonlyMap<string, CxScalar> = new Map([
+    ["string", "string"],
+    ["boolean", "boolean"],
+    ["integer", "integer"],
+    ["long", "long"],
+    ["double", "double"],
+    ["float", "double"],
+]);
 
 /**
  * Resolve a `d` value.
@@ -361,7 +428,7 @@ function cxType(d: unknown): CxType | null {
         return null;
     }
     const list = d.startsWith("list_of_");
-    const scalar = SCALARS[list ? d.slice("list_of_".length) : d] as CxScalar | undefined;
+    const scalar = SCALARS.get(list ? d.slice("list_of_".length) : d);
     return scalar === undefined ? null : { scalar, list };
 }
 
@@ -492,7 +559,15 @@ function parseScalar(
             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;
         }
     }
 }
@@ -653,15 +728,16 @@ function aspect(doc: CxDocument, name: string): readonly Held[] {
  * 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: string, keys: readonly string[]): number {
+function inexactBits(text: string, keys: readonly string[], depth = 1): number {
     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;
         }
     });
@@ -709,6 +785,117 @@ function checkNumberVerification(value: unknown, count: number, report: ImportRe
     }
 }
 
+/**
+ * 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: string): boolean {
+    return (
+        READ_ASPECTS.has(name) ||
+        OLD_ASPECT_NAMES.has(name) ||
+        CX_ASPECT_KEYS.includes(name) ||
+        TABLE_STYLE_ASPECTS.includes(name)
+    );
+}
+
+/** What collectElement() needs across elements. */
+interface CollectState {
+    readonly doc: CxDocument;
+    readonly report: ImportReportBuilder;
+    /** numberVerification elements read so far. */
+    verifications: number;
+    /** The precision callback of the kept aspects. */
+    readonly onKeptPrecision: (digits: string) => void;
+}
+
+/** One parsed aspect element and where it came from. */
+interface CollectedElement {
+    readonly name: string;
+    readonly value: unknown;
+    readonly text: string;
+    readonly line: number;
+    readonly exact: boolean;
+    /** The depth of the element's own keys in text (2 for a member's single object). */
+    readonly depth: number;
+}
+
+/** The id keys of the aspects whose ids are checked for precision. */
+const ID_KEYS: ReadonlyMap<string, readonly string[]> = 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: Map<string, Held[]>, name: string, held: Held, report: ImportReportBuilder): void {
+    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: CollectState, element: CollectedElement): void {
+    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: 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
@@ -721,17 +908,37 @@ async function readDocument(
     report: ImportReportBuilder,
     options: ResolvedImportOptions,
 ): Promise<CxDocument> {
-    const structure = new CxStructure(report);
+    const structure = new CxStructure(report, (name) => OLD_ASPECT_NAMES.get(name) ?? name);
     const doc: CxDocument = {
         aspects: new Map(),
         attributes: { node: new Map(), edge: new Map(), network: new Map() },
         kept: new Map(),
         structure,
     };
+    const state: CollectState = {
+        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<string>();
+    const lastMember = { block: -1 };
+    const countMember = (block: number, name: string | null): void => {
+        if (block !== lastMember.block) {
+            lastMember.block = block;
+            members++;
+        }
+        if (name !== null && isCxAspect(name)) {
+            known++;
+        } else if (name !== null) {
+            unknownNames.add(name);
+        }
+    };
     const canonical = (name: string, line: number): string => {
-        const renamed = OLD_ASPECT_NAMES[name] as string | undefined;
+        const renamed = OLD_ASPECT_NAMES.get(name);
         if (renamed === undefined) {
             return name;
         }
@@ -744,51 +951,11 @@ async function readDocument(
         );
         return renamed;
     };
-    const collect = (name: string, value: unknown, text: string, line: number, exact: boolean): void => {
-        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: 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: string, value: unknown, text: string, line: number, exact: boolean, depth = 1): void => {
+        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);
@@ -797,7 +964,7 @@ async function readDocument(
                 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)}`,
+                        `a CX document is a JSON array of aspects; found ${event.object ? "an object" : shown(event.value)}`,
                         { line: event.line },
                     );
                     break;
@@ -812,11 +979,21 @@ async function readDocument(
                     }
                     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,
@@ -826,21 +1003,24 @@ async function readDocument(
                     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`,
+                        `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;
@@ -854,6 +1034,20 @@ async function readDocument(
         }
         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;
 }
@@ -888,11 +1082,13 @@ function refId(raw: unknown): NodeId | null {
 }
 
 /**
- * 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: unknown): Set<NodeId> | null {
+function memberSet(raw: unknown, onBad?: (code: string, message: string) => void): Set<NodeId> | null {
     if (raw === "all") {
         return null;
     }
@@ -900,87 +1096,79 @@ function memberSet(raw: unknown): Set<NodeId> | null {
     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: CxDocument): GraphPlan[] {
-    const subs = new Map<NodeId, { nodes: Set<NodeId> | null; edges: Set<NodeId> | null }>();
-    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<NodeId, string>();
-    const order: NodeId[] = [];
-    const views = new Map<NodeId, NodeId[]>();
-    const addView = (sub: NodeId, view: NodeId): void => {
-        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: Held,
+    name: string,
+    key: string,
+    report: ImportReportBuilder,
+): { readonly value: Record<string, unknown>; readonly id: NodeId } | null {
+    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: NodeId | null): string | null => {
-        let found: string | null = 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 ??= 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: CxDocument, report: ImportReportBuilder): GraphPlan[] {
+    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);
@@ -991,10 +1179,11 @@ function graphPlans(doc: CxDocument): GraphPlan[] {
         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,
@@ -1004,7 +1193,7 @@ function graphPlans(doc: CxDocument): GraphPlan[] {
     }
     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,
@@ -1012,6 +1201,139 @@ function graphPlans(doc: CxDocument): GraphPlan[] {
     }));
 }
 
+/** A subnetwork's members: null when the element does not list them. */
+type Subnetwork = { nodes: Set<NodeId> | null; edges: Set<NodeId> | null };
+
+/**
+ * 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: CxDocument, report: ImportReportBuilder): Map<NodeId, Subnetwork> {
+    const subs = new Map<NodeId, Subnetwork>();
+    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: string, message: string): void => {
+            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: CxDocument,
+    subs: ReadonlyMap<NodeId, Subnetwork>,
+    report: ImportReportBuilder,
+): { relationNames: Map<NodeId, string>; order: NodeId[]; views: Map<NodeId, NodeId[]> } {
+    const relationNames = new Map<NodeId, string>();
+    const order: NodeId[] = [];
+    const views = new Map<NodeId, NodeId[]>();
+    const addView = (sub: NodeId, view: NodeId): void => {
+        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: { readonly value: Record<string, unknown>; readonly id: NodeId },
+    subs: ReadonlyMap<NodeId, Subnetwork>,
+    out: { relationNames: Map<NodeId, string>; order: NodeId[]; addView: (sub: NodeId, view: NodeId) => void },
+): void {
+    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: CxDocument, sub: NodeId | null): string | null {
+    let found: string | null = 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 ??= value.v;
+        }
+    }
+    return found;
+}
+
 /**
  * The distinct views the layout entries name, in order of appearance.
  * @param doc - the document
@@ -1072,12 +1394,18 @@ class CxReader {
     /** Every edge id of the root network. */
     private readonly rootEdges = new Set<NodeId>();
 
-    /** CX node id -> sink node index, for this graph. */
+    /** CX node id (as written, before the `ids` option) -> sink node index, for this graph. */
     private readonly nodeRows = new Map<NodeId, number>();
 
-    /** 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. */
+    private readonly sinkRows = new Map<NodeId, number>();
+
+    /** CX edge id (as written) -> sink edge index, for this graph. */
     private readonly edgeRows = new Map<NodeId, number>();
 
+    /** CX node id -> the id given to the sink, for the nodes whose original id was restored. */
+    private readonly sinkIds = new Map<NodeId, NodeId>();
+
     /** The subnetwork ids of the document. */
     private readonly subnetworks = new Set<NodeId>();
 
@@ -1148,6 +1476,7 @@ class CxReader {
         this.direction.setHeader(true);
         this.checkMembers();
         this.checkRootOnly();
+        this.checkTableColumns();
         const nodeColumns = this.declareAttributes("node");
         this.readNodes();
         this.readGroups();
@@ -1160,9 +1489,14 @@ 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`, {
-                element: kind,
-            });
+            report.warning(
+                "validation-error",
+                DANGLING_REFERENCE_CODE,
+                `${count} ${kind}${plural(count)} ${agree(count, "names", "name")} nothing; ignored`,
+                {
+                    element: kind,
+                },
+            );
         }
         this.setMeta();
     }
@@ -1194,16 +1528,6 @@ class CxReader {
         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
-     */
-    private key(raw: NodeId): NodeId {
-        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.
@@ -1225,14 +1549,16 @@ class CxReader {
     }
 
     /**
-     * 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
      */
-    private idOf(raw: unknown, inexact: boolean, element: string, edgeId = false): NodeId | null {
+    private idOf(raw: unknown, inexact: boolean, element: string, line: number, edgeId = false): NodeId | null {
         try {
             const parsed = cxId(raw, inexact);
             if (parsed.note === "text") {
@@ -1240,7 +1566,7 @@ class CxReader {
                     "coercion",
                     ID_TEXT_TYPE_CODE,
                     `${element}: the id ${shown(raw)} is not written as an integer; read as ${String(parsed.id)}`,
-                    { element },
+                    { line, element },
                 );
             } else if (parsed.note === "precision" && edgeId) {
                 // the edge is told apart by its digits, but the id column is f64
@@ -1248,7 +1574,7 @@ class CxReader {
                     "precision",
                     PRECISION_CODE,
                     `${element}: the edge id ${String(parsed.id)} is beyond 2^53; the id column holds the nearest double`,
-                    { element },
+                    { line, element },
                     `${PRECISION_CODE}:edge`,
                 );
             } else if (parsed.note === "precision") {
@@ -1257,31 +1583,101 @@ class CxReader {
                     "precision",
                     PRECISION_CODE,
                     `${element}: the id ${String(parsed.id)} is beyond 2^53; kept as its digits (a string id)`,
-                    { element },
+                    { 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
+     */
+    private sinkId(id: NodeId): NodeId {
+        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
+     */
+    private addNode(id: NodeId): { readonly row: number; readonly added: boolean } {
+        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
      */
     private precision(name: string, digits: string): void {
+        const overflow = !Number.isFinite(Number(digits));
         this.report.warnOnce(
             "precision",
             PRECISION_CODE,
-            `"${name}": ${digits} is beyond 2^53; stored as the nearest double`,
+            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
+     */
+    private unknownKeys(record: Record<string, unknown>, known: ReadonlySet<string>, what: string, line: number): void {
+        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). */
+    private checkTableColumns(): void {
+        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. */
     private checkMembers(): void {
         for (const id of this.plan.nodes ?? []) {
@@ -1328,7 +1724,7 @@ class CxReader {
             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`,
+                `${nodes} node${plural(nodes)} and ${edges} edge${plural(edges)} of the root network belong to no subnetwork (cySubNetworks); they are not read`,
                 { element: "cySubNetworks" },
             );
         }
@@ -1359,7 +1755,10 @@ class CxReader {
         const declared = this.tableColumns(domain === "node" ? "node_table" : "edge_table");
         const names = new Set<string>([...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: CxType[] = [];
@@ -1455,7 +1854,15 @@ 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);
             }
         }
@@ -1515,14 +1922,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",
@@ -1535,26 +1934,37 @@ 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 as unknown[]) : [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);
@@ -1608,6 +2018,15 @@ 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) {
@@ -1684,7 +2103,8 @@ class CxReader {
 
     /** Read the nodes of this graph. */
     private readNodes(): void {
-        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;
@@ -1706,40 +2126,66 @@ 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
+     */
+    private originalIds(): Map<NodeId, string> {
+        const out = new Map<NodeId, string>();
+        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
@@ -1799,30 +2245,40 @@ class CxReader {
         }
         const parents = new Map<number, number[]>();
         const collapsed: [number, boolean][] = [];
-        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) },
+                );
+            }
+            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(this.key(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",
@@ -1839,7 +2295,7 @@ class CxReader {
             }
             for (const raw of Array.isArray(value.nodes) ? (value.nodes as unknown[]) : []) {
                 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(
@@ -1896,7 +2352,7 @@ class CxReader {
             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);
             })
         );
     }
@@ -1963,6 +2419,12 @@ 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);
@@ -1983,14 +2445,31 @@ class CxReader {
                 );
                 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(
@@ -2069,6 +2548,7 @@ class CxReader {
     private readEdges(): void {
         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;
@@ -2090,13 +2570,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) {
@@ -2112,8 +2593,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;
@@ -2143,7 +2624,7 @@ class CxReader {
             const before = sink.edgeCount;
             let edge: number;
             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 });
                 report.counts.skippedEdges++;
@@ -2186,39 +2667,89 @@ 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 attribute values of the edges, by edge id (built once). */
-    private weights: Map<NodeId, unknown> | null = null;
+    /** The weight attribute values of the edges, by edge id. */
+    private weights = new Map<NodeId, unknown>();
 
     /**
-     * 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
      */
-    private weightOf(id: NodeId): number | undefined {
+    private edgeWeights(): Map<NodeId, unknown> {
         const { weightFrom } = this.options;
+        const chosen = new Map<NodeId, { scope: number; value: unknown }>();
         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 as unknown[]) : [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
+     */
+    private chooseWeight(
+        chosen: Map<NodeId, { scope: number; value: unknown }>,
+        raw: unknown,
+        weight: { scope: number; value: unknown },
+        line: number,
+        weightFrom: string,
+    ): void {
+        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
+     */
+    private weightOf(id: NodeId): number | undefined {
+        if (this.options.weightFrom === null) {
+            return undefined;
+        }
         const raw = this.weights.get(id);
         if (typeof raw === "string" && isNullText(raw)) {
             return undefined;
@@ -2233,17 +2764,42 @@ class CxReader {
         for (const [name, elements] of this.doc.attributes.network) {
             let chosen: Record<string, unknown> | null = 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);
@@ -2321,7 +2877,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`);
@@ -2354,7 +2910,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,
                 );
@@ -2379,15 +2935,15 @@ 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)`,
+                `the file's style rules are not applied (${parts.join("; ")}); they are kept in meta.extra.cx`,
                 { element: "cyVisualProperties" },
             );
         }
@@ -2416,7 +2972,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");
@@ -2434,8 +2990,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");
@@ -2474,16 +3030,35 @@ class CxReader {
             return;
         }
         const fields = [...new Set(records.flatMap((r) => Object.keys(r)).filter((k) => k !== "@id"))];
+        const names = new Set(["id"]);
         const decls: ColumnDecl[] = [
             { name: "id", dtype: "f64", nullable: true },
-            ...fields.map((field): ColumnDecl => ({ name: field, dtype: "json", nullable: true })),
+            ...fields.map((field): ColumnDecl => {
+                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: string): void => {
+            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))),
             ]);
         }
     }
@@ -2509,7 +3084,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`);
@@ -2576,12 +3151,24 @@ class CxReader {
         };
         const extra: Record<string, unknown> = Object.fromEntries(this.doc.kept);
         const groups = aspect(this.doc, "cyGroups").map((h) => plainJson(h.value));
+        const own: Record<string, unknown> = {};
         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");
@@ -2621,7 +3208,7 @@ async function run(
     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: ImportReport[] = [];
     chosen.forEach((index, k) => {
@@ -2636,10 +3223,12 @@ async function run(
 }
 
 /**
- * The CX version 1 importer plugin (design section 1.2).
+ * The CX version 1 importer plugin.
+ * @category Built-in formats
  */
 export const cxImporter: GraphImporter<CxImportOptions> = Object.freeze({
     format: CX_FORMAT,
+    options: Object.freeze(["zAs"]),
     extensions: Object.freeze([".cx"]),
     mimeTypes: Object.freeze(["application/json"]),
 
@@ -2651,8 +3240,7 @@ export const cxImporter: GraphImporter<CxImportOptions> = Object.freeze({
      * @returns the confidence
      */
     sniff(head: Uint8Array): number {
-        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;
         }
@@ -2685,11 +3273,11 @@ export const cxImporter: GraphImporter<CxImportOptions> = Object.freeze({
                     options,
                     first,
                 );
-                if (plans.length > 1) {
+                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 (importAll() reads every one)`,
+                        `the collection holds ${plans.length} subnetworks; graph ${index} is read and ${plans.length - 1} skipped (importAllGraphs() reads every one)`,
                     );
                 }
                 return [index];
@@ -2729,7 +3317,7 @@ export const cxImporter: GraphImporter<CxImportOptions> = 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) =>
+        return graphPlans(doc, report).map((plan) =>
             Object.freeze({
                 index: plan.index,
                 name: plan.name,