@graphty/graph-io 0.3.25 → 0.3.26

package/dist/chunks/{importer-DET1tg6s.js → importer-DCjOvO7U.js}

@@ -1,26 +1,986 @@
-import { INVALID_INDEX } from "@graphty/graph-format";
-import { T as TOO_LARGE_CODE, S as SINK_OPTION_CODE, O as OPTION_IGNORED_CODE, D as DIRECTION_FORCED_CODE, a as DIRECTION_REFUSED_CODE, R as ROLE_TAKEN_CODE, C as COLUMN_RENAMED_CODE, N as NO_GRAPH_CODE, A as AMBIGUOUS_GRAPH_NAME_CODE, G as GRAPH_NOT_FOUND_CODE, M as MULTIPLE_GRAPHS_CODE, I as ID_MERGED_CODE, P as PRECISION_CODE, b as ID_TEXT_TYPE_CODE, c as DUPLICATE_EDGE_ID_CODE, d as DUPLICATE_NODE_CODE, e as MISSING_ENDPOINT_CODE, f as MISSING_ID_CODE, g as STYLES_NOT_IMPORTED_CODE, h as PARENT_CYCLE_CODE, U as UNKNOWN_PARENT_CODE, i as DUPLICATE_ATTRIBUTE_CODE, j as DANGLING_REFERENCE_CODE, k as UNKNOWN_ATTR_TYPE_CODE, W as WIDENED_CODE, B as BAD_VALUE_CODE, l as COUNT_MISMATCH_CODE, m as ASPECT_ORDER_CODE, n as BAD_ASPECT_BLOCK_CODE, o as STATUS_WARNING_CODE, p as STATUS_FAILED_CODE, q as UNKNOWN_ENCODING_CODE, E as ENCODING_FALLBACK_CODE, r as INVALID_ENCODING_CODE, s as INVALID_UTF8_CODE, t as SYNTAX_CODE, u as EMPTY_INPUT_CODE, v as resolveImportOptions, w as ImportReportBuilder, x as textChunks, y as throwIfAborted, z as reportUnusedOptions, F as reportSinkOptions, H as chooseGraph, J as DirectionResolver, K as IdCoercer, L as declareResolved, Q as uniqueColumnName } from "./report-B1z4WT9e.js";
-import { s as scanAspects, r as reportTooDeep, C as CxStructure, i as isRecord, J as JsonScanError, p as plainJson, E as ExactInteger, c as cxId, f as flipY, z as zDecl, a as positionDecl, d as declareFresh, b as inexactLiteral } from "./json-elements-DDS8N2Dd.js";
-import { w as weightFromValue } from "./weights-Dzba96G3.js";
-import { z as zAsOption } from "./importer-vi3bSdtw.js";
+import { GraphFormatError, INVALID_INDEX } from "@graphty/graph-format";
+import { c as childrenCsr } from "./children-CL3Cy0ez.js";
+import { s as stringify, f as aspectBlock, d as directionNotes, p as planNodeIds, b as planEdgeIds, O as ORIGINAL_ID_ATTRIBUTE, h as nextNodeId, i as noteList, g as declaredType, z as zAsOption } from "./importer-DfVu6j59.js";
+import { c as capabilities, L as LOSS, r as resolveExportOptions, p as pairFolding, b as plural, a as checkCapabilities, e as explicitWeights, ad as TOO_LARGE_CODE, S as SINK_OPTION_CODE, O as OPTION_IGNORED_CODE, D as DIRECTION_FORCED_CODE, d as DIRECTION_REFUSED_CODE, R as ROLE_TAKEN_CODE, C as COLUMN_RENAMED_CODE, N as NO_GRAPH_CODE, ae as AMBIGUOUS_GRAPH_NAME_CODE, af as GRAPH_NOT_FOUND_CODE, l as MULTIPLE_GRAPHS_CODE, I as ID_MERGED_CODE, P as PRECISION_CODE, J as ID_TEXT_TYPE_CODE, a2 as JSON_NONSTANDARD_NUMBER_CODE, ag as SINGLE_OBJECT_ASPECT_CODE, W as MULTI_ASPECT_FRAGMENT_CODE, g as UNKNOWN_ELEMENT_CODE, m as DUPLICATE_EDGE_ID_CODE, n as DUPLICATE_NODE_CODE, s as MISSING_ENDPOINT_CODE, t as MISSING_ID_CODE, ah as STYLES_NOT_IMPORTED_CODE, ai as PARENT_CYCLE_CODE, q as UNKNOWN_PARENT_CODE, o as DUPLICATE_ATTRIBUTE_CODE, i as DANGLING_REFERENCE_CODE, U as UNKNOWN_ATTR_TYPE_CODE, aj as WIDENED_CODE, a3 as BAD_VALUE_CODE, j as COUNT_MISMATCH_CODE, Y as ASPECT_ORDER_CODE, V as BAD_ASPECT_BLOCK_CODE, _ as STATUS_WARNING_CODE, Z as STATUS_FAILED_CODE, w as UNKNOWN_ENCODING_CODE, x as ENCODING_FALLBACK_CODE, y as INVALID_ENCODING_CODE, z as INVALID_UTF8_CODE, ak as SYNTAX_CODE, E as EMPTY_INPUT_CODE, F as ELEMENT_ISSUE, G as INPUT_ISSUE, al as resolveImportOptions, a8 as ImportReportBuilder, a4 as textChunks, am as throwIfAborted, an as reportUnusedOptions, ao as reportSinkOptions, a7 as chooseGraph, ap as graphChosen, aq as DirectionResolver, ar as IdCoercer, $ as agree, a1 as declareResolved, a0 as uniqueColumnName, as as weightFromValue } from "./export-BTI4yQgy.js";
+import { i as isRecord, P as POSITION_COLUMN, h as headText, s as scanAspects, r as reportTooDeep, a as reportSharedBlock, C as CxStructure, J as JsonScanError, E as ExactInteger, c as cxId, p as plainJson, f as fitsF32, b as flipY, z as zDecl, d as positionDecl, e as declareFresh, g as inexactLiteral, k as keptPrecision } from "./json-elements-3tnyt5uZ.js";
+import { j as joinText, e as encodeChunks } from "./writer-DxjgHwSe.js";
+const CX_FORMAT$1 = "cx";
+const CX_LOSS = Object.freeze({
+  /**
+   * Every edge is written as directed, so an undirected graph, or the undirected edges of a mixed graph, read back
+   * as directed.
+   */
+  UNDIRECTED_AS_DIRECTED: "W_CX_UNDIRECTED_AS_DIRECTED",
+  /** A nested (json) column is written as a string attribute holding its JSON text. */
+  JSON_AS_STRING: "W_CX_JSON_AS_STRING",
+  /** A mutual pair is written as two directed edges without its mark. */
+  MUTUAL_EXPANDED: LOSS.MUTUAL_EXPANDED,
+  /**
+   * An attribute named `weight` without the weight role reads back as the edge weight, or is not written when the
+   * graph has weights of its own.
+   */
+  WEIGHT_KEY_CLASH: LOSS.WEIGHT_KEY_CLASH,
+  /** A start / end / timestamp column: CX has no time. */
+  TEMPORAL_DROPPED: LOSS.TEMPORAL,
+  /** An attribute with a role the format has no place for is written as a plain attribute; the role is lost. */
+  ROLE_DROPPED: LOSS.ROLE,
+  /**
+   * An attribute without a role is written where the format keeps a role (for example, a `name` column as the label), and
+   * reads back with that role.
+   */
+  ROLE_ASSUMED: LOSS.ROLE_ASSUMED,
+  /**
+   * An attribute type CX stores as another (a 32-bit float as double, an unsigned integer as long, a byte as
+   * integer, a dictionary as string); it reads back with that type.
+   */
+  DTYPE_UNSUPPORTED: LOSS.DTYPE,
+  /** A multi-component column (a second view's `position@2`, a vector) is written as a list of doubles. */
+  COMPONENTS_FLATTENED: LOSS.COMPONENTS,
+  /** A declared default: CX has none. */
+  DEFAULT_DROPPED: LOSS.DEFAULT,
+  /** Declared options: CX has no enumerations. */
+  OPTIONS_DROPPED: LOSS.OPTIONS,
+  /**
+   * Node ids the format cannot write, under `sanitizeIds: "error"`; the save fails with E_INVALID_ID. Pass
+   * `sanitizeIds: "mangle"` to rewrite them.
+   */
+  ID_CHARSET: LOSS.ID_CHARSET,
+  /** Node ids that are not integers under sanitizeIds "mangle": renumbered, originals kept. */
+  ID_MANGLED: LOSS.ID_MANGLED,
+  /** Edges without a usable integer id get generated ids. */
+  EDGE_IDS_GENERATED: LOSS.EDGE_IDS_GENERATED,
+  /**
+   * An attribute with a role (for example, the label) is written where the format keeps that role, and reads back under the
+   * name the format's importer gives it.
+   */
+  COLUMN_NAME_CHANGED: LOSS.COLUMN_NAME_CHANGED,
+  /** An extension table other than the `cx:citations` / `cx:supports` tables a CX import creates. */
+  EXTENSION_TABLE_DROPPED: LOSS.EXTENSION_TABLE,
+  /** A position, stacking order or weight that is NaN or infinite: CX spells no such number there. */
+  NONFINITE_AS_NULL: LOSS.NONFINITE_AS_NULL,
+  /** Visual columns (color, size, shape, thickness roles): CX keeps style as visual properties, not roles. */
+  VIZ_DROPPED: LOSS.VIZ
+});
+const CX_CAPABILITIES = capabilities({
+  mixedDirection: false,
+  multiEdges: true,
+  selfLoops: true,
+  edgeIds: "required",
+  idCharset: "integer",
+  dtypes: ["string", "f64", "i32", "bool"],
+  components: false,
+  lists: true,
+  json: false,
+  defaults: false,
+  options: false,
+  hierarchy: true,
+  temporal: "none",
+  graphAttributes: true,
+  positions: true,
+  viz: false
+});
+const SLOT_ROLES = /* @__PURE__ */ new Set(["label", "position", "id"]);
+const ROLE_NAMES = Object.freeze({
+  label: "name",
+  position: POSITION_COLUMN,
+  id: "id",
+  parent: "parent"
+});
+const SKIPPED_ROLES = /* @__PURE__ */ new Set([
+  "directed",
+  "pair",
+  "mutual",
+  "weight",
+  "timeText",
+  "originalId",
+  "parent",
+  "parents",
+  "start",
+  "end",
+  "timestamp",
+  "timestamps",
+  "spells",
+  "open",
+  "spellsOpen",
+  "position",
+  "color",
+  "size",
+  "shape",
+  "thickness",
+  "id"
+]);
+const BYPASS_NAMESPACE = "cx.bypass";
+const PROVENANCE_TABLES = Object.freeze({
+  "cx:citations": "citations",
+  "cx:supports": "supports"
+});
+const NEVER_WRITTEN = /* @__PURE__ */ new Set([
+  "nodes",
+  "edges",
+  "nodeAttributes",
+  "edgeAttributes",
+  "networkAttributes",
+  "cartesianLayout",
+  "cyGroups",
+  "cyVisualProperties",
+  "cyTableColumn",
+  "cySubNetworks",
+  "cyNetworkRelations",
+  "cyViews",
+  "CX Element ID",
+  "citations",
+  "supports",
+  "nodeCitations",
+  "edgeCitations",
+  "nodeSupports",
+  "edgeSupports",
+  "functionTerms",
+  "reifiedEdges",
+  "numberVerification",
+  "metaData",
+  "status",
+  "groups",
+  "subnetwork"
+]);
+const WEIGHT_ATTRIBUTE = "weight";
+const NUMERIC_DTYPES = /* @__PURE__ */ new Set(["f32", "f64", "i32", "u32", "u8"]);
+function fromCx(column, namespace) {
+  return column.meta.origin?.format === CX_FORMAT$1 && column.meta.origin.namespace === namespace;
+}
+function isBypass(column) {
+  return column.meta.origin?.namespace === BYPASS_NAMESPACE;
+}
+function isZ(column) {
+  return column.meta.extra.cytoscape === "z";
+}
+function isLink(column) {
+  return fromCx(column, "provenance") && column.meta.dtype === "list" && (column.meta.name === "citations" || column.meta.name === "supports");
+}
+function coreNeedsText(column) {
+  const { dtype } = column.meta;
+  return dtype !== "string" && dtype !== "dict" && dtype !== "json";
+}
+function genericNotes(snapshot, common, several, own, notes, note) {
+  let fatal = null;
+  const edgeLabel = snapshot.edges.byRole("label")?.meta.name;
+  const ownNames = new Set(own.filter((c) => c !== null).map((c) => c.meta.name));
+  for (const gen of checkCapabilities(snapshot, CX_CAPABILITIES, common, {
+    roles: SLOT_ROLES,
+    // a parents column reads back as parents only when some node has several parents
+    roleNames: several ? { ...ROLE_NAMES, parents: "parents" } : ROLE_NAMES
+  })) {
+    if (writtenOtherwise(gen, ownNames)) {
+      continue;
+    }
+    if (gen.code === LOSS.JSON) {
+      const which = gen.column === null ? "a column" : `column "${gen.column}"`;
+      note(
+        CX_LOSS.JSON_AS_STRING,
+        `${which} holds nested values; written as a string attribute holding their JSON text`,
+        gen.column,
+        gen.count
+      );
+      continue;
+    }
+    if (isEdgeLabelRename(gen, edgeLabel)) {
+      note(
+        LOSS.ROLE,
+        `edge column "${edgeLabel ?? ""}" (label) is written as a plain attribute; CX edges have no label slot and the role is lost`,
+        gen.column,
+        gen.count
+      );
+      continue;
+    }
+    if (gen.code === LOSS.MIXED_DIRECTION_ERROR && fatal === null) {
+      fatal = new GraphFormatError("E_DIRECTED", gen.message, { reason: "mixed direction" });
+    }
+    notes.push(gen);
+  }
+  if (edgeLabel === "name") {
+    note(
+      LOSS.ROLE,
+      `edge column "name" (label) is written as a plain attribute; CX edges have no label slot and the role is lost`,
+      "name",
+      null
+    );
+  }
+  return fatal;
+}
+function writtenOtherwise(gen, ownNames) {
+  if (gen.column !== null && ownNames.has(gen.column) && (gen.code === LOSS.JSON || gen.code === LOSS.DTYPE)) {
+    return true;
+  }
+  if (gen.code === LOSS.ID_CHARSET || gen.code === LOSS.ID_MANGLED) {
+    return true;
+  }
+  return gen.code === LOSS.EXTENSION_TABLE && gen.column !== null && gen.column in PROVENANCE_TABLES;
+}
+function isEdgeLabelRename(gen, edgeLabel) {
+  return gen.code === LOSS.COLUMN_NAME_CHANGED && gen.column === edgeLabel && gen.message.startsWith("edge column");
+}
+function planPositions(snapshot, note) {
+  const position = snapshot.nodes.byRole("position");
+  const zColumn = [...snapshot.nodes].find(isZ) ?? null;
+  const z = zColumn !== null && zFitsLayout(zColumn, position) ? zColumn : null;
+  if (position === null) {
+    return { position, z, positionZ: false, nonfinite: 0 };
+  }
+  let nonfinite = nonFiniteCells(position, (v) => [v[0], v[1]]);
+  const depth = nonFiniteCells(position, (v) => v[2] === 0 ? [] : [Number.NaN]);
+  const positionZ = zColumn === null && (position.meta.extra.sourceDims === 3 || depth > 0);
+  if (positionZ) {
+    nonfinite += nonFiniteCells(position, (v) => Number.isFinite(v[0]) && Number.isFinite(v[1]) ? [v[2]] : []);
+    note(
+      LOSS.COMPONENTS,
+      `node column "${position.meta.name}" (position) has a third coordinate; CX writes it as the layout's z, which reads back in the z column (a stacking order), not in the position`,
+      position.meta.name,
+      depth
+    );
+  }
+  return { position, z, positionZ, nonfinite };
+}
+function graphColumnNotes(snapshot, note) {
+  for (const c of snapshot.graph) {
+    const named = c.meta.name === "name" || c.meta.name === "description";
+    if (!isBypass(c) && named && (c.dtype === "string" || c.dtype === "dict")) {
+      note(
+        LOSS.ROLE_ASSUMED,
+        `graph column "${c.meta.name}" is written as the network attribute ${c.meta.name}, which reads back as the graph's ${c.meta.name}, not as a column`,
+        c.meta.name,
+        null
+      );
+    }
+  }
+}
+function plan(snapshot, common) {
+  const { notes, note } = noteList();
+  const functionTerm = [...snapshot.nodes].find((c) => fromCx(c, "provenance") && c.meta.name === "functionTerm") ?? null;
+  const reifiedEdge = [...snapshot.nodes].find((c) => fromCx(c, "reifiedEdges") && c.dtype === "u32") ?? null;
+  const children = childrenCsr(snapshot);
+  const several = children.column?.meta.role === "parents" && severalParents(children.column);
+  let fatal = genericNotes(snapshot, common, several, [functionTerm, reifiedEdge], notes, note);
+  const folding = pairFolding(snapshot);
+  directionNotes(snapshot, folding, common, CX_LOSS.UNDIRECTED_AS_DIRECTED, note);
+  const planned = planNodeIds(snapshot, common, "CX", ORIGINAL_ID_ATTRIBUTE, note);
+  const ids = planned instanceof GraphFormatError ? null : planned;
+  if (planned instanceof GraphFormatError) {
+    fatal ??= planned;
+  }
+  const edgeIds = planEdgeIds(snapshot, note);
+  if (snapshot.nodes.has(ORIGINAL_ID_ATTRIBUTE)) {
+    note(
+      LOSS.ROLE_ASSUMED,
+      `node column "${ORIGINAL_ID_ATTRIBUTE}" is the importer's record of mangled ids: it reads back as the node ids unless restoreMangledIds is false`,
+      ORIGINAL_ID_ATTRIBUTE,
+      null
+    );
+  }
+  const positions = planPositions(snapshot, note);
+  const { position, z, positionZ } = positions;
+  let { nonfinite } = positions;
+  const collapsed = [...snapshot.nodes].find((c) => fromCx(c, "cyGroups") && c.dtype === "bool") ?? null;
+  const nodeCore = corePlans(snapshot, note);
+  const edgeCore = [];
+  const interaction = snapshot.edges.get("interaction");
+  if (interaction !== null && (interaction.meta.role === null || !SKIPPED_ROLES.has(interaction.meta.role))) {
+    edgeCore.push({ key: "i", column: interaction });
+    coreTextNote(interaction, "edge", note);
+  }
+  const coreColumns = new Set([...nodeCore, ...edgeCore].map((c) => c.column));
+  const special = (c) => coreColumns.has(c) || isBypass(c) || isLink(c) || c === z || c === collapsed || c === functionTerm || c === reifiedEdge || c.meta.role !== null && SKIPPED_ROLES.has(c.meta.role);
+  const label = snapshot.nodes.byRole("label");
+  const renamedName = label !== null && label.meta.name !== "name" ? snapshot.nodes.get("name") : null;
+  if (renamedName !== null) {
+    note(
+      LOSS.COLUMN_NAME_CHANGED,
+      `node column "name" is written as the attribute "name#2": the label column "${label?.meta.name ?? ""}" is written as n, which reads back as "name"`,
+      "name",
+      renamedName.length - renamedName.nullCount
+    );
+  }
+  const nodeAttrs = attributePlans(snapshot.nodes, special, (c) => c === renamedName ? "name#2" : c.meta.name);
+  const weight = planWeight(snapshot, folding, note);
+  const plainWeight = snapshot.edges.get(WEIGHT_ATTRIBUTE);
+  const edgeAttrs = attributePlans(
+    snapshot.edges,
+    (c) => special(c) || c === plainWeight && c.meta.role === null,
+    (c) => c.meta.name
+  );
+  nonfinite += weight.nonfinite;
+  graphColumnNotes(snapshot, note);
+  const graphAttrs = attributePlans(snapshot.graph, isBypass, (c) => c.meta.name);
+  if (children.column !== null && children.column.meta.role === "parents" && !several) {
+    note(
+      LOSS.COLUMN_NAME_CHANGED,
+      `node column "${children.column.meta.name}" (parents) holds at most one parent per node; it reads back as the single-parent column "parent"`,
+      children.column.meta.name,
+      children.column.length - children.column.nullCount
+    );
+  }
+  if (nonfinite > 0) {
+    note(
+      LOSS.NONFINITE_AS_NULL,
+      `${nonfinite} NaN or infinite position${plural(nonfinite)}, stacking orders or weights cannot be written in CX; they read back unset`,
+      null,
+      nonfinite
+    );
+  }
+  return {
+    notes,
+    fatal,
+    ids,
+    folding,
+    edgeIds,
+    weight: weight.plan,
+    nodeCore,
+    edgeCore,
+    nodeAttrs,
+    edgeAttrs,
+    graphAttrs,
+    position,
+    positionZ,
+    z,
+    bypass: {
+      node: [...snapshot.nodes].filter(isBypass),
+      edge: [...snapshot.edges].filter(isBypass),
+      graph: [...snapshot.graph].filter(isBypass)
+    },
+    collapsed,
+    links: linkPlans(snapshot),
+    functionTerm,
+    reifiedEdge
+  };
+}
+function corePlans(snapshot, note) {
+  const out = [];
+  const label = snapshot.nodes.byRole("label");
+  const plainName = snapshot.nodes.get("name");
+  const n = label ?? (plainName !== null && plainName.meta.role === null ? plainName : null);
+  if (n !== null) {
+    out.push({ key: "n", column: n });
+    coreTextNote(n, "node", note);
+    if (n !== label) {
+      note(
+        LOSS.ROLE_ASSUMED,
+        `node column "name" is written as n and reads back as the label`,
+        "name",
+        n.length - n.nullCount
+      );
+    }
+  }
+  const represents = snapshot.nodes.get("represents");
+  if (represents !== null && represents !== n && (represents.meta.role === null || !SKIPPED_ROLES.has(represents.meta.role))) {
+    out.push({ key: "r", column: represents });
+    coreTextNote(represents, "node", note);
+  }
+  return out;
+}
+function coreTextNote(column, domain, note) {
+  if (coreNeedsText(column)) {
+    note(
+      LOSS.DTYPE,
+      `${domain} column "${column.meta.name}" is ${column.dtype}; CX writes it as text and it reads back as string`,
+      column.meta.name,
+      column.length - column.nullCount
+    );
+  }
+}
+function attributePlans(table, skip, rename) {
+  return [...table].filter((c) => !skip(c)).map((column) => ({ column, name: rename(column), d: declaredType(column) }));
+}
+function planWeight(snapshot, folding, note) {
+  const weights = explicitWeights(snapshot);
+  const plain = snapshot.edges.get(WEIGHT_ATTRIBUTE);
+  const clash = plain !== null && plain.meta.role === null;
+  let plan2 = null;
+  if (weights.weighted) {
+    plan2 = { value: (e) => weights.isExplicit(e) ? weights.value(e) : void 0 };
+    if (clash) {
+      note(
+        LOSS.WEIGHT_KEY_CLASH,
+        `edge column "${WEIGHT_ATTRIBUTE}" is not written: the explicit weights are written under that name`,
+        WEIGHT_ATTRIBUTE,
+        null
+      );
+    }
+  } else if (clash) {
+    const numeric = NUMERIC_DTYPES.has(plain.dtype);
+    note(
+      LOSS.WEIGHT_KEY_CLASH,
+      numeric ? `edge column "${WEIGHT_ATTRIBUTE}" is written as the weight attribute and reads back as the edge weight` : `edge column "${WEIGHT_ATTRIBUTE}" is ${plain.dtype}, and CX reads that attribute as the edge weight; it is not written`,
+      WEIGHT_ATTRIBUTE,
+      null
+    );
+    if (numeric) {
+      plan2 = { value: (e) => plain.isSet(e) ? plain.value(e) : void 0 };
+    }
+  }
+  return { plan: plan2, nonfinite: plan2 === null ? 0 : nanWeights(snapshot.edgeCount, plan2, folding) };
+}
+function nanWeights(edgeCount, plan2, folding) {
+  let nan = 0;
+  for (let e = 0; e < edgeCount; e++) {
+    const w = plan2.value(e);
+    if (!folding.folded(e) && w !== void 0 && Number.isNaN(w)) {
+      nan++;
+    }
+  }
+  return nan;
+}
+function zFitsLayout(z, position) {
+  for (let i = 0; i < z.length; i++) {
+    if (!z.isSet(i)) {
+      continue;
+    }
+    const value = z.value(i);
+    const point = position?.isSet(i) === true ? position.value(i) : null;
+    if (typeof value !== "number" || !Number.isFinite(value) || point === null || !Number.isFinite(point[0]) || !Number.isFinite(point[1])) {
+      return false;
+    }
+  }
+  return true;
+}
+function nonFiniteCells(column, pick) {
+  let count = 0;
+  for (let i = 0; i < column.length; i++) {
+    if (column.isSet(i) && pick(column.value(i)).some((v) => !Number.isFinite(v))) {
+      count++;
+    }
+  }
+  return count;
+}
+function severalParents(column) {
+  for (let i = 0; i < column.length; i++) {
+    if (column.isSet(i) && column.value(i).length > 1) {
+      return true;
+    }
+  }
+  return false;
+}
+function linkPlans(snapshot) {
+  const out = [];
+  for (const [domain, table] of [
+    ["node", snapshot.nodes],
+    ["edge", snapshot.edges]
+  ]) {
+    for (const column of table) {
+      if (isLink(column)) {
+        const key = column.meta.name;
+        out.push({ aspect: `${domain}${key === "citations" ? "Citations" : "Supports"}`, key, domain, column });
+      }
+    }
+  }
+  return out;
+}
+function scalarText(value) {
+  if (typeof value === "number") {
+    return Object.is(value, -0) ? "-0" : String(value);
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  return typeof value === "boolean" ? String(value) : JSON.stringify(value);
+}
+function cellValue(column, d, row) {
+  if (!column.isSet(row)) {
+    return void 0;
+  }
+  const value = column.value(row);
+  if (column.meta.dtype === "json") {
+    return JSON.stringify(value);
+  }
+  if (column.meta.dtype === "list" || column.meta.components > 1) {
+    const items = Array.from(value);
+    return d === "string" ? JSON.stringify(items) : items.map(scalarText);
+  }
+  return scalarText(value);
+}
+function coreText(column, row) {
+  if (!column.isSet(row)) {
+    return void 0;
+  }
+  const value = column.value(row);
+  if (column.meta.dtype === "json" || column.meta.dtype === "list" || column.meta.components > 1) {
+    return JSON.stringify(column.meta.dtype === "json" ? value : Array.from(value));
+  }
+  return scalarText(value);
+}
+function writtenEdges(snapshot, folding) {
+  const out = [];
+  for (let e = 0; e < snapshot.edgeCount; e++) {
+    if (!folding.folded(e)) {
+      out.push(e);
+    }
+  }
+  return out;
+}
+function aspects(snapshot, p, ids) {
+  const { src, dst } = snapshot.edgeList();
+  const edges = writtenEdges(snapshot, p.folding);
+  const nodeRange = () => Array.from({ length: snapshot.nodeCount }, (_, i2) => i2);
+  const nodeCore = (key) => p.nodeCore.find((c) => c.key === key)?.column ?? null;
+  const n = nodeCore("n");
+  const r = nodeCore("r");
+  const i = p.edgeCore[0]?.column ?? null;
+  const kept = snapshot.meta.sourceFormat === CX_FORMAT$1 && isRecord(snapshot.meta.extra.cx) ? snapshot.meta.extra.cx : {};
+  const out = [
+    {
+      name: "nodes",
+      idCounter: nextNodeId(ids, snapshot.nodeCount),
+      *elements() {
+        for (let row = 0; row < snapshot.nodeCount; row++) {
+          const element = { "@id": ids.idAt(row) };
+          const name = n === null ? void 0 : coreText(n, row);
+          const represents = r === null ? void 0 : coreText(r, row);
+          if (name !== void 0) {
+            element.n = name;
+          }
+          if (represents !== void 0) {
+            element.r = represents;
+          }
+          yield element;
+        }
+      }
+    },
+    {
+      name: "edges",
+      idCounter: edges.reduce((max, e) => Math.max(max, p.edgeIds[e] + 1), 0),
+      *elements() {
+        for (const e of edges) {
+          const element = {
+            "@id": p.edgeIds[e],
+            s: ids.idAt(src[e]),
+            t: ids.idAt(dst[e])
+          };
+          const interaction = i === null ? void 0 : coreText(i, e);
+          if (interaction !== void 0) {
+            element.i = interaction;
+          }
+          yield element;
+        }
+      }
+    },
+    {
+      name: "nodeAttributes",
+      *elements() {
+        for (const a of p.nodeAttrs) {
+          for (let row = 0; row < snapshot.nodeCount; row++) {
+            const v = cellValue(a.column, a.d, row);
+            if (v !== void 0) {
+              yield { po: ids.idAt(row), n: a.name, v, d: a.d };
+            }
+          }
+        }
+        for (let row = 0; row < snapshot.nodeCount; row++) {
+          if (ids.isChanged(row)) {
+            yield {
+              po: ids.idAt(row),
+              n: ORIGINAL_ID_ATTRIBUTE,
+              v: String(ids.originalAt(row)),
+              d: "string"
+            };
+          }
+        }
+      }
+    },
+    {
+      name: "edgeAttributes",
+      *elements() {
+        for (const a of p.edgeAttrs) {
+          for (const e of edges) {
+            const v = cellValue(a.column, a.d, e);
+            if (v !== void 0) {
+              yield { po: p.edgeIds[e], n: a.name, v, d: a.d };
+            }
+          }
+        }
+        if (p.weight !== null) {
+          for (const e of edges) {
+            const w = p.weight.value(e);
+            if (w !== void 0 && !Number.isNaN(w)) {
+              yield { po: p.edgeIds[e], n: WEIGHT_ATTRIBUTE, v: scalarText(w), d: "double" };
+            }
+          }
+        }
+      }
+    },
+    {
+      name: "networkAttributes",
+      *elements() {
+        for (const a of p.graphAttrs) {
+          const v = cellValue(a.column, a.d, 0);
+          if (v !== void 0) {
+            yield { n: a.name, v, d: a.d };
+          }
+        }
+        const { meta } = snapshot;
+        for (const [key, value] of [
+          ["name", meta.name],
+          ["description", meta.description]
+        ]) {
+          if (value !== null && !p.graphAttrs.some((a) => a.name === key)) {
+            yield { n: key, v: value, d: "string" };
+          }
+        }
+      }
+    },
+    { name: "cyTableColumn", elements: () => tableColumns(p, ids) },
+    { name: "cartesianLayout", elements: () => layoutElements(p, ids, nodeRange()) },
+    { name: "cyGroups", elements: () => groupElements(snapshot, p, ids, edges) },
+    { name: "cyVisualProperties", elements: () => visualProperties(p, ids, nodeRange(), edges, kept) }
+  ];
+  out.push(...provenanceAspects(snapshot, p, ids, edges));
+  for (const [name, value] of Object.entries(kept)) {
+    if (!NEVER_WRITTEN.has(name) && Array.isArray(value)) {
+      out.push({ name, elements: () => keptElements(value, kept.subnetwork, STYLE_ASPECTS.has(name)) });
+    }
+  }
+  return out;
+}
+function* tableColumns(p, ids) {
+  for (const { key, column } of [...p.nodeCore, ...p.edgeCore]) {
+    const n = { n: "name", r: "represents", i: "interaction" }[key];
+    if (n !== void 0 && column !== null) {
+      yield { applies_to: key === "i" ? "edge_table" : "node_table", n, d: "string" };
+    }
+  }
+  for (const a of p.nodeAttrs) {
+    yield { applies_to: "node_table", n: a.name, d: a.d };
+  }
+  if (ids.changed > 0) {
+    yield { applies_to: "node_table", n: ORIGINAL_ID_ATTRIBUTE, d: "string" };
+  }
+  for (const a of p.edgeAttrs) {
+    yield { applies_to: "edge_table", n: a.name, d: a.d };
+  }
+  if (p.weight !== null) {
+    yield { applies_to: "edge_table", n: WEIGHT_ATTRIBUTE, d: "double" };
+  }
+  for (const a of p.graphAttrs) {
+    yield { applies_to: "network_table", n: a.name, d: a.d };
+  }
+}
+const STYLE_ASPECTS = /* @__PURE__ */ new Set(["tableVisualProperties", "cyTableVisualProperties"]);
+function* keptElements(elements, subnetwork, style) {
+  for (const element of elements) {
+    if (!isRecord(element)) {
+      yield element;
+      continue;
+    }
+    if (element.s !== void 0 && element.s !== null && element.s !== subnetwork) {
+      continue;
+    }
+    const { s: _scope, ...rest } = element;
+    yield style ? rewriteView(rest) : rest;
+  }
+}
+function rewriteView(element) {
+  const out = { ...element };
+  if ("view" in out) {
+    out.view = 0;
+  }
+  if (typeof out.applies_to === "number") {
+    out.applies_to = 0;
+  }
+  return out;
+}
+function* layoutElements(p, ids, rows) {
+  const { position } = p;
+  if (position === null) {
+    return;
+  }
+  for (const row of rows) {
+    if (!position.isSet(row)) {
+      continue;
+    }
+    const point = position.value(row);
+    if (!Number.isFinite(point[0]) || !Number.isFinite(point[1])) {
+      continue;
+    }
+    const entry = { node: ids.idAt(row), x: point[0], y: point[1] === 0 ? 0 : -point[1] };
+    if (p.z?.isSet(row) === true) {
+      entry.z = p.z.value(row);
+    } else if (p.positionZ && Number.isFinite(point[2])) {
+      entry.z = point[2];
+    }
+    yield entry;
+  }
+}
+function* groupElements(snapshot, p, ids, edges) {
+  const children = childrenCsr(snapshot);
+  const groupsOf = /* @__PURE__ */ new Map();
+  const groups = [];
+  for (let g = 0; g < snapshot.nodeCount; g++) {
+    const members = children.childrenOf(g);
+    if (members.length > 0 || p.collapsed?.isSet(g) === true) {
+      groups.push(g);
+    }
+    for (const c of members) {
+      groupsOf.set(c, [...groupsOf.get(c) ?? [], g]);
+    }
+  }
+  if (groups.length === 0) {
+    return;
+  }
+  const { internal, external } = groupEdges(snapshot, p, groupsOf, edges);
+  const label = p.nodeCore.find((c) => c.key === "n")?.column ?? null;
+  for (const g of groups) {
+    const entry = { "@id": ids.idAt(g) };
+    const name = label === null ? void 0 : coreText(label, g);
+    if (name !== void 0) {
+      entry.n = name;
+    }
+    entry.nodes = Array.from(children.childrenOf(g), (c) => ids.idAt(c));
+    entry.internal_edges = internal.get(g) ?? [];
+    entry.external_edges = external.get(g) ?? [];
+    if (p.collapsed?.isSet(g) === true) {
+      entry.collapsed = p.collapsed.value(g);
+    }
+    yield entry;
+  }
+}
+function groupEdges(snapshot, p, groupsOf, edges) {
+  const internal = /* @__PURE__ */ new Map();
+  const external = /* @__PURE__ */ new Map();
+  const add = (table, g, id) => {
+    table.set(g, [...table.get(g) ?? [], id]);
+  };
+  const { src, dst } = snapshot.edgeList();
+  for (const e of edges) {
+    const ofSource = groupsOf.get(src[e]) ?? [];
+    const ofTarget = groupsOf.get(dst[e]) ?? [];
+    for (const g of ofSource) {
+      add(ofTarget.includes(g) ? internal : external, g, p.edgeIds[e]);
+    }
+    for (const g of ofTarget.filter((t) => !ofSource.includes(t))) {
+      add(external, g, p.edgeIds[e]);
+    }
+  }
+  return { internal, external };
+}
+function bypassValues(columns, row) {
+  let out = null;
+  for (const column of columns) {
+    if (column.isSet(row)) {
+      const property = column.meta.origin?.id;
+      out ??= {};
+      out[typeof property === "string" && property.length > 0 ? property : column.meta.name] = scalarText(
+        column.value(row)
+      );
+    }
+  }
+  return out;
+}
+function* visualProperties(p, ids, rows, edges, kept) {
+  const network = bypassValues(p.bypass.graph, 0);
+  if (network !== null) {
+    yield { properties_of: "network", properties: network };
+  }
+  const view = ownView(kept);
+  for (const entry of Array.isArray(kept.cyVisualProperties) ? kept.cyVisualProperties : []) {
+    if (isRecord(entry) && !["nodes", "edges", "network"].includes(String(entry.properties_of)) && (view === null || entry.view === void 0 || entry.view === null || entry.view === view)) {
+      yield rewriteView(entry);
+    }
+  }
+  for (const row of rows) {
+    const properties = bypassValues(p.bypass.node, row);
+    if (properties !== null) {
+      yield { properties_of: "nodes", applies_to: ids.idAt(row), properties };
+    }
+  }
+  for (const e of edges) {
+    const properties = bypassValues(p.bypass.edge, e);
+    if (properties !== null) {
+      yield { properties_of: "edges", applies_to: p.edgeIds[e], properties };
+    }
+  }
+}
+function ownView(kept) {
+  const sub = kept.subnetwork;
+  for (const r of Array.isArray(kept.cyNetworkRelations) ? kept.cyNetworkRelations : []) {
+    if (isRecord(r) && r.r === "view" && (sub === void 0 || r.p === sub)) {
+      return r.c;
+    }
+  }
+  for (const v of Array.isArray(kept.cyViews) ? kept.cyViews : []) {
+    if (isRecord(v) && (sub === void 0 || v.s === sub)) {
+      return v["@id"];
+    }
+  }
+  return null;
+}
+function provenanceAspects(snapshot, p, ids, edges) {
+  const out = [];
+  for (const [table, aspect2] of Object.entries(PROVENANCE_TABLES)) {
+    const ext = snapshot.extensions.get(table);
+    if (ext === void 0) {
+      continue;
+    }
+    const idColumn = ext.get("id");
+    const fields = [...ext].filter((c) => c !== idColumn);
+    let max = -1;
+    for (let row = 0; row < ext.rowCount; row++) {
+      if (idColumn?.isSet(row) === true) {
+        max = Math.max(max, Number(idColumn.value(row)));
+      }
+    }
+    out.push({
+      name: aspect2,
+      idCounter: max + 1,
+      *elements() {
+        for (let row = 0; row < ext.rowCount; row++) {
+          const element = {};
+          if (idColumn?.isSet(row) === true) {
+            element["@id"] = idColumn.value(row);
+          }
+          for (const field of fields) {
+            if (field.isSet(row)) {
+              element[field.meta.name] = field.value(row);
+            }
+          }
+          yield element;
+        }
+      }
+    });
+  }
+  for (const link of p.links) {
+    out.push({
+      name: link.aspect,
+      *elements() {
+        const rows = link.domain === "node" ? Array.from({ length: snapshot.nodeCount }, (_, i) => i) : edges;
+        for (const row of rows) {
+          if (link.column.isSet(row)) {
+            const po = link.domain === "node" ? ids.idAt(row) : p.edgeIds[row];
+            yield { po: [po], [link.key]: Array.from(link.column.value(row)) };
+          }
+        }
+      }
+    });
+  }
+  const terms = p.functionTerm;
+  if (terms !== null) {
+    out.push({
+      name: "functionTerms",
+      *elements() {
+        for (let row = 0; row < snapshot.nodeCount; row++) {
+          const term = terms.isSet(row) ? terms.value(row) : null;
+          if (isRecord(term)) {
+            yield { po: ids.idAt(row), ...term };
+          }
+        }
+      }
+    });
+  }
+  const reified = p.reifiedEdge;
+  if (reified !== null) {
+    out.push({
+      name: "reifiedEdges",
+      *elements() {
+        for (let row = 0; row < snapshot.nodeCount; row++) {
+          const edge = reified.isSet(row) ? reified.value(row) : -1;
+          if (edge >= 0 && edge < snapshot.edgeCount) {
+            yield { node: ids.idAt(row), edge: p.edgeIds[edge] };
+          }
+        }
+      }
+    });
+  }
+  return out;
+}
+function* write(snapshot, p) {
+  if (p.fatal !== null) {
+    throw p.fatal;
+  }
+  const { ids } = p;
+  if (ids === null) {
+    throw new GraphFormatError("E_INVALID_ID", "node ids cannot be written as CX integers", { reason: "charset" });
+  }
+  const all = aspects(snapshot, p, ids);
+  const written = [];
+  for (const aspect2 of all) {
+    let count = 0;
+    for (const _ of aspect2.elements()) {
+      count++;
+    }
+    if (count > 0 || aspect2.name === "nodes") {
+      written.push({ aspect: aspect2, count });
+    }
+  }
+  const metaData = written.map(({ aspect: aspect2, count }) => ({
+    name: aspect2.name,
+    version: "1.0",
+    ...aspect2.idCounter === void 0 ? {} : { idCounter: aspect2.idCounter },
+    elementCount: count,
+    consistencyGroup: 1
+  }));
+  yield '[{"numberVerification":[{"longNumber":281474976710655}]},\n';
+  yield `{"metaData":${stringify(metaData)}},
+`;
+  for (const { aspect: aspect2 } of written) {
+    yield* aspectBlock(aspect2.name, mapIterable(aspect2.elements(), stringify));
+  }
+  yield '{"status":[{"error":"","success":true}]}]\n';
+}
+function* mapIterable(items, fn) {
+  for (const item of items) {
+    yield fn(item);
+  }
+}
+const cxExporter = Object.freeze({
+  format: CX_FORMAT$1,
+  options: Object.freeze([]),
+  capabilities: CX_CAPABILITIES,
+  /**
+   * Pre-flight: what export() would lose, without writing anything.
+   * @param snapshot - the snapshot
+   * @param options - the common options
+   * @returns the notes, empty when the export is exact
+   */
+  check(snapshot, options) {
+    return Object.freeze([...plan(snapshot, resolveExportOptions(options)).notes]);
+  },
+  /**
+   * Write the document as UTF-8 chunks.
+   * @param snapshot - the snapshot
+   * @param options - the common options
+   * @returns the chunks
+   */
+  export(snapshot, options) {
+    return encodeChunks(write(snapshot, plan(snapshot, resolveExportOptions(options))));
+  },
+  /**
+   * Write the document as one string.
+   * @param snapshot - the snapshot
+   * @param options - the common options
+   * @returns the document
+   */
+  exportToString(snapshot, options) {
+    return joinText(write(snapshot, plan(snapshot, resolveExportOptions(options))));
+  }
+});
 const CX_FORMAT = "cx";
 const CX_BYPASS_NAMESPACE = "cx.bypass";
 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",
@@ -28,11 +988,14 @@ 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,
@@ -40,7 +1003,10 @@ 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,
@@ -52,9 +1018,9 @@ 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,
@@ -64,37 +1030,63 @@ 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 = /* @__PURE__ */ new Set([
@@ -106,6 +1098,7 @@ const USED_OPTIONS = /* @__PURE__ */ new Set([
   "weightFrom",
   "weightDtype",
   "long",
+  "restoreMangledIds",
   "errorLimit",
   "signal",
   "onProgress"
@@ -118,12 +1111,15 @@ const FORMAT_DEFAULTS = {
 };
 const ABORT_CHECK_INTERVAL = 64;
 const NUMBER_VERIFICATION_VALUES = /* @__PURE__ */ new Set(["281474976710655", "9223372036854775807"]);
-const OLD_ASPECT_NAMES = {
-  visualProperties: "cyVisualProperties",
-  subNetworks: "cySubNetworks",
-  networkRelations: "cyNetworkRelations",
-  hiddenAttributes: "cyHiddenAttributes"
-};
+const OLD_ASPECT_NAMES = /* @__PURE__ */ new Map([
+  ["visualProperties", "cyVisualProperties"],
+  ["subNetworks", "cySubNetworks"],
+  ["networkRelations", "cyNetworkRelations"],
+  ["hiddenAttributes", "cyHiddenAttributes"]
+]);
+const NODE_KEYS = /* @__PURE__ */ new Set(["@id", "n", "r"]);
+const EDGE_KEYS = /* @__PURE__ */ new Set(["@id", "s", "t", "i"]);
+const TABLES = /* @__PURE__ */ new Set(["node_table", "edge_table", "network_table"]);
 const READ_ASPECTS = /* @__PURE__ */ new Set([
   "nodes",
   "edges",
@@ -159,6 +1155,7 @@ const ALSO_KEPT = /* @__PURE__ */ new Set([
   "metaData"
 ]);
 const TABLE_STYLE_ASPECTS = ["tableVisualProperties", "cyTableVisualProperties"];
+const OWN_EXTRA_KEYS = ["groups", "subnetwork"];
 const CX_FIRST_KEYS = ["numberVerification", "metaData"];
 const CX_ASPECT_KEYS = [
   "nodes",
@@ -185,14 +1182,14 @@ const CX_ASPECT_KEYS = [
   "supports",
   "functionTerms"
 ];
-const SCALARS = {
-  string: "string",
-  boolean: "boolean",
-  integer: "integer",
-  long: "long",
-  double: "double",
-  float: "double"
-};
+const SCALARS = /* @__PURE__ */ new Map([
+  ["string", "string"],
+  ["boolean", "boolean"],
+  ["integer", "integer"],
+  ["long", "long"],
+  ["double", "double"],
+  ["float", "double"]
+]);
 function cxType(d) {
   if (d === void 0 || d === null) {
     return { scalar: "string", list: false };
@@ -201,7 +1198,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 === void 0 ? null : { scalar, list };
 }
 function typeText(type) {
@@ -290,7 +1287,14 @@ 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)) {
+        onPrecision(value);
+      }
+      return n;
     }
   }
 }
@@ -369,13 +1373,13 @@ function shown(value) {
 function aspect(doc, name) {
   return doc.aspects.get(name) ?? [];
 }
-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;
     }
   });
@@ -405,18 +1409,99 @@ function checkNumberVerification(value, count, report, line) {
     );
   }
 }
+function isCxAspect(name) {
+  return READ_ASPECTS.has(name) || OLD_ASPECT_NAMES.has(name) || CX_ASPECT_KEYS.includes(name) || TABLE_STYLE_ASPECTS.includes(name);
+}
+const ID_KEYS = /* @__PURE__ */ new Map([
+  ["nodes", ["@id"]],
+  ["edges", ["@id", "s", "t"]]
+]);
+function fileAttribute(table, name, held, report) {
+  const { value, line } = held;
+  const n = isRecord(value) ? value.n : void 0;
+  if (n === void 0 || 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);
+}
+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, []);
+    }
+    const onPrecision = name === "numberVerification" ? void 0 : 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 === void 0 ? 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);
+}
 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: /* @__PURE__ */ new Map(),
     attributes: { node: /* @__PURE__ */ new Map(), edge: /* @__PURE__ */ new Map(), network: /* @__PURE__ */ new Map() },
     kept: /* @__PURE__ */ 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 = /* @__PURE__ */ 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 === void 0) {
       return name;
     }
@@ -429,51 +1514,11 @@ async function readDocument(input, report, options) {
     );
     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);
@@ -482,7 +1527,7 @@ async function readDocument(input, report, options) {
         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;
@@ -497,11 +1542,21 @@ 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,
@@ -511,21 +1566,24 @@ async function readDocument(input, report, options) {
           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;
@@ -539,99 +1597,88 @@ 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;
 }
 function refId(raw) {
   try {
-    return cxId(raw).id;
-  } catch {
-    return null;
-  }
-}
-function memberSet(raw) {
-  if (raw === "all") {
-    return null;
-  }
-  const out = /* @__PURE__ */ new Set();
-  if (Array.isArray(raw)) {
-    for (const item of raw) {
-      const id = refId(item);
-      if (id !== null) {
-        out.add(id);
-      }
-    }
-  }
-  return out;
-}
-function graphPlans(doc) {
-  const subs = /* @__PURE__ */ 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 = /* @__PURE__ */ new Map();
-  const order = [];
-  const views = /* @__PURE__ */ 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);
-    }
+    return cxId(raw).id;
+  } catch {
+    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);
-    }
+}
+function memberSet(raw, onBad) {
+  if (raw === "all") {
+    return null;
   }
-  for (const id of subs.keys()) {
-    if (!order.includes(id)) {
-      order.push(id);
+  const out = /* @__PURE__ */ new Set();
+  if (Array.isArray(raw)) {
+    for (const item of raw) {
+      const id = refId(item);
+      if (id === null) {
+        onBad?.(CX_ISSUE.INVALID_ID, `the member ${shown(item)} is not an id; ignored`);
+      } else {
+        out.add(id);
+      }
     }
+  } else if (raw !== void 0) {
+    onBad?.(BAD_VALUE_CODE, `the member list ${shown(raw)} is neither a list of ids nor "all"; read as empty`);
   }
-  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 === void 0 ? null : refId(value.s);
-      if (scope === sub) {
-        return value.v;
+  return out;
+}
+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
       }
-      if (scope === null) {
-        found ??= value.v;
+    );
+    return null;
+  }
+  if (value[key] === void 0 || value[key] === null) {
+    report.error("missing-value", MISSING_ID_CODE, `a ${name} element has no ${key}; skipped`, {
+      line,
+      element: name
+    });
+    return null;
+  }
+  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 found;
-  };
+    );
+    return null;
+  }
+  return { value, id };
+}
+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 ? void 0 : subs.get(sub);
@@ -642,10 +1689,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,
@@ -655,13 +1703,99 @@ 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) ?? []
   }));
 }
+function readSubnetworks(doc, report) {
+  const subs = /* @__PURE__ */ 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;
+}
+function readRelations(doc, subs, report) {
+  const relationNames = /* @__PURE__ */ new Map();
+  const order = [];
+  const views = /* @__PURE__ */ 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 };
+}
+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);
+  }
+}
+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 === void 0 ? null : refId(value.s);
+    if (scope === sub) {
+      return value.v;
+    }
+    if (scope === null) {
+      found ??= value.v;
+    }
+  }
+  return found;
+}
 function layoutViews(doc) {
   const out = [];
   for (const { value } of aspect(doc, "cartesianLayout")) {
@@ -685,11 +1819,13 @@ class CxReader {
    * @param doc - the collected document
    * @param plan - the graph to read
    */
-  constructor(sink, report, options, zAs, doc, plan) {
+  constructor(sink, report, options, zAs, doc, plan2) {
     this.rootNodes = /* @__PURE__ */ new Set();
     this.rootEdges = /* @__PURE__ */ new Set();
     this.nodeRows = /* @__PURE__ */ new Map();
+    this.sinkRows = /* @__PURE__ */ new Map();
     this.edgeRows = /* @__PURE__ */ new Map();
+    this.sinkIds = /* @__PURE__ */ new Map();
     this.subnetworks = /* @__PURE__ */ new Set();
     this.dangling = /* @__PURE__ */ new Map();
     this.nameHandle = INVALID_INDEX;
@@ -700,13 +1836,13 @@ class CxReader {
     this.idType = "integer";
     this.weighted = false;
     this.coreValues = /* @__PURE__ */ new Map();
-    this.weights = null;
+    this.weights = /* @__PURE__ */ new Map();
     this.sink = sink;
     this.report = report;
     this.options = options;
     this.zAs = zAs;
     this.doc = doc;
-    this.plan = plan;
+    this.plan = plan2;
     this.direction = new DirectionResolver(sink, report, options.onMixedDirection);
     this.coercer = new IdCoercer(options.ids);
     for (const { value } of aspect(doc, "nodes")) {
@@ -734,6 +1870,7 @@ class CxReader {
     this.direction.setHeader(true);
     this.checkMembers();
     this.checkRootOnly();
+    this.checkTableColumns();
     const nodeColumns = this.declareAttributes("node");
     this.readNodes();
     this.readGroups();
@@ -746,9 +1883,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();
   }
@@ -775,15 +1917,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.
@@ -804,14 +1937,16 @@ 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") {
@@ -819,14 +1954,14 @@ 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) {
         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 },
+          { line, element },
           `${PRECISION_CODE}:edge`
         );
       } else if (parsed.note === "precision") {
@@ -835,29 +1970,93 @@ 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
+   */
+  sinkId(id) {
+    const original = this.sinkIds.get(id);
+    if (original !== void 0) {
+      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 !== void 0) {
+      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) {
+    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
+   */
+  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() {
     for (const id of this.plan.nodes ?? []) {
@@ -902,7 +2101,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" }
       );
     }
@@ -930,7 +2129,7 @@ class CxReader {
     const declared = this.tableColumns(domain === "node" ? "node_table" : "edge_table");
     const names = /* @__PURE__ */ 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 = [];
@@ -1023,7 +2222,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);
       }
     }
@@ -1078,14 +2285,6 @@ class CxReader {
         if (scope === 0) {
           continue;
         }
-        const target = refId(value.po);
-        const row = target === null ? void 0 : rows.get(this.key(target));
-        if (row === void 0) {
-          if (target === null || !root.has(target)) {
-            this.dangle(`${domain} attribute target`);
-          }
-          continue;
-        }
         if (value.v === void 0) {
           this.report.error(
             "missing-value",
@@ -1098,23 +2297,33 @@ class CxReader {
           );
           continue;
         }
-        if (value.v === null) {
-          continue;
-        }
-        const previous = chosen.get(row);
-        if (previous !== void 0 && 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}`
-          );
+        for (const raw of Array.isArray(value.po) ? value.po : [value.po]) {
+          const target = refId(raw);
+          const row = target === null ? void 0 : rows.get(target);
+          if (row === void 0) {
+            if (target === null || !root.has(target)) {
+              this.dangle(`${domain} attribute target`);
+            }
+            continue;
+          }
+          if (value.v === null) {
+            continue;
+          }
+          const previous = chosen.get(row);
+          if (previous !== void 0 && 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);
@@ -1160,6 +2369,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 !== void 0 && prior !== value) {
@@ -1229,7 +2447,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;
@@ -1251,38 +2470,64 @@ 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;
       }
-      if (!this.inGraph(refId(value["@id"]) ?? id)) {
+      if (!this.inGraph(id)) {
         continue;
       }
       let row = this.nodeRows.get(id);
-      if (row !== void 0) {
-        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 === void 0) {
+        const original = originals.get(refId(value["@id"]) ?? id);
+        if (original !== void 0) {
+          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 = /* @__PURE__ */ 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
@@ -1334,30 +2579,40 @@ class CxReader {
     }
     const parents = /* @__PURE__ */ 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 !== void 0 && 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 !== void 0 && 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 === void 0) {
         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",
@@ -1374,7 +2629,7 @@ class CxReader {
       }
       for (const raw of Array.isArray(value.nodes) ? value.nodes : []) {
         const member = refId(raw);
-        const row = member === null ? void 0 : this.nodeRows.get(this.key(member));
+        const row = member === null ? void 0 : this.nodeRows.get(member);
         if (row === void 0) {
           if (member === null || !this.rootNodes.has(member)) {
             this.report.error(
@@ -1428,7 +2683,7 @@ class CxReader {
   hasMemberIn(raw) {
     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);
     });
   }
   /**
@@ -1489,6 +2744,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 === void 0 || value.view === null ? null : refId(value.view);
@@ -1509,14 +2770,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 ? void 0 : this.nodeRows.get(this.key(node));
+      const row = node === null ? void 0 : this.nodeRows.get(node);
       if (row === void 0) {
         if (node === null || !this.rootNodes.has(node)) {
           this.dangle("layout entry");
         }
         continue;
       }
+      if (value.z !== void 0 && 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(
@@ -1588,6 +2866,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;
@@ -1609,13 +2888,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 === void 0 || value.s === null || value.t === void 0 || value.t === null) {
@@ -1631,8 +2911,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;
@@ -1662,7 +2942,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 });
         report.counts.skippedEdges++;
@@ -1704,34 +2984,76 @@ 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 = /* @__PURE__ */ new Map();
     if (weightFrom === null) {
-      return void 0;
+      return /* @__PURE__ */ new Map();
     }
-    if (this.weights === null) {
-      this.weights = /* @__PURE__ */ 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 !== void 0 && 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 === void 0 || 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 ? void 0 : chosen.get(po);
+    if (po === null || previous !== void 0 && 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 void 0;
     }
     const raw = this.weights.get(id);
     if (typeof raw === "string" && isNullText(raw)) {
@@ -1745,17 +3067,38 @@ 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 === void 0) {
+          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 === void 0 || chosen.v === null || name === "") {
+      if (chosen?.v === void 0 || chosen.v === null) {
         continue;
       }
       const type = cxType(chosen.d);
@@ -1830,7 +3173,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 ? void 0 : rows.get(this.key(target));
+          const row = target === null ? void 0 : rows.get(target);
           if (row === void 0) {
             if (target === null || !(domain === "node" ? this.rootNodes : this.rootEdges).has(target)) {
               this.dangle(`${domain} visual property entry`);
@@ -1863,7 +3206,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
         );
@@ -1888,15 +3231,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" }
       );
     }
@@ -1924,7 +3267,7 @@ class CxReader {
         continue;
       }
       const po = refId(value.po);
-      const row = po === null ? void 0 : this.nodeRows.get(this.key(po));
+      const row = po === null ? void 0 : this.nodeRows.get(po);
       if (row === void 0) {
         if (po === null || !this.rootNodes.has(po)) {
           this.dangle("functionTerms entry");
@@ -1942,8 +3285,8 @@ class CxReader {
       }
       const node = refId(value.node);
       const edge = refId(value.edge);
-      const row = node === null ? void 0 : this.nodeRows.get(this.key(node));
-      const edgeRow = edge === null ? void 0 : this.edgeRows.get(this.key(edge));
+      const row = node === null ? void 0 : this.nodeRows.get(node);
+      const edgeRow = edge === null ? void 0 : this.edgeRows.get(edge);
       if (row === void 0 || edgeRow === void 0) {
         if (node === null || !this.rootNodes.has(node) || edge === null || !this.rootEdges.has(edge)) {
           this.dangle("reifiedEdges entry");
@@ -1981,16 +3324,35 @@ class CxReader {
       return;
     }
     const fields = [...new Set(records.flatMap((r) => Object.keys(r)).filter((k) => k !== "@id"))];
+    const names = /* @__PURE__ */ 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] === void 0 ? null : plainJson(record[field]))
+        ...fields.map((field) => record[field] === void 0 ? null : plainJson(record[field], precision))
       ]);
     }
   }
@@ -2012,7 +3374,7 @@ class CxReader {
       const ids = (Array.isArray(value[column]) ? value[column] : []).map(refId).filter((id) => id !== null).map(Number);
       for (const raw of targets) {
         const target = refId(raw);
-        const row = target === null ? void 0 : rows.get(this.key(target));
+        const row = target === null ? void 0 : rows.get(target);
         if (row === void 0) {
           if (target === null || !root.has(target)) {
             this.dangle(`${aspectName} entry`);
@@ -2071,12 +3433,24 @@ 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");
@@ -2098,7 +3472,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) => {
@@ -2113,6 +3487,7 @@ async function run(input, options, sinkFor, pick) {
 }
 const cxImporter = Object.freeze({
   format: CX_FORMAT,
+  options: Object.freeze(["zAs"]),
   extensions: Object.freeze([".cx"]),
   mimeTypes: Object.freeze(["application/json"]),
   /**
@@ -2123,8 +3498,7 @@ 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;
     }
@@ -2152,11 +3526,11 @@ const cxImporter = 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];
@@ -2187,18 +3561,21 @@ 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({
-        index: plan.index,
-        name: plan.name,
-        nodes: memberCount(plan.nodes, nodes),
-        edges: memberCount(plan.edges, edges)
+    return graphPlans(doc, report).map(
+      (plan2) => Object.freeze({
+        index: plan2.index,
+        name: plan2.name,
+        nodes: memberCount(plan2.nodes, nodes),
+        edges: memberCount(plan2.edges, edges)
       })
     );
   }
 });
 export {
-  CX_ISSUE as C,
-  cxImporter as c
+  CX_CAPABILITIES as C,
+  CX_ISSUE as a,
+  CX_LOSS as b,
+  cxExporter as c,
+  cxImporter as d
 };
-//# sourceMappingURL=importer-DET1tg6s.js.map
+//# sourceMappingURL=importer-DCjOvO7U.js.map