@graphty/graph-io 0.3.24 → 0.3.26

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

@@ -27,8 +27,8 @@
  */
 import { GraphFormatError, INVALID_INDEX, MAX_COUNT, } from "@graphty/graph-format";
 import { declareAttribute, declareCompanion, declareResolved, losesPrecision, parseDeclaredTemporal, parseDeclaredValue, PRECISION_CODE, } from "../../common/attributes.js";
-import { COUNT_HINT_CODE, DUPLICATE_ATTRIBUTE_CODE, DUPLICATE_EDGE_ID_CODE, DUPLICATE_NODE_CODE, ID_MERGED_CODE, MISSING_ENDPOINT_CODE, MISSING_ID_CODE, NO_GRAPH_CODE, STRAY_TEXT_CODE, UNKNOWN_ELEMENT_CODE, UNKNOWN_PARENT_CODE, XML_SYNTAX_CODE, } from "../../common/codes.js";
-import { parseDecimalText } from "../../common/declared-types.js";
+import { BAD_VALUE_CODE, COUNT_HINT_CODE, COUNT_MISMATCH_CODE, DUPLICATE_ATTRIBUTE_CODE, DUPLICATE_EDGE_ID_CODE, DUPLICATE_NODE_CODE, EMPTY_INPUT_CODE, ID_MERGED_CODE, MISSING_ENDPOINT_CODE, MISSING_ID_CODE, MULTIPLE_GRAPHS_CODE, NO_GRAPH_CODE, PARENT_CYCLE_CODE, STRAY_TEXT_CODE, UNKNOWN_ELEMENT_CODE, UNKNOWN_PARENT_CODE, UNKNOWN_XML_ATTRIBUTE_CODE, XML_SYNTAX_CODE, } from "../../common/codes.js";
+import { overflowsToInfinity, parseDecimalText } from "../../common/declared-types.js";
 import { DirectionResolver } from "../../common/direction.js";
 import { IdCoercer } from "../../common/ids.js";
 import { textChunks, throwIfAborted } from "../../common/input.js";
@@ -37,44 +37,169 @@ import { reportSinkOptions, reportUnusedOptions, resolveImportOptions, } from ".
 import { ImportReportBuilder } from "../../common/report.js";
 import { parseTimeText, timeTextCompanion } from "../../common/temporal.js";
 import { isWeightField, parseWeightText } from "../../common/weights.js";
-import { isWhitespace, localName, tokenizeXml, xmlDeclaredEncoding, XmlSyntaxError, } from "../../common/xml.js";
+import { isWhitespace, localName, sniffXmlText, tokenizeXml, xmlDeclaredEncoding, XmlEmptyInputError, XmlSyntaxError, } from "../../common/xml.js";
 import { EDGE_DECLS, GEXF_FORMAT, GRAPH_MODES, NODE_DECLS, OPEN_END, OPEN_START, RESERVED_EDGE_NAMES, RESERVED_NODE_NAMES, temporalTableDecls, temporalTableName, TIME_FORMATS, TIME_REPRESENTATIONS, } from "./schema.js";
-/** Issue code: the document is not a GEXF document (no `<gexf>` root). */
+/**
+ * The document is not a GEXF document (no `<gexf>` root).
+ * @category Issue and loss codes
+ */
 export const NOT_GEXF_CODE = "E_NOT_GEXF";
-/** Issue code: the graph declares edges but no `<nodes>` section. */
+/**
+ * The graph declares edges but no `<nodes>` section.
+ * @category Issue and loss codes
+ */
 export const MISSING_NODES_CODE = "E_GEXF_MISSING_NODES";
-/** Issue code: an edge `type` outside directed / undirected / mutual. */
+/**
+ * An edge `type` outside directed / undirected / mutual.
+ * @category Issue and loss codes
+ */
 export const EDGE_TYPE_CODE = "E_GEXF_EDGE_TYPE";
-/** Issue code: an `<attributes>` group without a class, or with an unknown one. */
+/**
+ * An `<attributes>` group without a class, or with an unknown one.
+ * @category Issue and loss codes
+ */
 export const ATTRIBUTES_CLASS_CODE = "E_GEXF_ATTRIBUTES_CLASS";
-/** Issue code: an `<attribute>` without an id. */
+/**
+ * An `<attribute>` without an id.
+ * @category Issue and loss codes
+ */
 export const ATTRIBUTE_ID_CODE = "E_GEXF_ATTRIBUTE_ID";
-/** Issue code: a graph header value (`defaultedgetype`, `mode`, `timeformat`, ...) outside its set. */
+/**
+ * A graph header value (`defaultedgetype`, `mode`, `timeformat`, ...) outside its set.
+ * @category Issue and loss codes
+ */
 export const HEADER_VALUE_CODE = "W_GEXF_HEADER_VALUE";
-/** Issue code: an `<attribute>` without a type (read as string). */
+/**
+ * An `<attribute>` without a type (read as string).
+ * @category Issue and loss codes
+ */
 export const ATTRIBUTE_TYPE_CODE = "W_GEXF_ATTRIBUTE_TYPE";
-/** Issue code: an `<attvalue>` naming an attribute the document never declares (once per id). */
+/**
+ * An `<attvalue>` naming an attribute the document never declares (once per id).
+ * @category Issue and loss codes
+ */
 export const UNKNOWN_ATTRIBUTE_CODE = "W_GEXF_UNKNOWN_ATTRIBUTE";
-/** Issue code: an `<attvalue>` without a `for` or a `value`. */
+/**
+ * An `<attvalue>` without a `for` or a `value`.
+ * @category Issue and loss codes
+ */
 export const ATTVALUE_SHAPE_CODE = "W_GEXF_ATTVALUE_SHAPE";
-/** Issue code: a timed value on an attribute declared in a static group (stored as dynamic anyway). */
+/**
+ * A timed value on an attribute declared in a static group (stored as dynamic anyway).
+ * @category Issue and loss codes
+ */
 export const TIMED_STATIC_CODE = "W_GEXF_TIMED_VALUE_ON_STATIC";
-/** Issue code: the `weight` XML attribute is present but `weightFrom` is null. */
+/**
+ * The `weight` XML attribute is present but `weightFrom` is null.
+ * @category Issue and loss codes
+ */
 export const WEIGHT_IGNORED_CODE = "W_GEXF_WEIGHT_IGNORED";
-/** Issue code: viz elements skipped under `viz: false`. */
+/**
+ * Viz elements skipped under `viz: false`.
+ * @category Issue and loss codes
+ */
 export const VIZ_SKIPPED_CODE = "W_GEXF_VIZ_SKIPPED";
-/** Issue code: a 1.2 dynamic viz element (its bounds are dropped, the value kept). */
+/**
+ * A 1.2 dynamic viz element (its bounds are dropped, the value kept).
+ * @category Issue and loss codes
+ */
 export const VIZ_DYNAMIC_CODE = "W_GEXF_VIZ_DYNAMIC_DROPPED";
 /**
- * Issue code: `startopen` / `endopen` on a `<spell>` stored closed. No longer recorded: the open
- * bits of each spell are kept in the spells.open column. Kept so the exported code table is stable.
+ * `startopen` / `endopen` on a `<spell>` stored closed. No longer recorded: the open bits of each spell are kept in
+ * the spells.open column. Kept so the exported code table is stable.
+ * @category Issue and loss codes
  */
 export const SPELL_OPEN_CODE = "W_GEXF_SPELL_OPEN_DROPPED";
-/** Issue code: a viz element with a value that does not parse (the element is skipped). */
+/**
+ * A viz element with a value that does not parse (the element is skipped).
+ * @category Issue and loss codes
+ */
 export const VIZ_VALUE_CODE = "W_GEXF_VIZ_VALUE";
-/** Issue code: both `start` and `startopen` (or `end` and `endopen`) on one element; the closed bound wins. */
+/**
+ * Both `start` and `startopen` (or `end` and `endopen`) on one element; the closed bound wins.
+ * @category Issue and loss codes
+ */
 export const OPEN_BOUND_CONFLICT_CODE = "W_GEXF_OPEN_BOUND_CONFLICT";
+/**
+ * Both `timestamp` and `start` / `end` on one element or value; `start` / `end` win.
+ * @category Issue and loss codes
+ */
+export const TIMESTAMP_CONFLICT_CODE = "W_GEXF_TIMESTAMP_CONFLICT";
+/**
+ * A value outside the `<options>` its attribute declares (the value is kept).
+ * @category Issue and loss codes
+ */
+export const VALUE_OUTSIDE_OPTIONS_CODE = "W_GEXF_VALUE_OUTSIDE_OPTIONS";
 export { DUPLICATE_NODE_CODE, ID_MERGED_CODE, MISSING_ENDPOINT_CODE, MISSING_ID_CODE, NO_GRAPH_CODE, UNKNOWN_PARENT_CODE, };
+/** The GEXF versions graph-io knows, and the version a namespace implies when `version` is missing. */
+const VERSIONS = new Set(["1.0", "1.1", "1.2", "1.3"]);
+/**
+ * The version a GEXF namespace names (`http://www.gexf.net/1.2draft`, `http://gexf.net/1.3`).
+ * @param ns - the root's namespace
+ * @returns the version, or null
+ */
+function namespaceVersion(ns) {
+    const match = ns === null ? null : /gexf\.net\/(1\.[0-3])/.exec(ns);
+    return match === null ? null : match[1];
+}
+/**
+ * Whether a namespace is a GEXF viz namespace (`http://www.gexf.net/1.2draft/viz`, the 1.1
+ * triple-slash `http://gexf.net/1.1draft///viz`, `http://gexf.net/1.3/viz`, GEXF 1.0's `http://www.gephi.org/gexf/viz`).
+ * @param ns - the element's namespace
+ * @returns true for a viz namespace
+ */
+function isVizNamespace(ns) {
+    return ns !== null && /(gexf\.net\/.*viz|gephi\.org\/gexf\/viz)\/?$/.test(ns);
+}
+/** Distinct unknown attribute names reported one by one per element kind; the rest are counted in one issue. */
+const MAX_UNKNOWN_ATTRIBUTE_NAMES = 16;
+/** The XML attributes the importer reads on each element other than `<node>` / `<edge>`. */
+const ELEMENT_ATTRIBUTES = {
+    gexf: new Set(["version", "variant"]),
+    meta: new Set(["lastmodifieddate"]),
+    graph: new Set([
+        "defaultedgetype",
+        "mode",
+        "type",
+        "timeformat",
+        "timerepresentation",
+        "idtype",
+        "start",
+        "end",
+        "timestamp",
+        "startopen",
+        "endopen",
+    ]),
+    // `type` is GEXF 1.0's name for `mode` (static | dynamic)
+    attributes: new Set(["class", "mode", "type", "start", "end", "startopen", "endopen"]),
+    attribute: new Set(["id", "title", "type"]),
+    attvalue: new Set(["for", "value", "start", "end", "timestamp", "startopen", "endopen", "id"]),
+    spell: new Set(["start", "end", "timestamp", "startopen", "endopen"]),
+    parent: new Set(["for"]),
+    nodes: new Set(["count"]),
+    edges: new Set(["count"]),
+};
+/** A `count` hint as written: decimal digits only (as GraphML's parse.nodes). */
+const COUNT_TEXT = /^\d+$/;
+/** An xs:date / xs:dateTime text (`lastmodifieddate`). */
+const DATE_TEXT = /^-?\d{4,}-\d{2}-\d{2}(.*)$/s;
+/** The time of an xs:dateTime, after its date. */
+const TIME_TEXT = /^T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?/;
+/** The zone that may end an xs:date or xs:dateTime. */
+const ZONE_TEXT = /^(?:Z|[+-]\d{2}:\d{2})?$/;
+/**
+ * Whether a text is an xs:date or xs:dateTime.
+ * @param text - the text
+ * @returns true when it is
+ */
+function isDateText(text) {
+    const m = DATE_TEXT.exec(text);
+    if (m === null) {
+        return false;
+    }
+    const time = TIME_TEXT.exec(m[1])?.[0] ?? "";
+    return ZONE_TEXT.test(m[1].slice(time.length));
+}
 const EDGE_TYPES = new Set(["directed", "undirected", "mutual"]);
 /**
  * An edge type as a keyword of {@link EDGE_TYPES}: the schema spells them in lower case, but files
@@ -274,7 +399,15 @@ class GexfReader {
             index: INVALID_INDEX,
             mirror: INVALID_INDEX,
             where: { line: 0, element: null },
+            xmlWeight: null,
         };
+        /** The `for` ids of the static values of the open `<attvalues>`, for the duplicate check. */
+        this.attvalueIds = new Set();
+        /** The open `<nodes>` / `<edges>` sections: their count hint and the elements read directly in them. */
+        this.sections = [];
+        /** Unknown attribute names reported per element kind, and how many more were not listed. */
+        this.unknownNames = new Map();
+        this.unknownOverflow = new Map();
         /** The one `<attvalue>` location, reused per value (its fields are copied into every issue). */
         this.valueWhere = { line: 0, element: null };
         this.attributeGroup = null;
@@ -321,15 +454,26 @@ class GexfReader {
         };
     }
     // ---------------------------------------------------------------- events
-    start(name, attrs, line) {
+    start(name, attrs, line, ns = "") {
         const parent = this.ctx.length === 0 ? null : this.ctx[this.ctx.length - 1];
         const local = localName(name);
+        if (ns === null &&
+            parent !== null &&
+            parent !== Ctx.Skip &&
+            parent !== Ctx.MetaText &&
+            parent !== Ctx.AttributeText &&
+            !name.startsWith("viz:")) {
+            // an undeclared prefix or a name that is not namespace-well-formed (<:node>, <a:b:node>)
+            this.unknownElement(name, line);
+            return;
+        }
         switch (parent) {
             case null:
                 if (local !== "gexf") {
                     this.report.fail(NOT_GEXF_CODE, `the root element is <${name}>, not <gexf>`, { line });
                 }
-                this.readRoot(attrs);
+                this.checkAttributes("gexf", attrs, line);
+                this.readRoot(attrs, ns, line);
                 this.ctx.push(Ctx.Gexf);
                 return;
             case Ctx.Gexf:
@@ -351,7 +495,7 @@ class GexfReader {
                 this.startInNodes(name, local, attrs, line);
                 return;
             case Ctx.Node:
-                this.startInNode(name, local, attrs, line);
+                this.startInNode(name, local, attrs, line, ns);
                 return;
             case Ctx.Attvalues:
                 this.startInAttvalues(name, local, attrs, line);
@@ -366,7 +510,7 @@ class GexfReader {
                 this.startInEdges(name, local, attrs, line);
                 return;
             case Ctx.Edge:
-                this.startInEdge(name, local, attrs, line);
+                this.startInEdge(name, local, attrs, line, ns);
                 return;
             case Ctx.MetaText:
             case Ctx.AttributeText:
@@ -406,6 +550,10 @@ class GexfReader {
             case Ctx.Node:
                 this.nodeStack.pop();
                 return;
+            case Ctx.Nodes:
+            case Ctx.Edges:
+                this.finishSection();
+                return;
             case Ctx.Edge:
                 this.edge = null;
                 return;
@@ -416,8 +564,6 @@ class GexfReader {
                 this.finishSpells();
                 return;
             case Ctx.Gexf:
-            case Ctx.Nodes:
-            case Ctx.Edges:
             case Ctx.Attvalues:
             case Ctx.Skip:
             case undefined:
@@ -458,16 +604,30 @@ class GexfReader {
         if (!this.graphSeen) {
             this.report.fail(NO_GRAPH_CODE, "the document has no <graph> element");
         }
+        for (const [kind, more] of this.unknownOverflow) {
+            this.report.warning("unsupported", UNKNOWN_XML_ATTRIBUTE_CODE, `${more} more distinct attribute names on <${kind}> are not GEXF attributes and are not kept (not listed one by one)`, { element: kind });
+        }
     }
     // ---------------------------------------------------------------- root, meta, graph
     /**
-     * Record the root's version.
+     * Record the root's version: as written when known; the namespace's when absent; an unknown
+     * one is kept as written and reported.
      * @param attrs - the `<gexf>` attributes
+     * @param ns - the root's namespace
+     * @param line - the line
      */
-    readRoot(attrs) {
+    readRoot(attrs, ns, line) {
         const version = attrs.get("version");
         if (version !== undefined && version.length > 0) {
             this.meta.sourceVersion = version;
+            if (!VERSIONS.has(version)) {
+                this.report.warning("validation-error", HEADER_VALUE_CODE, `<gexf version="${version}"> is not a GEXF version graph-io knows (1.0 to 1.3); read as GEXF 1.3`, { line, element: "version" });
+            }
+            return;
+        }
+        const implied = namespaceVersion(ns);
+        if (implied !== null) {
+            this.meta.sourceVersion = implied;
         }
     }
     /**
@@ -480,21 +640,27 @@ class GexfReader {
     startInGexf(name, local, attrs, line) {
         switch (local) {
             case "meta": {
+                this.checkAttributes("meta", attrs, line);
                 const modified = attrs.get("lastmodifieddate");
                 if (modified !== undefined && modified.length > 0) {
                     this.meta.modified = modified;
+                    if (!isDateText(modified.trim())) {
+                        this.report.warning("validation-error", HEADER_VALUE_CODE, `<meta lastmodifieddate="${modified}"> is not an xs:date; kept as written`, { line, element: "lastmodifieddate" });
+                    }
                 }
                 this.ctx.push(Ctx.Meta);
                 return;
             }
             case "graph":
+                this.checkAttributes("graph", attrs, line);
                 if (this.graphSeen) {
-                    this.report.fail(NO_GRAPH_CODE, "a second <graph> element; a GEXF document has one graph", {
-                        line,
-                    });
+                    // the schema allows one graph; merging is what the GraphML importer does too
+                    this.report.warnOnce("unsupported", MULTIPLE_GRAPHS_CODE, "a second <graph> element; its nodes and edges are merged into the first and its header is ignored", { line });
+                }
+                else {
+                    this.graphSeen = true;
+                    this.readHeader(attrs, line);
                 }
-                this.graphSeen = true;
-                this.readHeader(attrs, line);
                 this.ctx.push(Ctx.Graph);
                 return;
             default:
@@ -538,9 +704,11 @@ class GexfReader {
         this.metaField = null;
         this.metaText = "";
     }
-    /** Close `<meta>`: nothing more to do (the patch is applied at `<graph>`). */
+    /** Close `<meta>`: the patch is applied with the graph header, or now when `<meta>` follows the graph. */
     finishMeta() {
-        // the meta patch is applied when the graph header is read
+        if (this.graphSeen) {
+            this.sink.setMeta(this.meta);
+        }
     }
     /**
      * Read `<graph defaultedgetype mode timeformat timerepresentation idtype start end timestamp>`
@@ -594,7 +762,7 @@ class GexfReader {
         const idType = attrs.get("idtype");
         if (idType !== undefined) {
             if (idType === "string") {
-                // informational only: Gephi writes idtype="string" unconditionally, so honouring it
+                // informational only: Gephi writes idtype="string" unconditionally, so honoring it
                 // would turn every Gephi export's integer ids into text; the canonical rule of
                 // design section 4.1 applies and the exporter's check() reports W_ID_TEXT_TYPE
                 patch.idType = "string";
@@ -642,39 +810,59 @@ class GexfReader {
                 return;
             case "nodes":
                 this.nodesSeen = true;
-                this.reserve(attrs, "node", line);
-                this.ctx.push(Ctx.Nodes);
+                this.beginSection(attrs, "node", line);
                 return;
             case "edges":
                 if (!this.nodesSeen) {
                     this.report.error("validation-error", MISSING_NODES_CODE, "the graph declares <edges> but no <nodes>", { line });
                 }
                 this.resolveParents();
-                this.reserve(attrs, "edge", line);
-                this.ctx.push(Ctx.Edges);
+                this.beginSection(attrs, "edge", line);
                 return;
             default:
                 this.unknownElement(name, line);
         }
     }
+    /**
+     * Open a `<nodes>` / `<edges>` section: its count hint is reserved and later compared with the
+     * elements the section holds.
+     * @param attrs - the section's attributes
+     * @param domain - node or edge
+     * @param line - the line
+     */
+    beginSection(attrs, domain, line) {
+        this.checkAttributes(`${domain}s`, attrs, line);
+        this.sections.push({ domain, hint: this.reserve(attrs, domain, line), seen: 0, line });
+        this.ctx.push(domain === "node" ? Ctx.Nodes : Ctx.Edges);
+    }
+    /** Close a `<nodes>` / `<edges>` section: a count hint that disagrees is reported. */
+    finishSection() {
+        const section = this.sections.pop();
+        if (section?.hint === undefined || section.hint === null || section.hint === section.seen) {
+            return;
+        }
+        this.report.warning("validation-error", COUNT_MISMATCH_CODE, `<${section.domain}s count="${section.hint}"> but the section holds ${section.seen} <${section.domain}> elements (nested ones included)`, { line: section.line, element: "count" });
+    }
     /**
      * Pass a section's `count` hint to the sink; a hint the sink cannot reserve is a warning.
      * @param attrs - the `<nodes>` or `<edges>` attributes
      * @param domain - which count it is
      * @param line - the line
+     * @returns the hint, or null when absent or ignored
      */
     reserve(attrs, domain, line) {
         const text = attrs.get("count");
         if (text === undefined) {
-            return;
+            return null;
         }
-        const count = Number(text);
-        if (!Number.isInteger(count) || count < 0 || count > MAX_COUNT) {
+        // decimal digits only: Number() would read "" as 0, "0x10" as 16 and "1e3" as 1000
+        const count = COUNT_TEXT.test(text) ? Number(text) : Number.NaN;
+        if (!Number.isSafeInteger(count) || count > MAX_COUNT) {
             this.report.warning("validation-error", COUNT_HINT_CODE, `<${domain}s count="${text}"> is not a count the sink can reserve; ignored`, { line, element: "count" });
-            return;
+            return null;
         }
         if (count === 0) {
-            return;
+            return count;
         }
         try {
             if (domain === "node") {
@@ -693,6 +881,7 @@ class GexfReader {
                 element: "count",
             });
         }
+        return count;
     }
     // ---------------------------------------------------------------- attribute declarations
     /**
@@ -701,6 +890,7 @@ class GexfReader {
      * @param line - the line
      */
     beginAttributes(attrs, line) {
+        this.checkAttributes("attributes", attrs, line);
         const cls = attrs.get("class");
         const where = { line };
         let domain = null;
@@ -712,7 +902,7 @@ class GexfReader {
                 ? "<attributes> without a class"
                 : `<attributes class="${cls}"> is neither node nor edge`, where);
         }
-        const mode = attrs.get("mode");
+        const mode = attrs.get("mode") ?? attrs.get("type");
         if (mode !== undefined && mode !== "static" && mode !== "dynamic") {
             this.warnHeader("mode", mode, where);
         }
@@ -731,6 +921,7 @@ class GexfReader {
             this.unknownElement(name, line);
             return;
         }
+        this.checkAttributes("attribute", attrs, line);
         const group = this.attributeGroup;
         if (group === null || group.domain === null) {
             // the group's class was refused; its attributes are dropped with it
@@ -810,13 +1001,20 @@ class GexfReader {
             report.warning("validation-error", DUPLICATE_ATTRIBUTE_CODE, `${domain} attribute "${id}" is declared twice; the first declaration is kept`, where);
             return;
         }
+        if (this.unknownAttributes.has(`${domain}:${id}`)) {
+            report.warning("missing-value", UNKNOWN_ATTRIBUTE_CODE, `${domain} attribute "${id}" is declared after values that use it; those values were dropped (declare <attributes> before <nodes>)`, where);
+        }
         const title = attrs.get("title") ?? null;
         const type = attrs.get("type") ?? null;
         if (type === null) {
             report.warning("validation-error", ATTRIBUTE_TYPE_CODE, `attribute "${id}" declares no type; read as string`, where);
         }
         const name = title !== null && title.length > 0 ? title : id;
-        if (domain === "edge" && isWeightField(name, options.weightFrom)) {
+        if (domain === "edge" && this.weightAttr !== null && isWeightField(name, options.weightFrom)) {
+            // the first attribute of that title stays THE weight; this one becomes a plain column
+            report.warning("validation-error", DUPLICATE_ATTRIBUTE_CODE, `edge attribute "${id}" is also titled ${name}; attribute "${this.weightAttr.id}" is the weight, "${id}" is kept as a column`, where);
+        }
+        else if (domain === "edge" && isWeightField(name, options.weightFrom)) {
             const declared = declareAttribute({ format: GEXF_FORMAT, id, title, type, long: options.long });
             for (const issue of declared.issues) {
                 report.warning(issue.category, issue.code, issue.message, where);
@@ -827,7 +1025,8 @@ class GexfReader {
         }
         const declaredNames = domain === "node" ? this.declaredNodeNames : this.declaredEdgeNames;
         const reserved = domain === "node" ? RESERVED_NODE_NAMES : RESERVED_EDGE_NAMES;
-        const taken = (candidate) => reserved.has(candidate) || declaredNames.has(candidate);
+        const weightName = domain === "edge" && this.weightAttr !== null ? options.weightFrom : null;
+        const taken = (candidate) => reserved.has(candidate) || declaredNames.has(candidate) || candidate === weightName;
         const input = {
             format: GEXF_FORMAT,
             id,
@@ -900,7 +1099,9 @@ class GexfReader {
         const enclosing = this.nodeStack.length === 0 ? INVALID_INDEX : this.nodeStack[this.nodeStack.length - 1].index;
         const idText = attrs.get("id");
         const where = { line, element: idText ?? attrs.get("label") ?? null };
+        this.countInSection("node");
         this.checkAttributeNames(attrs, NODE_ATTRIBUTES, "node", where);
+        // GEXF types ids as xs:string: id="" is a legal id (the exporter writes it), only a missing one is not
         if (idText === undefined) {
             report.error("missing-value", MISSING_ID_CODE, "<node> without an id", where);
             report.counts.skippedNodes++;
@@ -908,6 +1109,9 @@ class GexfReader {
             this.ctx.push(Ctx.Node);
             return;
         }
+        if (this.meta.idType === "integer" && !/^\s*[+-]?\d+\s*$/.test(idText)) {
+            report.warnOnce("validation-error", HEADER_VALUE_CODE, `node id "${idText}" is not an integer although the graph declares idtype="integer"; ids follow the ids option`, where, `${HEADER_VALUE_CODE}:idtype`);
+        }
         let index;
         try {
             const id = this.coerceId(idText, where);
@@ -930,11 +1134,17 @@ class GexfReader {
         }
         this.nodeStack.push({ index, where });
         this.ctx.push(Ctx.Node);
+        // three independent parts: a bad pid must not cost the label or the lifetime
         try {
             const label = attrs.get("label");
             if (label !== undefined) {
                 this.nodeColumns.label.set(sink, report, index, label, where);
             }
+        }
+        catch (err) {
+            report.recordError(err, where);
+        }
+        try {
             const pid = attrs.get("pid");
             if (pid !== undefined) {
                 this.parentRefs.push({
@@ -947,28 +1157,50 @@ class GexfReader {
             else if (enclosing !== INVALID_INDEX) {
                 this.parentRefs.push({ child: index, parentId: null, parentIndex: enclosing, where });
             }
+        }
+        catch (err) {
+            report.recordError(err, where);
+        }
+        try {
             this.writeLifetime(attrs, index, this.nodeColumns, where);
         }
         catch (err) {
             report.recordError(err, where);
         }
     }
+    /**
+     * Count a `<node>` / `<edge>` element in the open sections of its kind, for the count hint
+     * check: a `<nodes count>` counts the nodes nested in its nodes too.
+     * @param domain - node or edge
+     */
+    countInSection(domain) {
+        for (const section of this.sections) {
+            if (section.domain === domain) {
+                section.seen++;
+            }
+        }
+    }
     /**
      * A child of `<node>`.
      * @param name - the element name
      * @param local - its local name
      * @param attrs - its attributes
      * @param line - the line
+     * @param ns - the element's namespace
      */
-    startInNode(name, local, attrs, line) {
+    startInNode(name, local, attrs, line, ns) {
         const frame = this.nodeStack[this.nodeStack.length - 1];
         if (frame.index === INVALID_INDEX && local !== "nodes") {
             // the node was skipped; its children are too
             this.ctx.push(Ctx.Skip);
             return;
         }
+        if (frame.index === INVALID_INDEX) {
+            this.report.error("missing-value", UNKNOWN_PARENT_CODE, "the nodes nested in this skipped <node> lose their parent; they are read as top-level nodes", { line });
+        }
         switch (local) {
             case "attvalues":
+                this.attvalueIds.clear();
                 this.ctx.push(Ctx.Attvalues);
                 return;
             case "parents":
@@ -982,13 +1214,16 @@ class GexfReader {
                 this.ctx.push(Ctx.Spells);
                 return;
             case "nodes":
-                this.reserve(attrs, "node", line);
-                this.ctx.push(Ctx.Nodes);
+                this.beginSection(attrs, "node", line);
                 return;
             case "color":
             case "position":
             case "size":
             case "shape":
+                if (!isViz(name, ns)) {
+                    this.unknownElement(name, line);
+                    return;
+                }
                 this.writeViz(name, local, attrs, "node", frame.index, frame.where);
                 this.ctx.push(Ctx.Skip);
                 return;
@@ -1009,10 +1244,11 @@ class GexfReader {
             return;
         }
         this.ctx.push(Ctx.Skip);
+        this.checkAttributes("parent", attrs, line);
         const frame = this.nodeStack[this.nodeStack.length - 1];
         const text = attrs.get("for");
         if (text === undefined) {
-            this.report.warning("missing-value", ATTVALUE_SHAPE_CODE, "<parent> without a for attribute", frame.where);
+            this.report.error("missing-value", UNKNOWN_PARENT_CODE, "<parent> without a for attribute names no parent", frame.where);
             return;
         }
         try {
@@ -1040,6 +1276,20 @@ class GexfReader {
         const lists = this.parentsRefs;
         this.parentRefs = [];
         this.parentsRefs = [];
+        // each node's parent so far, as the parent column holds it: a link closes a cycle when the
+        // child is the parent or one of its ancestors. A repeated link (a duplicate node declaring
+        // the same pid) is not a cycle, which an undirected union-find would wrongly report.
+        // ponytail: O(depth) per link, so O(n * depth); fine for real hierarchies, add path
+        // compression over an ancestry index if a deep chain ever shows up in a profile.
+        const parentOf = new Map();
+        const isAncestorOrSelf = (candidate, of) => {
+            for (let at = of; at !== undefined; at = parentOf.get(at)) {
+                if (at === candidate) {
+                    return true;
+                }
+            }
+            return false;
+        };
         for (const ref of refs) {
             let parent = ref.parentIndex;
             if (ref.parentId !== null) {
@@ -1049,8 +1299,16 @@ class GexfReader {
                     continue;
                 }
             }
+            if (parentOf.get(ref.child) === parent) {
+                continue;
+            }
+            if (isAncestorOrSelf(ref.child, parent)) {
+                report.error("validation-error", PARENT_CYCLE_CODE, `the parent link of node "${ref.where.element ?? "?"}" would close a parent cycle; it is dropped`, ref.where);
+                continue;
+            }
             try {
                 this.parentColumn.set(sink, report, ref.child, parent, ref.where);
+                parentOf.set(ref.child, parent);
             }
             catch (err) {
                 report.recordError(err, ref.where);
@@ -1105,7 +1363,9 @@ class GexfReader {
         const { where } = this.edgeFrame;
         where.line = line;
         where.element = idText ?? edgeElement(sourceText, targetText);
+        this.countInSection("edge");
         this.checkAttributeNames(attrs, EDGE_ATTRIBUTES, "edge", where);
+        // source="" names the node whose id is "" (legal in GEXF), so only a missing endpoint is E_MISSING_ENDPOINT
         if (sourceText === undefined || targetText === undefined) {
             report.error("missing-value", MISSING_ENDPOINT_CODE, `<edge> without a ${sourceText === undefined ? "source" : "target"}`, where);
             report.counts.skippedEdges++;
@@ -1122,13 +1382,10 @@ class GexfReader {
             }
             kind = type;
         }
-        if (idText !== undefined) {
-            if (this.edgeIds.has(idText)) {
-                report.error("validation-error", DUPLICATE_EDGE_ID_CODE, `edge id "${idText}" is declared more than once; the edge is skipped`, where);
-                report.counts.skippedEdges++;
-                return;
-            }
-            this.edgeIds.add(idText);
+        if (idText !== undefined && this.edgeIds.has(idText)) {
+            report.error("validation-error", DUPLICATE_EDGE_ID_CODE, `edge id "${idText}" is declared more than once; the edge is skipped`, where);
+            report.counts.skippedEdges++;
+            return;
         }
         let index;
         try {
@@ -1156,9 +1413,14 @@ class GexfReader {
             report.counts.skippedEdges++;
             return;
         }
+        // the id is claimed only by an edge that was added, so a rejected edge does not cost the next
+        if (idText !== undefined) {
+            this.edgeIds.add(idText);
+        }
         const frame = this.edgeFrame;
         frame.index = index;
         frame.mirror = this.resolver.lastMirror;
+        frame.xmlWeight = attrs.get("weight") ?? null;
         this.edge = frame;
         try {
             if (idText !== undefined) {
@@ -1194,7 +1456,21 @@ class GexfReader {
             this.report.warnOnce("coercion", WEIGHT_IGNORED_CODE, "the weight attribute is ignored because weightFrom is null; edges are unweighted", where);
             return undefined;
         }
-        return parseWeightText(text);
+        // a blank weight="" is an absent weight (common/weights.ts), as a blank weight attvalue is
+        const weight = parseWeightText(text, this.report);
+        this.checkOverflow(text, where);
+        return weight;
+    }
+    /**
+     * Report (once) a weight text too large for a double, stored as Infinity; `INF` itself is a
+     * legal weight (design section 3.7) and is not reported.
+     * @param text - the weight text
+     * @param where - the location
+     */
+    checkOverflow(text, where) {
+        if (overflowsToInfinity(text)) {
+            this.report.warnOnce("precision", PRECISION_CODE, `weight ${text.trim()} is beyond the double range and is stored as Infinity`, where, `${PRECISION_CODE}:weight`);
+        }
     }
     /**
      * A child of `<edge>`.
@@ -1202,8 +1478,9 @@ class GexfReader {
      * @param local - its local name
      * @param attrs - its attributes
      * @param line - the line
+     * @param ns - the element's namespace
      */
-    startInEdge(name, local, attrs, line) {
+    startInEdge(name, local, attrs, line, ns) {
         const { edge } = this;
         if (edge === null) {
             this.ctx.push(Ctx.Skip);
@@ -1211,6 +1488,7 @@ class GexfReader {
         }
         switch (local) {
             case "attvalues":
+                this.attvalueIds.clear();
                 this.ctx.push(Ctx.Attvalues);
                 return;
             case "spells":
@@ -1222,6 +1500,10 @@ class GexfReader {
             case "color":
             case "thickness":
             case "shape":
+                if (!isViz(name, ns)) {
+                    this.unknownElement(name, line);
+                    return;
+                }
                 this.writeViz(name, local, attrs, "edge", edge.index, edge.where);
                 this.ctx.push(Ctx.Skip);
                 return;
@@ -1244,6 +1526,7 @@ class GexfReader {
             return;
         }
         this.ctx.push(Ctx.Skip);
+        this.checkAttributes("attvalue", attrs, line);
         const { report, edge } = this;
         const domain = edge === null ? "node" : "edge";
         let index;
@@ -1273,6 +1556,12 @@ class GexfReader {
             report.warning("missing-value", ATTVALUE_SHAPE_CODE, `<attvalue for="${forId}"> without a value attribute`, valueWhere);
             return;
         }
+        if (!isTimed(attrs)) {
+            if (this.attvalueIds.has(forId)) {
+                report.warning("validation-error", DUPLICATE_ATTRIBUTE_CODE, `a second static <attvalue for="${forId}"> on one ${domain}; the later value "${value}" is kept`, { ...valueWhere, element: forId });
+            }
+            this.attvalueIds.add(forId);
+        }
         try {
             if (domain === "edge" && this.weightAttr !== null && this.weightAttr.id === forId) {
                 if (isTimed(attrs)) {
@@ -1315,12 +1604,14 @@ class GexfReader {
         if (edge === null) {
             return;
         }
-        const weight = parseWeightText(text);
+        const weight = parseWeightText(text, this.report);
         if (weight === undefined) {
-            throw new GraphFormatError("E_INVALID_WEIGHT", "an edge weight cannot be blank", {
-                value: text,
-                line: where.line ?? null,
-            });
+            // blank is absent (common/weights.ts), as a blank weight="" XML attribute is
+            return;
+        }
+        this.checkOverflow(text, where);
+        if (edge.xmlWeight !== null) {
+            this.report.warning("validation-error", DUPLICATE_ATTRIBUTE_CODE, `the edge has both weight="${edge.xmlWeight}" and a weight attvalue "${text}"; the attvalue is kept`, where);
         }
         sink.setEdgeWeight(edge.index, weight);
         if (edge.mirror !== INVALID_INDEX) {
@@ -1353,8 +1644,30 @@ class GexfReader {
         if (losesPrecision(spec, text)) {
             this.report.warning("precision", PRECISION_CODE, `long value ${text.trim()} of "${attribute.name}" exceeds 2^53 and was rounded`, where);
         }
+        else if (typeof value === "number" && overflowsToInfinity(text)) {
+            this.report.warnOnce("precision", PRECISION_CODE, `values of "${attribute.name}" beyond the double range (${text.trim()}) are stored as Infinity`, where, `${PRECISION_CODE}:overflow:${attribute.name}`);
+        }
+        this.checkOptions(attribute, value, where);
         this.setCell(domain, attribute.handle, index, value);
     }
+    /**
+     * Report (once per attribute) a value outside the `<options>` the attribute declares; the
+     * value is kept.
+     * @param attribute - the declaration
+     * @param value - the parsed value (a list checks each item)
+     * @param where - the value's location
+     */
+    checkOptions(attribute, value, where) {
+        const { options } = attribute.valueDecl;
+        if (options === undefined || options.length === 0) {
+            return;
+        }
+        const items = Array.isArray(value) ? value : [value];
+        const outside = items.find((item) => !options.includes(item));
+        if (typeof outside === "string" || typeof outside === "number" || typeof outside === "boolean") {
+            this.report.warnOnce("validation-error", VALUE_OUTSIDE_OPTIONS_CODE, `"${outside}" is not among the options of attribute "${attribute.name}"; the value is kept`, where, `${VALUE_OUTSIDE_OPTIONS_CODE}:${attribute.name}`);
+        }
+    }
     /**
      * Append a timed value to the attribute's temporal table (design section 5.10), creating the
      * table on first use.
@@ -1389,6 +1702,9 @@ class GexfReader {
             }
         }
         const row = this.temporalRow(attrs, index, value, where);
+        if (row === null) {
+            return;
+        }
         if (temporalValue) {
             row.push(valueText ?? undefined);
         }
@@ -1413,14 +1729,15 @@ class GexfReader {
                 origin: { format: GEXF_FORMAT, id: weightAttr.id, type: weightAttr.spec.declared },
             }, false));
         }
-        const value = parseWeightText(text);
+        const value = parseWeightText(text, this.report);
         if (value === undefined) {
-            throw new GraphFormatError("E_INVALID_WEIGHT", "a timed edge weight cannot be blank", {
-                value: text,
-                line: where.line ?? null,
-            });
+            // blank is absent (common/weights.ts): no timed value
+            return;
+        }
+        const row = this.temporalRow(attrs, index, value, where);
+        if (row !== null) {
+            sink.addExtensionRow(weightAttr.table, row);
         }
-        sink.addExtensionRow(weightAttr.table, this.temporalRow(attrs, index, value, where));
     }
     /**
      * The row of a temporal table for one timed value: element, bounds, value, bound texts, open bits.
@@ -1428,10 +1745,13 @@ class GexfReader {
      * @param index - the element's index
      * @param value - the parsed value
      * @param where - the value's location
-     * @returns the row, without the optional value text
+     * @returns the row, without the optional value text; null when the interval is inverted (recorded)
      */
     temporalRow(attrs, index, value, where) {
         const bounds = this.readBounds(attrs, where);
+        if (bounds === null) {
+            return null;
+        }
         return [
             index,
             bounds.start.value,
@@ -1448,7 +1768,7 @@ class GexfReader {
      * section 5.1); missing bounds are unbounded.
      * @param attrs - the attributes
      * @param where - the location, for the conflict warning
-     * @returns the bounds and the open bits
+     * @returns the bounds and the open bits; null (recorded as E_BAD_VALUE) when the interval is inverted
      */
     readBounds(attrs, where) {
         let start = { value: -Infinity, text: null };
@@ -1458,6 +1778,9 @@ class GexfReader {
         if (timestamp !== undefined) {
             start = parseTimeText(timestamp, this.timeFormat);
             end = start;
+            if (attrs.has("start") || attrs.has("end") || attrs.has("startopen") || attrs.has("endopen")) {
+                this.report.warnOnce("validation-error", TIMESTAMP_CONFLICT_CODE, "both timestamp and start / end are given; start / end set the interval and the timestamp is kept as written", where);
+            }
         }
         const startText = attrs.get("start");
         const startOpen = attrs.get("startopen");
@@ -1483,6 +1806,10 @@ class GexfReader {
             end = parseTimeText(endOpen, this.timeFormat);
             open |= OPEN_END;
         }
+        if (start.value > end.value) {
+            this.report.error("validation-error", BAD_VALUE_CODE, `the interval starts after it ends (${start.text ?? String(start.value)} > ${end.text ?? String(end.value)}); it is not kept`, where);
+            return null;
+        }
         return { start, end, open };
     }
     /**
@@ -1510,9 +1837,13 @@ class GexfReader {
             attrs.has("startopen") ||
             attrs.has("endopen")) {
             const bounds = this.readBounds(attrs, where);
+            if (bounds === null) {
+                return;
+            }
             const timestamp = attrs.get("timestamp");
             if (timestamp !== undefined) {
-                columns.timestamp.set(sink, report, index, bounds.start, where);
+                // parsed again: beside start / startopen, bounds.start is the start, not the timestamp
+                columns.timestamp.set(sink, report, index, parseTimeText(timestamp, this.timeFormat), where);
             }
             if (attrs.has("start") || attrs.has("startopen")) {
                 columns.start.set(sink, report, index, bounds.start, where);
@@ -1553,10 +1884,15 @@ class GexfReader {
                     line: where.line ?? null,
                 });
             }
-            pairs.push([
+            const pair = [
                 parseTimeText(items[0], this.timeFormat).value,
                 parseTimeText(items[1], this.timeFormat).value,
-            ]);
+            ];
+            if (pair[0] > pair[1]) {
+                this.report.error("validation-error", BAD_VALUE_CODE, `interval "${part.trim()}" starts after it ends; it is not kept`, where);
+                continue;
+            }
+            pairs.push(pair);
         }
         return pairs;
     }
@@ -1573,9 +1909,13 @@ class GexfReader {
             return;
         }
         this.ctx.push(Ctx.Skip);
+        this.checkAttributes("spell", attrs, line);
         const where = this.spellsWhere ?? { line };
         try {
             const bounds = this.readBounds(attrs, where);
+            if (bounds === null) {
+                return;
+            }
             this.spellPairs?.push([bounds.start.value, bounds.end.value]);
             this.spellOpen.push(bounds.open);
         }
@@ -1691,23 +2031,47 @@ class GexfReader {
         this.ctx.push(Ctx.Skip);
     }
     /**
-     * Report XML attributes the importer does not read (once per attribute name and domain).
+     * Report XML attributes the importer does not read (once per attribute name and element kind;
+     * beyond MAX_UNKNOWN_ATTRIBUTE_NAMES distinct names per kind the rest are counted and reported
+     * once at the end). Namespace declarations and `xml:` / `xsi:` attributes are not data.
      * @param attrs - the element's attributes
      * @param known - the attribute names read
-     * @param domain - node or edge
+     * @param kind - the element name
      * @param where - the element's location
      */
-    checkAttributeNames(attrs, known, domain, where) {
+    checkAttributeNames(attrs, known, kind, where) {
+        if (attrs.size === 0) {
+            return;
+        }
         for (const key of attrs.keys()) {
-            if (!known.has(key)) {
-                const seen = `${domain}@${key}`;
-                if (!this.unknownAttributes.has(seen)) {
-                    this.unknownAttributes.add(seen);
-                    this.report.warning("unsupported", UNKNOWN_ELEMENT_CODE, `attribute ${key} of <${domain}> is not GEXF and was ignored`, { ...where, element: key });
-                }
+            if (known.has(key) || key === "xmlns" || /^(xmlns|xml|xsi):/.test(key)) {
+                continue;
+            }
+            let names = this.unknownNames.get(kind);
+            if (names === undefined) {
+                names = new Set();
+                this.unknownNames.set(kind, names);
             }
+            if (names.has(key)) {
+                continue;
+            }
+            names.add(key);
+            if (names.size > MAX_UNKNOWN_ATTRIBUTE_NAMES) {
+                this.unknownOverflow.set(kind, (this.unknownOverflow.get(kind) ?? 0) + 1);
+                continue;
+            }
+            this.report.warning("unsupported", UNKNOWN_XML_ATTRIBUTE_CODE, `attribute ${key} of <${kind}> is not GEXF and was ignored`, { ...where, element: key });
         }
     }
+    /**
+     * Report the XML attributes the importer does not read on an element other than node / edge.
+     * @param kind - the element's local name (a key of ELEMENT_ATTRIBUTES)
+     * @param attrs - its attributes
+     * @param line - the line
+     */
+    checkAttributes(kind, attrs, line) {
+        this.checkAttributeNames(attrs, ELEMENT_ATTRIBUTES[kind] ?? new Set(), kind, { line });
+    }
     /**
      * Write one cell of a domain.
      * @param domain - node or edge
@@ -1745,6 +2109,16 @@ class GexfReader {
         }
     }
 }
+/**
+ * Whether a node / edge child named like a viz element is one: in a viz namespace, or written
+ * with the `viz:` prefix the document never declares (hand-written files often omit it).
+ * @param name - the element name as written
+ * @param ns - its namespace
+ * @returns true for a viz element
+ */
+function isViz(name, ns) {
+    return isVizNamespace(ns) || (ns === null && name.startsWith("viz:"));
+}
 /**
  * The element text of an edge without an id, for issues.
  * @param source - the source text, or undefined
@@ -1811,7 +2185,7 @@ function parseColor(attrs) {
     if (hex !== undefined && !attrs.has("r")) {
         const digits = hex.startsWith("#") ? hex.slice(1) : hex;
         if (!/^[0-9a-fA-F]{6}$/.test(digits)) {
-            throw new GraphFormatError("E_COLUMN_TYPE", `viz hex="${hex}" is not a #RRGGBB colour`, {
+            throw new GraphFormatError("E_COLUMN_TYPE", `viz hex="${hex}" is not a #RRGGBB color`, {
                 attribute: "hex",
             });
         }
@@ -1836,7 +2210,7 @@ const XML_START = /^\uFEFF?\s*</;
  *     not start with markup
  */
 function sniffGexf(head) {
-    const text = new TextDecoder("utf-8", { fatal: false }).decode(head);
+    const text = sniffXmlText(head);
     // Only a document that starts as markup: a JSON or CSV value may mention a `<gexf>` tag.
     if (!XML_START.test(text)) {
         return 0;
@@ -1864,9 +2238,13 @@ function resolveGexfOptions(options) {
     }
     return viz;
 }
-/** The GEXF importer (design section 8.4). */
+/**
+ * The GEXF importer.
+ * @category Built-in formats
+ */
 export const gexfImporter = Object.freeze({
     format: GEXF_FORMAT,
+    options: Object.freeze(["viz"]),
     extensions: Object.freeze([".gexf"]),
     mimeTypes: Object.freeze(["application/gexf+xml", "application/xml", "text/xml"]),
     sniff: sniffGexf,
@@ -1891,9 +2269,12 @@ export const gexfImporter = Object.freeze({
         reportUnusedOptions(options, report, USED_OPTIONS);
         const reader = new GexfReader(sink, report, resolved, viz);
         try {
-            await tokenizeXml(textChunks(input, report, { ...resolved, declaredEncoding: xmlDeclaredEncoding }), reader);
+            await tokenizeXml(textChunks(input, report, { ...resolved, declaredEncoding: xmlDeclaredEncoding, xml: true }), reader);
         }
         catch (err) {
+            if (err instanceof XmlEmptyInputError) {
+                report.fail(EMPTY_INPUT_CODE, "the input is empty (no markup at all)", { line: err.line });
+            }
             if (err instanceof XmlSyntaxError) {
                 report.fail(XML_SYNTAX_CODE, err.message, { line: err.line });
             }