@graphty/graph-io 0.3.28 → 0.3.30

package/src/common/export.ts

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

package/src/common/format.ts

@@ -30,17 +30,6 @@ export function formatF32(value: number): string {
     return String(value);
 }
 
-/**
- * Whether a number read from a file keeps its decimal value in an f32 column: the shortest decimal
- * of its f32 rounding reads back as the same number (0.2 does; 123456789.123 and 0.123456789 do not).
- * @param value - a finite number
- * @returns true when nothing a reader would see is lost
- * @category Plugin helpers
- */
-export function survivesF32(value: number): boolean {
-    return Number(formatF32(Math.fround(value))) === value;
-}
-
 /**
  * The shortest text of an f64 value: `String(x)`, which is already the shortest round-tripping
  * decimal in JS, except for negative zero, which `String()` writes as "0".

package/src/common/json-elements.ts

@@ -1655,7 +1655,7 @@ export const POSITION_COLUMN = "position";
 const Z_COLUMN = "z";
 
 /**
- * The position column of a Cytoscape-family importer: f32 x3, y-up, 2 source dimensions.
+ * The position column of a Cytoscape-family importer: f64 x3, y-up, 2 source dimensions.
  * @param format - the importer's format name
  * @param sourceDims - 3 when z goes into the position (zAs "position")
  * @returns the declaration
@@ -1664,7 +1664,7 @@ const Z_COLUMN = "z";
 export function positionDecl(format: string, sourceDims = 2): ColumnDecl {
     return {
         name: POSITION_COLUMN,
-        dtype: "f32",
+        dtype: "f64",
         components: 3,
         role: "position",
         mutable: true,
@@ -1690,17 +1690,6 @@ export function zDecl(format: string): ColumnDecl {
     };
 }
 
-/**
- * Whether a coordinate fits the f32 position column: finite once rounded to f32 (1e39 and the
- * Infinity of a literal like 1e400 do not, nor does NaN).
- * @param value - the coordinate
- * @returns true when the column can hold it
- * @category Plugin helpers
- */
-export function fitsF32(value: number): boolean {
-    return Number.isFinite(Math.fround(value));
-}
-
 /**
  * The head of an input as text for a sniff: UTF-16 by its byte order mark, else UTF-8, never
  * failing, without the BOM.

package/src/formats/csv/exporter.ts

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

package/src/formats/cx/importer.ts

@@ -86,7 +86,6 @@ import {
     CxStructure,
     declareFresh,
     ExactInteger,
-    fitsF32,
     flipY,
     headText,
     inexactLiteral,
@@ -2445,11 +2444,11 @@ class CxReader {
                 );
                 continue;
             }
-            if (!fitsF32(value.x) || !fitsF32(value.y)) {
+            if (!Number.isFinite(value.x) || !Number.isFinite(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`,
+                    `a cartesianLayout element for node ${shown(value.node)} has the coordinates ${String(value.x)}, ${String(value.y)}, which are not both finite; skipped`,
                     { line, element: "cartesianLayout" },
                 );
                 continue;

package/src/formats/cx2/importer.ts

@@ -79,7 +79,6 @@ import {
     CxStructure,
     declareFresh,
     ExactInteger,
-    fitsF32,
     flipY,
     headText,
     inexactLiteral,
@@ -1638,11 +1637,11 @@ class Cx2Reader {
                 `${CX2_ISSUE.PARTIAL_LAYOUT}:z`,
             );
         }
-        if (x !== null && y !== null && (!fitsF32(x) || !fitsF32(y))) {
+        if (x !== null && y !== null && (!Number.isFinite(x) || !Number.isFinite(y))) {
             this.report.error(
                 "validation-error",
                 BAD_VALUE_CODE,
-                `${element}: the coordinates ${String(x)}, ${String(y)} are beyond what the f32 position column holds; the position is unset`,
+                `${element}: the coordinates ${String(x)}, ${String(y)} are not both finite; the position is unset`,
                 { line, element },
             );
         } else if (x !== null && y !== null) {

package/src/formats/cys/exporter.ts

@@ -966,7 +966,7 @@ function plan(snapshot: GraphSnapshot, common: ResolvedExportOptions): Plan {
     for (const gen of checkCapabilities(snapshot, CYS_CAPABILITIES, common, {
         roles: SLOT_ROLES,
         roleNames: ROLE_NAMES,
-        positionDtype: "f32",
+        positionDtype: "f64",
     })) {
         // json is reported per column below; ids by the SUID rule (positive integers)
         if (gen.code !== LOSS.JSON && gen.code !== LOSS.ID_CHARSET && gen.code !== LOSS.ID_MANGLED) {
@@ -1224,8 +1224,9 @@ function viewCoords(p: Plan, i: number): string[] {
     const coords: string[] = [];
     if (p.position?.isSet(i) === true) {
         const [x, y, z] = Array.from(p.position.value(i) as ArrayLike<number>);
+        const fmt = p.position.dtype === "f32" ? formatF32 : formatF64;
         if (Number.isFinite(x) && Number.isFinite(y)) {
-            coords.push(`x="${formatF32(x)}"`, `y="${formatF32(y === 0 ? 0 : -y)}"`);
+            coords.push(`x="${fmt(x)}"`, `y="${fmt(y === 0 ? 0 : -y)}"`);
         }
         if (
             Number.isFinite(x) &&
@@ -1235,7 +1236,7 @@ function viewCoords(p: Plan, i: number): string[] {
             z !== 0 &&
             Number.isFinite(z)
         ) {
-            coords.push(`z="${formatF32(z)}"`);
+            coords.push(`z="${fmt(z)}"`);
         }
     }
     if (p.z?.isSet(i) === true) {

package/src/formats/dot/exporter.ts

@@ -206,7 +206,7 @@ export const dotExporter: GraphExporter<DotExportOptions> = Object.freeze({
     check(snapshot: GraphSnapshot, options?: DotExportOptions & CommonExportOptions): readonly LossNote[] {
         const resolved = resolveExportOptions(options);
         const notes = checkCapabilities(snapshot, CAPABILITIES, resolved, {
-            positionDtype: "f32",
+            positionDtype: "f64",
             roles: KEPT_ROLES,
             roleNames: ROLE_NAMES,
         });

package/src/formats/dot/importer.ts

@@ -21,7 +21,7 @@
  *   name (fdp's cluster edges) merge into that one node with a warning. Other subgraphs are
  *   transparent grouping; their attributes are reported as dropped.
  * - attribute values are ID strings inferred per column by the sink under the 5.1 grammar, except
- *   `label` (text, role label), `pos` on a node (the position role column, f32 x3, design section
+ *   `label` (text, role label), `pos` on a node (the position role column, f64 x3, design section
  *   5.2), `weight` (THE weight, `weightFrom`) and `key` (cgraph's edge identity, the edge id role).
  * - ids are coerced with the common rule (`canonical` by default: `1` and `"1"` are the same node,
  *   as the DOT grammar says).
@@ -68,7 +68,6 @@ import {
     UNKNOWN_ENCODING_CODE,
 } from "../../common/codes.js";
 import { DirectionResolver, type EdgeKind } from "../../common/direction.js";
-import { survivesF32 } from "../../common/format.js";
 import { IdCoercer } from "../../common/ids.js";
 import { canonicalEncoding, readText, throwIfAborted } from "../../common/input.js";
 import {
@@ -177,7 +176,7 @@ export const DOT_ISSUE = Object.freeze({
     CLUSTER_NODE_MERGED: "W_DOT_CLUSTER_NODE_MERGED",
     /** A node mentioned in two unrelated clusters keeps the first. */
     CLUSTER_CONFLICT: "W_DOT_CLUSTER_CONFLICT",
-    /** A node's `pos` is not a point, or is too large for a 32-bit float position; the value was dropped. */
+    /** A node's `pos` is not a point, or has a coordinate that is not finite; the value was dropped. */
     BAD_POS: "W_DOT_BAD_POS",
     /** Node `pos` values mix two and three coordinates; the position column records the first's. */
     POS_DIMS: "W_DOT_POS_DIMS",
@@ -1672,25 +1671,16 @@ class DotParser {
         const z = match[3] === undefined ? 0 : Number(match[3]);
         const dims = match[3] === undefined ? 2 : 3;
         const point = [x, y, z];
-        if (point.some((v) => !Number.isFinite(Math.fround(v)))) {
-            // the position column is f32: a half-infinite point would be a half-valid position
+        if (point.some((v) => !Number.isFinite(v))) {
+            // a half-infinite point would be a half-valid position
             this.report.warning(
                 "validation-error",
                 DOT_ISSUE.BAD_POS,
-                `pos ${JSON.stringify(text)} is beyond the f32 range of the position column; dropped`,
+                `pos ${JSON.stringify(text)} has a coordinate that is not finite; dropped`,
                 { line, element },
             );
             return;
         }
-        if (!point.every(survivesF32)) {
-            this.report.warnOnce(
-                "precision",
-                DOT_ISSUE.PRECISION,
-                `pos ${JSON.stringify(text)} has a coordinate the f32 position column rounds (warned once; positions=false keeps pos as written)`,
-                { line, element },
-                `${DOT_ISSUE.PRECISION}:pos`,
-            );
-        }
         if (this.posDims === 0) {
             this.posDims = dims;
         } else if (dims !== this.posDims) {
@@ -1769,7 +1759,7 @@ class DotParser {
     }
 
     /**
-     * The position column (f32 x3, role position, design section 5.2), declared on the first `pos`.
+     * The position column (f64 x3, role position, design section 5.2), declared on the first `pos`.
      * @param dims - the dimensions of the first value, recorded in extra.sourceDims
      * @returns the handle
      */
@@ -1777,7 +1767,7 @@ class DotParser {
         if (this.positionHandle === INVALID_INDEX) {
             this.positionHandle = this.declare("node", {
                 name: POS_ATTRIBUTE,
-                dtype: "f32",
+                dtype: "f64",
                 components: 3,
                 nullable: true,
                 mutable: true,

package/src/formats/gexf/exporter.ts

@@ -93,8 +93,8 @@ export const GEXF_LOSS = Object.freeze({
     /** A numeric edge id column: GEXF edge ids read back as strings. */
     EDGE_ID_TEXT: "W_GEXF_EDGE_ID_TEXT",
     /**
-     * A visual attribute (position, color, size, thickness) is stored at more precision than GEXF keeps; it reads back
-     * as a 32-bit float.
+     * A visual attribute (position, color, size, thickness) is stored at another precision than the importer gives it;
+     * a position reads back as a 64-bit float, a color, size or thickness as a 32-bit float.
      */
     VIZ_DTYPE: "W_GEXF_VIZ_DTYPE",
     /**
@@ -271,7 +271,7 @@ function planExport(
         ...checkCapabilities(snapshot, caps, resolved, {
             openIntervals: version === "1.2",
             temporalText: true,
-            positionDtype: "f32",
+            positionDtype: "f64",
             roles: MAPPED_ROLES,
             // GEXF 1.2 has no edge kind: the kind column is dropped (W_GEXF_KIND_DROPPED), not renamed
             roleNames: version === "1.2" ? ROLE_NAMES_1_2 : ROLE_NAMES,
@@ -608,10 +608,12 @@ function collectRoles(
             }
             continue;
         }
-        if (VIZ_NUMERIC_ROLES.has(role) && column.dtype !== "f32") {
+        // the importer reads a position as f64 and every other viz value as f32
+        const vizDtype = role === "position" ? "f64" : "f32";
+        if (VIZ_NUMERIC_ROLES.has(role) && column.dtype !== vizDtype) {
             note(
                 GEXF_LOSS.VIZ_DTYPE,
-                `${domain} column "${meta.name}" (${role}) is ${column.dtype}; viz values read back as f32`,
+                `${domain} column "${meta.name}" (${role}) is ${column.dtype}; viz values read back as ${vizDtype}`,
                 meta.name,
                 column.length - column.nullCount,
             );

package/src/formats/gexf/schema.ts

@@ -184,7 +184,7 @@ export const NODE_DECLS: Readonly<Record<keyof typeof NODE_COLUMNS, ColumnDecl>>
     },
     position: {
         name: NODE_COLUMNS.position,
-        dtype: "f32",
+        dtype: "f64",
         components: 3,
         role: "position",
         mutable: true,

package/src/formats/json/exporter.ts

@@ -648,7 +648,7 @@ function plan(snapshot: GraphSnapshot, resolved: Resolved): Plan {
     // plain attributes and read back without their role)
     const notes = checkCapabilities(snapshot, caps, resolved.common, {
         roles: SLOT_ROLES[dialect],
-        positionDtype: "f32",
+        positionDtype: "f64",
     }).filter((n) => n.code !== LOSS.POSITIONS && n.code !== LOSS.EDGE_IDS_DROPPED);
     const note: NoteFn = (code, message, column = null, count = null): void => {
         notes.push(Object.freeze({ code, message, column, count }));

package/src/formats/json/importer.ts

@@ -3369,7 +3369,7 @@ function importCytoscape(ctx: ImportContext, root: unknown): void {
     const positionColumn = ctx.nodes.declareIf(
         {
             name: POSITION_COLUMN,
-            dtype: "f32",
+            dtype: "f64",
             components: 3,
             role: "position",
             mutable: true,
@@ -3450,7 +3450,7 @@ function importCytoscape(ctx: ImportContext, root: unknown): void {
                     report.error(
                         "validation-error",
                         JSON_ISSUE.BAD_VALUE,
-                        `${element}: position must be an object with numeric x and y (and z) that are finite and within the f32 range`,
+                        `${element}: position must be an object with numeric x and y (and z) that are finite numbers`,
                         { element },
                     );
                 }
@@ -3656,16 +3656,13 @@ function hasPositionZ(element: unknown): boolean {
     return isJsonObject(element) && isJsonObject(element.position) && typeof element.position.z === "number";
 }
 
-/** The largest finite f32, the bound of a position coordinate. */
-const F32_MAX = 3.4028234663852886e38;
-
 /**
- * Whether a value is a coordinate the f32 position column holds: a finite number within the f32 range.
+ * Whether a value is a coordinate the position column holds: a finite number.
  * @param value - the value
  * @returns true for a storable coordinate
  */
 function isCoordinate(value: unknown): value is number {
-    return typeof value === "number" && Number.isFinite(value) && Math.abs(value) <= F32_MAX;
+    return typeof value === "number" && Number.isFinite(value);
 }
 
 /**