@graphty/graph-io 0.3.48 → 0.3.50

package/src/formats/gexf/styles.ts

@@ -14,11 +14,11 @@ import { canonNumber } from "../../styles/canon/number.js";
 import type { CanonSite } from "../../styles/canon/site.js";
 import { canonText } from "../../styles/canon/text.js";
 import { StyleApproximations } from "../../styles/io/approximations.js";
-import { blockStyles, parseStyleBlock, STYLE_BLOCK_NAME } from "../../styles/io/block.js";
+import { STYLE_BLOCK_NAME } from "../../styles/io/block.js";
+import { type ElementValues, takeFromBlock } from "../../styles/io/round-trip.js";
 import type { ExporterStyleInput } from "../../styles/io/writer.js";
 import { StyleNotes } from "../../styles/notes.js";
-import { styleFingerprint } from "../../styles/plan/features.js";
-import { plainCell, resolveStyles } from "../../styles/plan/resolve.js";
+import { plainCell } from "../../styles/plan/resolve.js";
 import type {
     ImporterStyles,
     StyleColumn,
@@ -29,7 +29,9 @@ import type {
     StyleWriteCapabilities,
 } from "../../styles/types.js";
 import type { LossNote } from "../../types.js";
-import { NODE_COLUMNS, VIZ_NAMESPACE } from "./schema.js";
+import { DIALOG_LINE_HEIGHT, dialogWidth } from "./dialog-metrics.js";
+import { dependantColor, drawnLabels, edgeThickness, type GephiFont, GephiPreview } from "./preview.js";
+import { NODE_COLUMNS, TEMPORAL_COLUMNS, temporalTableName, VIZ_NAMESPACE } from "./schema.js";
 
 /** The column of a node's `label` attribute. */
 const LABEL_COLUMN = NODE_COLUMNS.label;
@@ -58,15 +60,20 @@ const GEPHI_NODE_FILL = "#000000";
 /** The style column marking directed edges, which Gephi draws with an arrow at the target. */
 const DIRECTED_KEY = "directed";
 
-/** The style column holding the mixed color of each edge without a color of its own. */
-const MIXED_COLOR_KEY = "mixed-color";
-/** The style columns of the border Gephi draws on each node without one of its own. */
-const BORDER_COLOR_KEY = "border-color";
-const BORDER_WIDTH_KEY = "border-width";
-/** The style column of the label size Gephi draws on each node, scaled with the node. */
-const LABEL_SIZE_KEY = "label-size";
-/** The style column of the width Gephi draws an edge with from its weight. */
-const WEIGHT_WIDTH_KEY = "weight-width";
+/** The style column marking the nodes whose labels Gephi hides where they overlap (node.label.avoidOverlap). */
+const AVOID_OVERLAP_KEY = "label-avoid-overlap";
+
+/** The style column marking the edges Gephi does not draw (dropped, or merged into a parallel edge). */
+const HIDDEN_KEY = "gephi-hidden";
+
+/** The style column holding the mix of its end nodes' colors of each edge without a color of its own. */
+const MIXED_COLOR_KEY = "end-colors";
+/** The width property and the style column of the width Gephi draws an edge with from its weight. */
+const WEIGHT_WIDTH = ["width", "weight-width"] as const;
+/** Gephi's node width when a node has no `viz:size` (graphstore NodeImpl size 10, a radius). */
+const GEPHI_NODE_WIDTH = 20;
+/** How much thicker than its weight Gephi draws a self-loop. */
+const SELF_LOOP_THICKNESS = 1.3;
 
 /** GEXF's node shapes, by the neutral shape each writes exactly. */
 const NODE_SHAPES: ReadonlyMap<string, string> = new Map([
@@ -116,26 +123,37 @@ const VIZ_COLUMNS: Readonly<Record<StyleTarget, readonly string[]>> = {
 };
 
 /**
- * A `viz:color` `hex` value as channels: r, g and b 0..255 and an alpha 0..1. Reads `#rgb`, `#rgba`, `#rrggbb` and
- * `#rrggbbaa` (alpha last), with or without the `#`.
+ * A `viz:color` `hex` value as channels: r, g and b 0..255 and an alpha 0..1, read the way Gephi reads it: Java's
+ * `Color.decode`, which parses the text as one integer (`Integer.decode`: `#` or `0x` hexadecimal, a leading `0`
+ * octal, otherwise decimal; a leading sign allowed) and keeps its low 24 bits, opaque. So `#rrggbb` is the color it
+ * names, but `#f80` is `#000f80`, `#4daf4a80` is `#af4a80` and `984ea3` is not a color at all (Gephi draws that node
+ * as if it had no color: `gexf-specimen-node-fills-borders`, `color-hex-short`, `color-hex-alpha`, `color-hex-nohash`).
  * @param hex - the attribute's value
- * @returns `[r, g, b, a]`, or null when it is not a hex color
+ * @returns `[r, g, b, 1]`, or null when Java cannot read it as an int
  */
 export function canonVizColor(hex: string): [number, number, number, number] | null {
-    const text = hex.trim();
-    if (!/^#?([0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/i.test(text)) {
+    const m = /^([+-]?)(?:(0x|0X|#)([0-9a-fA-F]+)|(0[0-7]+)|(\d+))$/.exec(hex.trim());
+    if (m === null) {
         return null;
     }
-    const c = canonColor(text.startsWith("#") ? text : `#${text}`, "css", {
-        notes: new StyleNotes(),
-        target: "node",
-        property: "fill",
-    });
-    if (c === null) {
+    const [, sign, , hexDigits, octal, decimal] = m;
+    let v: number;
+    if (hexDigits !== undefined) {
+        v = Number.parseInt(hexDigits, 16);
+    } else if (octal !== undefined) {
+        v = Number.parseInt(octal, 8);
+    } else {
+        v = Number.parseInt(decimal, 10);
+    }
+    if (sign === "-") {
+        v = -v;
+    }
+    // Integer.decode accepts -2^31 .. 2^31 - 1 only
+    if (v < -2147483648 || v > 2147483647) {
         return null;
     }
-    const n = Number.parseInt(c.color.slice(1), 16);
-    return [(n >> 16) & 255, (n >> 8) & 255, n & 255, c.alpha];
+    const n = v & 0xffffff;
+    return [(n >> 16) & 255, (n >> 8) & 255, n & 255, 1];
 }
 
 /**
@@ -256,17 +274,22 @@ function readVizColor(viz: VizRead, color: string, i: number): void {
 }
 
 /**
- * Reads one element's viz size (a node's width and height) or thickness (an edge's width).
+ * Reads one element's viz size (a node's width and height) or thickness (an edge's width). A node's
+ * size is a radius, as Gephi and sigma draw it (Gephi's preview: a circle of radius 0.92 x size plus
+ * a 0.16 x size outline, an outer diameter of 2 x size), so its width and height are twice it.
  * @param viz - the target's reading
  * @param size - the viz size or thickness column
  * @param i - the element
  */
 function readVizSize(viz: VizRead, size: string, i: number): void {
     const v = canonNumber(plainCell(viz.table.value(size, i)), viz.site(i, "width"));
-    if (v !== null) {
-        viz.column("width")[i] = v;
+    // Gephi draws a node of viz:size 0 at its default size 10 (gexf-specimen-node-sizes-opacity, size-0)
+    if (v !== null && !(v === 0 && viz.target === "node")) {
         if (viz.target === "node") {
-            viz.column("height")[i] = v;
+            viz.column("width")[i] = 2 * v;
+            viz.column("height")[i] = 2 * v;
+        } else {
+            viz.column("width")[i] = v;
         }
     }
 }
@@ -288,206 +311,987 @@ function readVizShape(viz: VizRead, shape: string, i: number): boolean {
     return typeof raw === "string" && raw.toLowerCase() === "image";
 }
 
+/** What Gephi draws of each edge (gephiEdges()). */
+interface GephiDrawnEdges {
+    /** Whether Gephi draws the edge directed, with an arrow at its target. */
+    readonly directed: boolean[];
+    /** Whether Gephi does not draw the edge at all. */
+    readonly hidden: boolean[];
+    /** The weight Gephi draws the edge with: merged, then shifted. */
+    readonly weight: number[];
+}
+
 /**
- * Whether each edge is directed.
+ * The edges as Gephi's importer and preview draw them (measured with the Gephi Toolkit 0.11.3:
+ * `gexf-specimen-edges-lines`, `-p13`, `-p15`, `gexf-specimen-arrows`, `-p6`, `-p7`):
+ * - an edge whose own type is against the graph's `defaultedgetype` is dropped (`undirected` in a `directed`
+ *   graph, `directed` in an `undirected` one); a `mutual` graph, or one with no `defaultedgetype`, keeps every
+ *   edge, an untyped or `mutual` one directed;
+ * - edges of one kind between the same ends (either way round for an undirected edge) are merged into the first,
+ *   whose weight is their sum;
+ * - an edge's weight is its `weight` (1 when it has none), or, when an edge attribute named weight is dynamic, its
+ *   value over the earliest interval (0 when it has none);
+ * - when the smallest weight drawn is 0 or less, every weight is raised by |smallest| + 1.
+ * An undirected edge of a directed snapshot is two halves here; both take what its first half gets.
  * @param snapshot - the graph
- * @returns one flag per edge
+ * @param gexf - whether the file is a GEXF; another format keeps its own direction, with nothing merged or dropped
+ * @returns per edge, what Gephi draws
  */
-function directedEdges(snapshot: GraphSnapshot): boolean[] {
-    const out = new Array<boolean>(snapshot.edgeCount).fill(snapshot.directed);
-    const col = snapshot.directed ? snapshot.edges.byRole("directed") : null;
-    if (col !== null) {
-        for (let e = 0; e < snapshot.edgeCount; e++) {
-            out[e] = plainCell(col.value(e)) !== false;
+function gephiEdges(snapshot: GraphSnapshot, gexf: boolean): GephiDrawnEdges {
+    const n = snapshot.edgeCount;
+    const first = firstHalf(snapshot);
+    // another format Gephi draws: its own direction, nothing merged or dropped
+    if (!gexf) {
+        return otherFormatEdges(snapshot);
+    }
+    const header = gexfDefaultEdgeType(snapshot);
+    const dirCol = snapshot.edges.byRole("directed");
+    const mutualCol = snapshot.edges.byRole("mutual");
+    const kindCol = snapshot.edges.byRole("kind");
+    const weightOf = gephiWeight(snapshot);
+    const out: GephiDrawnEdges = {
+        directed: new Array<boolean>(n).fill(false),
+        hidden: new Array<boolean>(n).fill(false),
+        weight: new Array<number>(n).fill(1),
+    };
+    const leaders = new Map<string, number>();
+    const drawnLeaders: number[] = [];
+    const ownDirection = gexfOwnDirection(header, dirCol, mutualCol);
+    for (let e = 0; e < n; e++) {
+        const f = first(e);
+        if (f !== e) {
+            continue;
+        }
+        // the edge's own type: graph-io records it only when the file mixes directions
+        const { ownUndirected, mismatched } = ownDirection(f);
+        if (mismatched) {
+            out.hidden[f] = true;
+            continue;
         }
+        // Gephi draws no arrowhead on a self-loop
+        const s = snapshot.edgeSource(f);
+        const t = snapshot.edgeTarget(f);
+        const directed = header !== "undirected" && s !== t && !ownUndirected;
+        out.directed[f] = directed;
+        const kind = kindCol?.isSet(f) === true ? String(kindCol.value(f)) : "";
+        const key = `${kind}\u0000${gephiEndsKey(s, t, directed)}`;
+        const leader = leaders.get(key);
+        if (leader === undefined) {
+            leaders.set(key, f);
+            drawnLeaders.push(f);
+            out.weight[f] = weightOf(f);
+        } else {
+            out.weight[leader] += weightOf(f);
+            out.hidden[f] = true;
+        }
+    }
+    // a loop, not Math.min(...): a spread of every edge overflows the call stack on a large graph
+    const smallest = drawnLeaders.reduce((m, f) => Math.min(m, out.weight[f]), Infinity);
+    const shift = smallest <= 0 ? 1 - smallest : 0;
+    for (let e = 0; e < n; e++) {
+        const f = first(e);
+        out.directed[e] = out.directed[f];
+        out.hidden[e] = out.hidden[f];
+        out.weight[e] = out.weight[f] + shift;
     }
     return out;
 }
 
 /**
- * The rules Gephi's defaults make per element, as Gephi's Preview draws them (`DefaultPreset.java`; sources in
- * `styles/defaults.ts`): an arrow at the target of every directed edge; the mean of its two nodes' colors on every
- * edge without a color of its own (Preview's "mixed" edge color); the edge's weight as the thickness of every edge
- * without a thickness of its own; a border darker than its fill and scaled with its size on every node without a
- * border of its own; and each node's label, in a size scaled with the node (12 for a size-10 node) on every node
- * without a label size of its own (Gephi draws GEXF, its GraphML export and its GML the same way).
- *
- * Labels are a choice, not Gephi's default: Gephi hides them in both its drawings (`DefaultPreset.java` line 106,
- * `VizConfig.java` line 113), while sigma.js and gexf-js, which most published GEXF files are viewed with, show
- * them. graph-io shows them: a label is what the file states about a node, and hiding it is a view setting Gephi
- * offers as a switch, like the application's own; an application that wants Gephi's look hides them itself.
- *
- * An edge's own color is kept, though Preview's "mixed" mode draws over it: the file states it, and Gephi's
- * Overview, Preview's "original" mode, sigma.js and gexf-js all draw it.
+ * The ends of an edge as the key Gephi merges parallel edges by: in order for a directed edge, either way round
+ * for an undirected one.
+ * @param s - the source node index
+ * @param t - the target node index
+ * @param directed - whether the edge is drawn directed
+ * @returns the key
+ */
+function gephiEndsKey(s: number, t: number, directed: boolean): string {
+    return directed ? `${String(s)}>${String(t)}` : `${String(Math.min(s, t))}-${String(Math.max(s, t))}`;
+}
+
+/**
+ * A GEXF edge's own type, read from the directed and mutual columns, or from the header when the file did not
+ * mix directions (no directed column); an edge whose own type disagrees with the header's is one Gephi never loads.
+ * @param header - the file's default edge type
+ * @param dirCol - the directed column, or null
+ * @param mutualCol - the mutual column, or null
+ * @returns per edge index, whether its own type is undirected and whether it disagrees with the header
+ */
+function gexfOwnDirection(
+    header: ReturnType<typeof gexfDefaultEdgeType>,
+    dirCol: ReturnType<GraphSnapshot["edges"]["byRole"]>,
+    mutualCol: ReturnType<GraphSnapshot["edges"]["byRole"]>,
+): (f: number) => { ownUndirected: boolean; mismatched: boolean } {
+    const verdict = (
+        ownUndirected: boolean,
+        ownDirected: boolean,
+    ): { ownUndirected: boolean; mismatched: boolean } => ({
+        ownUndirected,
+        mismatched: (header === "directed" && ownUndirected) || (header === "undirected" && ownDirected),
+    });
+    return (f) => {
+        if (dirCol === null) {
+            return verdict(header === "undirected", header !== "undirected");
+        }
+        const mutual = mutualCol?.value(f) === true;
+        return verdict(dirCol.value(f) === false && !mutual, dirCol.value(f) === true && !mutual);
+    };
+}
+
+/**
+ * The edges of a format other than GEXF as Gephi draws them: each in its own direction, as thick as its weight (1
+ * for a weight of 0 or below, so the edge stays visible).
  * @param snapshot - the graph
- * @param node - the node values read from the file
- * @param edge - the edge values read from the file
- * @param budget - the work budget
- * @returns the node and edge rules and the style columns they read
+ * @returns per edge, what Gephi draws
  */
-export function gephiRules(
-    snapshot: GraphSnapshot,
-    node: Readonly<Record<string, readonly (StyleValue | null)[]>>,
-    edge: Readonly<Record<string, readonly (StyleValue | null)[]>>,
-    budget: StyleReadContext["budget"],
-): { readonly node: ToolRules; readonly edge: ToolRules } {
-    return { node: gephiNodeRules(snapshot, node, budget), edge: gephiEdgeRules(snapshot, node, edge, budget) };
+function otherFormatEdges(snapshot: GraphSnapshot): GephiDrawnEdges {
+    const first = firstHalf(snapshot);
+    const weightOf = gephiWeight(snapshot);
+    const directed = new Array<boolean>(snapshot.edgeCount).fill(snapshot.directed);
+    const col = snapshot.directed ? snapshot.edges.byRole("directed") : null;
+    const weight: number[] = [];
+    for (let e = 0; e < snapshot.edgeCount; e++) {
+        if (col !== null) {
+            directed[e] = plainCell(col.value(e)) !== false;
+        }
+        const w = weightOf(first(e));
+        weight.push(w > 0 ? w : 1);
+    }
+    return { directed, hidden: directed.map(() => false), weight };
 }
 
-/** Rules and the style columns they read. */
-interface ToolRules {
+/**
+ * The graph's `defaultedgetype` as written, lower case, or null when it wrote none.
+ * @param snapshot - the graph
+ * @returns the keyword
+ */
+function gexfDefaultEdgeType(snapshot: GraphSnapshot): string | null {
+    const written = (snapshot.meta.extra.gexf as { defaultedgetype?: unknown } | undefined)?.defaultedgetype;
+    return typeof written === "string" ? written.trim().toLowerCase() : null;
+}
+
+/**
+ * Each edge's weight as Gephi reads it: an edge attribute whose id or title is `weight` and is dynamic is the weight,
+ * at its value over the earliest interval (0 for an edge without one: its static `weight` is not read); otherwise
+ * the edge's `weight`, 1 for an edge with none.
+ * @param snapshot - the graph
+ * @returns the weight of an edge
+ */
+function gephiWeight(snapshot: GraphSnapshot): (e: number) => number {
+    const isWeight = (v: unknown): boolean => typeof v === "string" && v.toLowerCase() === "weight";
+    const dynamic = snapshot.edges
+        .names()
+        .map((name) => snapshot.edges.get(name))
+        .find(
+            (c) =>
+                c !== null && c.meta.dynamic && [c.meta.name, c.meta.origin?.id, c.meta.origin?.title].some(isWeight),
+        );
+    const table =
+        dynamic === undefined || dynamic === null
+            ? undefined
+            : snapshot.extensions.get(temporalTableName("edge", dynamic.meta.name));
+    if (table !== undefined) {
+        const element = table.get(TEMPORAL_COLUMNS.element);
+        const start = table.get(TEMPORAL_COLUMNS.start);
+        const value = table.get(TEMPORAL_COLUMNS.value);
+        const earliest = new Map<number, { start: number; value: number }>();
+        for (let row = 0; element !== null && value !== null && row < table.rowCount; row++) {
+            const e = element.value(row) as number;
+            const at = start?.isSet(row) === true ? (start.value(row) as number) : -Infinity;
+            const v = Number(value.value(row));
+            const seen = earliest.get(e);
+            if (Number.isFinite(v) && (seen === undefined || at < seen.start)) {
+                earliest.set(e, { start: at, value: v });
+            }
+        }
+        return (e) => earliest.get(e)?.value ?? 0;
+    }
+    // the snapshot's own weights (the role column exists only when some edge has none), as their shortest decimal
+    const weights = explicitWeights(snapshot);
+    return (e) => {
+        const w = Number(weights.text(e) ?? 1);
+        return Number.isFinite(w) ? w : 1;
+    };
+}
+
+/** The node values Gephi's per-element defaults are worked out from, each undefined when no node has one. */
+interface GephiNodeValues {
+    /** Each node's fill. */
+    readonly fill?: readonly (StyleValue | null)[];
+    /** Each node's fill opacity (the alpha of its color), null for opaque. */
+    readonly fillOpacity?: readonly (StyleValue | null)[];
+    /** Each node's width, twice its Gephi size. */
+    readonly width?: readonly (StyleValue | null)[];
+}
+
+/** The edge values Gephi's per-element defaults give way to, each undefined when no edge has one. */
+interface GephiEdgeValues {
+    /** Each edge's own color. */
+    readonly color?: readonly (StyleValue | null)[];
+    /** Each edge's own width. */
+    readonly width?: readonly (StyleValue | null)[];
+}
+
+/** The rules of one target and the style columns they read. */
+interface GephiTargetRules {
     readonly rules: StyleRule[];
     readonly columns: Map<string, StyleColumn>;
 }
 
-/** Preview's "darker" border: each channel of the fill times this (`DependantColor.java` line 55). */
-const GEPHI_BORDER_DARKEN = 0.498;
-/** Preview's border width as a share of the node's drawn width (`SizeUtils.java` lines 11, 37). */
-const GEPHI_BORDER_SHARE = 0.08;
-/** Gephi's node size when a node has none (`AbstractProcessor.java` lines 195-198). */
-const GEPHI_NODE_SIZE = 10;
 /**
- * Preview's label size per unit of node size: Arial 12 (`DefaultPreset.java` line 93) times the node drawn twice its
- * size wide times 0.05 (`NodeLabelRenderer.java` lines 165-173, `NODE_LABEL_PROPORTIONAL_SIZE` true), so 12 for a
- * size-10 node.
+ * A node color's channels as Gephi holds them: r, g, b and alpha, 0..255.
+ * @param fill - the node's fill, or null for Gephi's default
+ * @param opacity - its opacity, or null for opaque
+ * @returns the channels
+ */
+function nodeChannels(fill: StyleValue | null | undefined, opacity: StyleValue | null | undefined): number[] {
+    const n = Number.parseInt((typeof fill === "string" ? fill : GEPHI_NODE_FILL).slice(1), 16);
+    const a = typeof opacity === "number" ? Math.round(opacity * 255) : 255;
+    return [(n >> 16) & 255, (n >> 8) & 255, n & 255, a];
+}
+
+/**
+ * `#rrggbb` of three channels.
+ * @param c - r, g and b, 0..255
+ * @returns the color
+ */
+function hexOf(c: readonly number[]): string {
+    return `#${c
+        .slice(0, 3)
+        .map((v) => v.toString(16).padStart(2, "0"))
+        .join("")}`;
+}
+
+/**
+ * A passthrough rule of a tool default that is itself per element, and its column, when any element takes it.
+ * @param out - the target's rules and columns, changed in place
+ * @param target - nodes or edges
+ * @param pair - the style property and its style column, which is also the rule's id after `<target>.tool.`
+ * @param column - the default per element, null where the element has its own value
+ * @param reason - why the values are per element
+ */
+function perElementDefault(
+    out: GephiTargetRules,
+    target: StyleTarget,
+    pair: readonly [string, string],
+    column: (StyleValue | null)[],
+    reason: string,
+): void {
+    const [property, key] = pair;
+    const elements = column.filter((v) => v !== null).length;
+    if (elements === 0) {
+        return;
+    }
+    out.columns.set(key, column);
+    out.rules.push({
+        id: `${target}.tool.${key}`,
+        target,
+        role: "passthrough",
+        origin: "tool",
+        where: { has: { style: key } },
+        map: { [property]: { kind: "passthrough" as const, by: { style: key } } },
+        facts: { elements, reason },
+    });
+}
+
+/** What a GEXF drawing adds to gephiRules(): the file is a GEXF, drawn under these Preview settings. */
+interface GephiDrawing {
+    /** The Preview settings, Gephi's defaults where none is given. */
+    readonly preview: GephiPreview;
+    /** Each edge's own viz color and its alpha, which `edge.color=original` draws. */
+    readonly original?: {
+        readonly color?: readonly (StyleValue | null)[];
+        readonly opacity?: readonly (StyleValue | null)[];
+    };
+    /** Each edge's label, drawn under `edge.label.show`. */
+    readonly edgeLabels?: readonly (StyleValue | null)[];
+    /** Whether the node labels Gephi's overlap avoidance hides are already left out (gephiOverlapHidden()). */
+    readonly overlapSettled?: boolean;
+}
+
+/**
+ * A tool rule that sets the same values on every element.
+ * @param out - the target's rules, changed in place
+ * @param target - nodes or edges
+ * @param id - the rule's id after `<target>.tool.`
+ * @param set - the values
  */
-const GEPHI_LABEL_PER_SIZE = 1.2;
+function everyElement(out: GephiTargetRules, target: StyleTarget, id: string, set: Record<string, StyleValue>): void {
+    if (Object.keys(set).length > 0) {
+        out.rules.push({
+            id: `${target}.tool.${id}`,
+            target,
+            role: "group",
+            origin: "tool",
+            where: { all: true },
+            set,
+        });
+    }
+}
 
 /**
- * The node rules of Gephi's defaults: the border Preview draws, the label and its size scaled with the node.
+ * The rules Gephi's preview defaults (DefaultPreset) make per element, as its SVG export draws every GEXF and GraphML
+ * file: each node outlined in a darker shade of its fill, 0.08 of its width wide, with its label 0.3 of its width
+ * tall; each edge in the mix of its two end nodes' colors and alphas, as thick as its weight, with an arrow at the
+ * target of a directed edge. An element's own value is kept (a file graphty wrote states every one). A GEXF drawing
+ * also merges and drops edges as Gephi's importer does (gephiEdges()) and follows the Preview settings it was drawn
+ * with.
  * @param snapshot - the graph
- * @param node - the node values read from the file
+ * @param nodes - each node's fill, opacity and width
+ * @param edges - each edge's own color and width
  * @param budget - the work budget
- * @returns the rules and their columns
+ * @param gexf - the GEXF drawing, or undefined for another format Gephi draws
+ * @returns the node and edge rules and the style columns they read
  */
-function gephiNodeRules(
+export function gephiRules(
     snapshot: GraphSnapshot,
-    node: Readonly<Record<string, readonly (StyleValue | null)[]>>,
+    nodes: GephiNodeValues,
+    edges: GephiEdgeValues,
     budget: StyleReadContext["budget"],
-): ToolRules {
-    const rules: StyleRule[] = [];
-    const columns = new Map<string, StyleColumn>();
-    const n = snapshot.nodeCount;
-    budget.spend("node", n);
-    // Preview draws a ring of the fill, each channel times 0.498 (rounded), 0.08 of the node's width wide
-    const color = withoutOwn(node.borderColor, n, (i) => darker(node.fill?.[i] ?? GEPHI_NODE_FILL));
-    const size = (i: number): number => {
-        const w = node.width?.[i];
-        return typeof w === "number" ? w : GEPHI_NODE_SIZE;
-    };
-    const width = withoutOwn(node.borderWidth, n, (i) => round6(size(i) * GEPHI_BORDER_SHARE));
-    // Preview scales each label with its node (NODE_LABEL_PROPORTIONAL_SIZE)
-    const labelSize = withoutOwn(node.labelSize, n, (i) => round6(size(i) * GEPHI_LABEL_PER_SIZE));
-    for (const [property, key, values, reason] of [
-        ["borderColor", BORDER_COLOR_KEY, color, "FILL_BORDER"],
-        ["borderWidth", BORDER_WIDTH_KEY, width, "FILL_BORDER"],
-        ["labelSize", LABEL_SIZE_KEY, labelSize, "NODE_SIZE_LABEL"],
-    ] as const) {
-        const elements = values.filter((v) => v !== null).length;
-        if (elements > 0) {
-            columns.set(key, values);
-            rules.push({
-                id: `node.tool.${key}`,
-                target: "node",
-                role: "passthrough",
-                origin: "tool",
-                where: { has: { style: key } },
-                map: { [property]: { kind: "passthrough" as const, by: { style: key } } },
-                facts: { elements, reason },
-            });
-        }
+    gexf?: GephiDrawing,
+): { readonly node: GephiTargetRules; readonly edge: GephiTargetRules } {
+    const preview = gexf?.preview ?? new GephiPreview();
+    const node: GephiTargetRules = { rules: [], columns: new Map() };
+    const edge: GephiTargetRules = { rules: [], columns: new Map() };
+    budget.spend("node", snapshot.nodeCount);
+    budget.spend("edge", snapshot.edgeCount);
+    const channels = Array.from({ length: snapshot.nodeCount }, (_, i) =>
+        nodeChannels(nodes.fill?.[i], nodes.fillOpacity?.[i]),
+    );
+    const labelSizes = nodeRules(node, snapshot, channels, nodes, preview);
+    edgeRules(edge, snapshot, channels, nodes, edges, gexf, preview);
+    nodeLabelRules(node, channels, labelSizes, preview, gexf?.overlapSettled === true);
+    labelBox(node, channels, nodes, preview);
+    return { node, edge };
+}
+
+/**
+ * A node's width, twice its Gephi size.
+ * @param nodes - the node values
+ * @param i - the node
+ * @returns the width
+ */
+function nodeWidth(nodes: GephiNodeValues, i: number): number {
+    const w = nodes.width?.[i];
+    return typeof w === "number" ? w : GEPHI_NODE_WIDTH;
+}
+
+/**
+ * The node rules: opacity, border and label size.
+ * @param node - the node rules, changed in place
+ * @param snapshot - the graph
+ * @param channels - each node's color channels
+ * @param nodes - the node values
+ * @param preview - the settings
+ * @returns each node's label size
+ */
+function nodeRules(
+    node: GephiTargetRules,
+    snapshot: GraphSnapshot,
+    channels: readonly number[][],
+    nodes: GephiNodeValues,
+    preview: GephiPreview,
+): number[] {
+    const nodeIndices = Array.from({ length: snapshot.nodeCount }, (_, i) => i);
+    // a node's alpha is drawn only under node.per.node.opacity, times node.opacity, on its fill and its border alike:
+    // a node not opaque is a fill of radius 0.84 s and a separate ring out to s, both at that alpha
+    const perNode = preview.on("node.per.node.opacity");
+    const alpha = channels.map((c) => ((perNode ? c[3] : 255) / 255) * (preview.num("node.opacity") / 100));
+    const translucent = alpha.map((a) => (a < 1 ? a : null));
+    perElementDefault(node, "node", ["fillOpacity", "preview-opacity"], translucent, "NODE_OPACITY");
+    perElementDefault(node, "node", ["borderOpacity", "preview-border-opacity"], translucent, "NODE_OPACITY");
+    // NodeRenderer: the border is DependantColor DARKER by default, half of each channel (+-1 from Gephi's float math)
+    const borderMode = preview.text("node.border.color");
+    perElementDefault(
+        node,
+        "node",
+        ["borderColor", "border-shade"],
+        channels.map((c) => hexOf(dependantColor(borderMode, c) ?? c.map((v) => Math.floor(v / 2)))),
+        "NODE_FILL_SHADE",
+    );
+    // A node of size s is a circle of radius 0.92 s with a 0.16 s border: 0.08 of its 2 s width, or node.border.width
+    // under node.border.fixed. Its label is the label font's size in proportion to the node's, round(size / 20 * s)
+    // (NODE_LABEL_PROPORTIONAL_SIZE; Arial 12 makes round(0.6 s)), never under 1.
+    const fixed = preview.on("node.border.fixed") ? preview.num("node.border.width") : null;
+    perElementDefault(
+        node,
+        "node",
+        ["borderWidth", "size-border"],
+        nodeIndices.map((i) => {
+            // a fixed border is no wider than the node's size (radius): a size-3 node takes a border of 4 as 3
+            return fixed === null ? 0.08 * nodeWidth(nodes, i) : Math.min(fixed, nodeWidth(nodes, i) / 2);
+        }),
+        "NODE_SIZE",
+    );
+    const font = preview.font("node");
+    const labelSizes = nodeIndices.map((i) =>
+        preview.on("node.label.proportinalSize")
+            ? Math.max(1, Math.round((font.size / 40) * nodeWidth(nodes, i)))
+            : font.size,
+    );
+    perElementDefault(node, "node", ["labelSize", "size-label"], labelSizes, "NODE_SIZE");
+    return labelSizes;
+}
+
+/**
+ * The node label rules the Preview settings make beyond the size: color, outline, font and overlap avoidance.
+ * @param node - the node rules, changed in place
+ * @param channels - each node's color channels
+ * @param sizes - each node's label size
+ * @param preview - the settings
+ * @param settled - whether the labels overlap avoidance hides are already left out
+ */
+function nodeLabelRules(
+    node: GephiTargetRules,
+    channels: readonly number[][],
+    sizes: readonly number[],
+    preview: GephiPreview,
+    settled: boolean,
+): void {
+    const color = preview.text("node.label.color");
+    if (color !== "#000000" && color !== "original") {
+        perElementDefault(
+            node,
+            "node",
+            ["labelColor", "preview-label-color"],
+            channels.map((c) => hexOf(dependantColor(color, c) ?? [0, 0, 0])),
+            "NODE_LABEL_COLOR",
+        );
     }
-    const label = snapshot.nodes.names().find((name) => snapshot.nodes.get(name)?.meta.role === "label");
-    if (label !== undefined && node.label === undefined) {
-        rules.push({
-            id: "node.tool.label",
+    labelOutline(node, "node", channels, sizes, preview);
+    const font = preview.font("node");
+    everyElement(node, "node", "preview-label", fontValues(font, preview.on("node.label.customFont")));
+    // ponytail: where a node has no stored position Gephi's own grid (gephiOverlapHidden()) cannot be run; avoiding
+    // overlap, larger first, is that test without the grid's rounding. A rule only while it is on: graphty-element
+    // has no value that turns a lower rule's overlap avoidance off again.
+    if (preview.on("node.label.avoidOverlap") && !settled) {
+        node.columns.set(
+            AVOID_OVERLAP_KEY,
+            sizes.map(() => true),
+        );
+        node.rules.push({
+            id: "node.tool.label-avoid-overlap",
             target: "node",
-            role: "passthrough",
+            role: "group",
             origin: "tool",
-            where: { has: { data: label } },
-            map: { label: { kind: "passthrough", by: { data: label } } },
-            facts: { reason: "NODE_NAME" },
+            where: { has: { style: AVOID_OVERLAP_KEY } },
+            set: { labelAvoidOverlap: true },
         });
     }
-    return { rules, columns };
 }
 
 /**
- * The edge rules of Gephi's defaults: the target arrow of a directed edge, the mixed color and the weight's width.
+ * Gephi's alpha for a Preview opacity in percent: Java's `Color` keeps it as one of 256 steps, cut down to a whole
+ * step (`labels-p10`'s 30 is drawn 76 / 255, not 77).
+ * @param percent - the opacity, 0 to 100
+ * @returns the alpha, 0 to 1
+ */
+function gephiAlpha(percent: number): number {
+    // ponytail: 1e-9 keeps a step that floating point lands a hair under (0.4 x 255) on its step
+    return Math.floor((Math.min(Math.max(percent, 0), 100) / 100) * 255 + 1e-9) / 255;
+}
+
+/**
+ * The label box of `node.label.box`: Gephi strokes an unfilled box round the label, 0.08 of the node's size wide, in
+ * the color `node.label.box.color` derives from the node's and at `node.label.box.opacity` (`gexf-specimen-labels-p11`,
+ * `-p12`, `-p13`, `-p20`, `-p21`). The box is the text's own bounds -- its advance width and its font's ascent plus
+ * descent, with no leading -- grown by the stroke's width, so the stroke's inner edge lies on the text's bounds
+ * (`labels-p11`: a 15 px "Label" is 40.47 x 17.46 inside a 2.0 stroke): no padding, a line height of 1.
+ * @param node - the node rules, changed in place
+ * @param channels - each node's color channels
+ * @param nodes - the node values
+ * @param preview - the settings
+ */
+function labelBox(
+    node: GephiTargetRules,
+    channels: readonly number[][],
+    nodes: GephiNodeValues,
+    preview: GephiPreview,
+): void {
+    if (!preview.on("node.label.box")) {
+        return;
+    }
+    const mode = preview.text("node.label.box.color");
+    perElementDefault(
+        node,
+        "node",
+        ["labelBorderColor", "preview-box-color"],
+        channels.map((c) => hexOf(dependantColor(mode, c) ?? c)),
+        "LABEL_BOX",
+    );
+    perElementDefault(
+        node,
+        "node",
+        ["labelBorderWidth", "preview-box-width"],
+        channels.map((_, i) => 0.04 * nodeWidth(nodes, i)),
+        "LABEL_BOX",
+    );
+    everyElement(node, "node", "preview-box", {
+        labelBorderOpacity: gephiAlpha(preview.num("node.label.box.opacity")),
+        labelPadding: 0,
+        labelLineHeight: 1,
+    });
+}
+
+/**
+ * The label font values a custom font sets.
+ * @param font - the font
+ * @param custom - whether the font is custom
+ * @returns the values
+ */
+function fontValues(font: GephiFont, custom: boolean): Record<string, StyleValue> {
+    if (!custom) {
+        return {};
+    }
+    return {
+        labelFont: font.family,
+        ...(font.bold ? { labelWeight: "bold" } : {}),
+        ...(font.italic ? { labelItalic: true } : {}),
+    };
+}
+
+/**
+ * The label outline of `<target>.label.outline.size` and `.color`: a stroke size / 32 of the label's size wide, round
+ * each letter, in the color its mode derives from the element's color and at `.outline.opacity` (Gephi's default 80;
+ * `gexf-specimen-labels-p9`, `-p10`, `-p17` .. `-p19`, `edge-labels-p5`, `-p6`).
+ * @param out - the rules, changed in place
+ * @param target - nodes or edges
+ * @param colors - each element's color channels
+ * @param sizes - each element's label size
+ * @param preview - the settings
+ */
+function labelOutline(
+    out: GephiTargetRules,
+    target: StyleTarget,
+    colors: readonly number[][],
+    sizes: readonly number[],
+    preview: GephiPreview,
+): void {
+    const size = preview.num(`${target}.label.outline.size`);
+    if (size <= 0) {
+        return;
+    }
+    const mode = preview.text(`${target}.label.outline.color`);
+    perElementDefault(
+        out,
+        target,
+        ["labelOutlineWidth", "preview-outline-width"],
+        sizes.map((s) => (size / 32) * s),
+        "LABEL_OUTLINE",
+    );
+    perElementDefault(
+        out,
+        target,
+        ["labelOutlineColor", "preview-outline-color"],
+        colors.map((c) => hexOf(dependantColor(mode, c) ?? [255, 255, 255])),
+        "LABEL_OUTLINE",
+    );
+    everyElement(out, target, "preview-outline", {
+        labelOutlineOpacity: gephiAlpha(preview.num(`${target}.label.outline.opacity`)),
+    });
+}
+
+/**
+ * The node labels Gephi's label overlap avoidance hides (`node.label.avoidOverlap`, Gephi 0.11
+ * NodeLabelRenderer.preProcess): largest font first, each label's box -- its Dialog advance width by its line height,
+ * centered on its node -- marks the cells of a `node.label.overlapGridSize` grid over the nodes' bounds, and a label
+ * any of whose cells an earlier one marked is hidden. A label's font size is 12 x 0.05 x its node's size (proportional
+ * size) or the font's, measured in the float size of the last label of the same whole size (Gephi's font cache),
+ * its labels taken largest node first.
+ * Decided where every node has a stored position; elsewhere graphty-element lays the graph out, so null.
  * @param snapshot - the graph
- * @param node - the node values read from the file
- * @param edge - the edge values read from the file
- * @param budget - the work budget
- * @returns the rules and their columns
+ * @param labels - each node's label as drawn
+ * @param widths - each node's width (twice its size), or undefined for Gephi's default
+ * @param preview - the settings
+ * @returns whether each label is hidden, or null
  */
-function gephiEdgeRules(
+function gephiOverlapHidden(
     snapshot: GraphSnapshot,
-    node: Readonly<Record<string, readonly (StyleValue | null)[]>>,
-    edge: Readonly<Record<string, readonly (StyleValue | null)[]>>,
-    budget: StyleReadContext["budget"],
-): ToolRules {
-    const rules: StyleRule[] = [];
-    const columns = new Map<string, StyleColumn>();
-    const directed = directedEdges(snapshot);
-    if (directed.some(Boolean)) {
-        columns.set(
+    labels: readonly (StyleValue | null)[],
+    widths: readonly (StyleValue | null)[] | undefined,
+    preview: GephiPreview,
+): boolean[] | null {
+    const centers = gephiCenters(snapshot);
+    if (centers.includes(null)) {
+        return null;
+    }
+    const f = Math.fround;
+    const grid = preview.num("node.label.overlapGridSize");
+    const proportional = preview.on("node.label.proportinalSize");
+    const base = f(preview.font("node").size * preview.num("node.label.scale"));
+    const nodeSizes = centers.map((_, i) => {
+        const w = widths?.[i];
+        return f((typeof w === "number" ? w : GEPHI_NODE_WIDTH) / 2);
+    });
+    const sizes = nodeSizes.map((nodeSize) =>
+        proportional ? f(f(base * nodeSize) * f(0.05)) : f(base * f(1 + f(nodeSize * f(0.00001)))),
+    );
+    // Gephi's label items come largest node first (file order among equals; measured on six corpus files)
+    const items = sizes.map((_, i) => i).sort((a, b) => nodeSizes[b] - nodeSizes[a]);
+    // Font.deriveFont(size).getSize() rounds; the cache keeps the last font of each whole size
+    const cached = new Map<number, number>();
+    items.forEach((i) => cached.set(Math.round(sizes[i]), sizes[i]));
+    // NodeItem Y is the file's y turned over
+    const at = centers.map((c) => [c?.[0] ?? 0, -(c?.[1] ?? 0)] as const);
+    // loops, not Math.min(...): a spread of every node overflows the call stack on a large graph
+    let [loX, loY, hiX, hiY] = [Infinity, Infinity, -Infinity, -Infinity];
+    for (const [x, y] of at) {
+        [loX, loY, hiX, hiY] = [Math.min(loX, x), Math.min(loY, y), Math.max(hiX, x), Math.max(hiY, y)];
+    }
+    const [minX, minY] = [loX - grid, loY - grid];
+    const cols = Math.ceil((hiX + grid - minX) / grid);
+    const rows = Math.ceil((hiY + grid - minY) / grid);
+    const taken = new Set<number>();
+    const hidden = labels.map(() => false);
+    const order = [...items].sort((a, b) => sizes[b] - sizes[a]);
+    for (const i of order) {
+        const label = labels[i];
+        if (typeof label !== "string" || label.trim() === "") {
+            continue;
+        }
+        const size = cached.get(Math.round(sizes[i])) ?? sizes[i];
+        const half = [(dialogWidth(label) * size) / 2, (DIALOG_LINE_HEIGHT * size) / 2] as const;
+        const cells = gridCells(
+            { min: [minX, minY], size: grid, cols, rows },
+            [at[i][0] - half[0], at[i][1] - half[1]],
+            [at[i][0] + half[0], at[i][1] + half[1]],
+        );
+        if (cells.some((k) => taken.has(k))) {
+            hidden[i] = true;
+        } else {
+            cells.forEach((k) => taken.add(k));
+        }
+    }
+    return hidden;
+}
+
+/**
+ * The cells of a grid a box covers, as Gephi's label grid counts them (each corner's cell truncated, kept on the grid).
+ * @param grid - the grid: its lowest corner, cell size and cell counts
+ * @param grid.min - its lowest x and y
+ * @param grid.size - its cell size
+ * @param grid.cols - its columns
+ * @param grid.rows - its rows
+ * @param lo - the box's lowest x and y
+ * @param hi - the box's highest x and y
+ * @returns the cell indices, row by row
+ */
+function gridCells(
+    grid: {
+        readonly min: readonly [number, number];
+        readonly size: number;
+        readonly cols: number;
+        readonly rows: number;
+    },
+    lo: readonly [number, number],
+    hi: readonly [number, number],
+): number[] {
+    const cell = (v: number, axis: 0 | 1): number =>
+        Math.min((axis === 0 ? grid.cols : grid.rows) - 1, Math.max(0, Math.trunc((v - grid.min[axis]) / grid.size)));
+    const cells: number[] = [];
+    for (let r = cell(lo[1], 1); r <= cell(hi[1], 1); r++) {
+        for (let c = cell(lo[0], 0); c <= cell(hi[0], 0); c++) {
+            cells.push(r * grid.cols + c);
+        }
+    }
+    return cells;
+}
+
+/** Gephi's `edge.arc-curveness`: a curved edge is an arc of radius its nodes' distance over it (code only, 1.2). */
+const GEPHI_ARC_CURVENESS = 1.2;
+
+/**
+ * Each node's stored center, its viz:position; null without one (graphty-element lays such a node out, where Gephi
+ * would put it at (0, 0)).
+ * @param snapshot - the graph
+ * @returns x and y by node
+ */
+function gephiCenters(snapshot: GraphSnapshot): ([number, number] | null)[] {
+    const position = snapshot.nodes.byRole("position");
+    return Array.from({ length: snapshot.nodeCount }, (_, i) => {
+        const v = position?.isSet(i) === true ? (position.value(i) as ArrayLike<number>) : null;
+        return v === null ? null : [v[0] || 0, v[1] || 0];
+    });
+}
+
+/**
+ * The curved edges Gephi draws no line for: its arc (radius distance / 1.2) is cut back at each end by a chord as long
+ * as that end's node radius (its size), plus `edge.radius`, plus at the target of a directed edge its arrowhead
+ * (`arrow.size` x its thickness); where the two cuts meet or pass each other, or a cut is longer than the arc, the
+ * nodes swallow the edge and no line is drawn (Gephi 0.11 EdgeRenderer.CurvedEdgeRenderer.Helper,
+ * computeTruncateAngle; gexf-cns-wos: 24 edges between overlapping nodes). Its arrowhead is still drawn, unless its
+ * nodes are at one place (ArrowRenderer).
+ * @param snapshot - the graph
+ * @param nodes - the node values (their widths)
+ * @param directed - whether each edge is drawn directed
+ * @param thickness - each edge's drawn thickness
+ * @param preview - the settings
+ * @returns for each edge, "line" when only its line is swallowed, "all" when its nodes are at one place, else null
+ */
+function swallowedEdges(
+    snapshot: GraphSnapshot,
+    nodes: GephiNodeValues,
+    directed: readonly boolean[],
+    thickness: readonly number[],
+    preview: GephiPreview,
+): ("line" | "all" | null)[] {
+    const centers = gephiCenters(snapshot);
+    const edgeRadius = preview.num("edge.radius");
+    const arrowSize = preview.num("arrow.size");
+    const arc = 2 * Math.asin(Math.min(1, GEPHI_ARC_CURVENESS / 2));
+    return Array.from({ length: snapshot.edgeCount }, (_, e) => {
+        const [a, b] = [snapshot.edgeSource(e), snapshot.edgeTarget(e)];
+        const [pa, pb] = [centers[a], centers[b]];
+        if (a === b || pa === null || pb === null) {
+            return null;
+        }
+        const d = Math.hypot(pb[0] - pa[0], pb[1] - pa[1]);
+        if (d === 0) {
+            return "all";
+        }
+        const r = d / GEPHI_ARC_CURVENESS;
+        // the angle a cut of chord length c takes off the arc; past the arc's length, more than the whole arc
+        const cut = (c: number): number =>
+            c >= r * arc ? Infinity : 2 * Math.atan2(c / 2, Math.sqrt(r * r - (c / 2) * (c / 2)));
+        const source = edgeRadius + nodeWidth(nodes, a) / 2;
+        const target = edgeRadius + nodeWidth(nodes, b) / 2 + (directed[e] ? arrowSize * thickness[e] : 0);
+        return cut(source) + cut(target) >= arc ? "line" : null;
+    });
+}
+
+/** How many points a Gephi self-loop's circle is drawn through. */
+const SELF_LOOP_STEPS = 96;
+
+/**
+ * Gephi's self-loops as bends round their node: a circle up and to the right of it, centered `r` right of and `r`
+ * above the node's center, of radius `r` = half the node's size (a radius) plus a third of the loop's stroke, which is
+ * 1.3 times the edge's weight (gephi PreviewPlugin EdgeRenderer, SelfLoopEdgeRenderer; measured on the GEXF specimen
+ * sheets and gexf-graphology-rio: r = 0.5435 x the drawn radius + 0.33 x the stroke). The circle runs from the side
+ * facing the node all the way round; its part inside the node is not drawn.
+ * @param snapshot - the graph
+ * @param thickness - each edge's drawn thickness
+ * @param hidden - whether each edge is not drawn
+ * @returns each loop's bends, as fractions of its node's half size; null for any other edge
+ */
+function selfLoopBends(
+    snapshot: GraphSnapshot,
+    thickness: readonly number[],
+    hidden: readonly boolean[],
+): (StyleValue | null)[] {
+    const sizes = vizColumn(snapshot, "node", "size");
+    const sizeOf = (n: number): number => {
+        const v = sizes === null ? null : Number(plainCell(snapshot.nodes.value(sizes, n)));
+        return v !== null && Number.isFinite(v) && v > 0 ? v : GEPHI_NODE_WIDTH / 2;
+    };
+    const fraction = (v: number): string => String(Math.round(v * 1e4) / 1e4);
+    return Array.from({ length: snapshot.edgeCount }, (_, e) => {
+        const n = snapshot.edgeSource(e);
+        if (n !== snapshot.edgeTarget(e) || hidden[e]) {
+            return null;
+        }
+        const size = sizeOf(n);
+        const r = (0.5 * size + 0.33 * SELF_LOOP_THICKNESS * thickness[e]) / size;
+        const points: string[] = [];
+        for (let k = 0; k <= SELF_LOOP_STEPS; k++) {
+            // from the point facing the node's center (225 degrees), clockwise all the way round
+            const a = (5 * Math.PI) / 4 - (2 * Math.PI * k) / SELF_LOOP_STEPS;
+            points.push(`${fraction(r + r * Math.cos(a))},${fraction(r + r * Math.sin(a))}`);
+        }
+        return points.join(" ");
+    });
+}
+
+/**
+ * The edge rules: arrows, thickness, the edges not drawn, color and opacity, curves and labels.
+ * @param edge - the edge rules, changed in place
+ * @param snapshot - the graph
+ * @param channels - each node's color channels
+ * @param nodes - the node values (their widths)
+ * @param edges - each edge's own color and width
+ * @param gexf - the GEXF drawing, or undefined
+ * @param preview - the settings
+ */
+function edgeRules(
+    edge: GephiTargetRules,
+    snapshot: GraphSnapshot,
+    channels: readonly number[][],
+    nodes: GephiNodeValues,
+    edges: GephiEdgeValues,
+    gexf: GephiDrawing | undefined,
+    preview: GephiPreview,
+): void {
+    const drawn = gephiEdges(snapshot, gexf !== undefined);
+    const arrowSize = preview.num("arrow.size");
+    if (drawn.directed.some(Boolean) && arrowSize > 0) {
+        edge.columns.set(
             DIRECTED_KEY,
-            directed.map((d) => (d ? true : null)),
+            drawn.directed.map((d) => (d ? true : null)),
         );
-        rules.push({
+        // arrow.size scales the arrowhead from its default 3 (gexf-specimen-arrows-p2); 0 draws none (-p3)
+        edge.rules.push({
             id: "edge.tool.arrow",
             target: "edge",
             role: "group",
             origin: "tool",
             where: { has: { style: DIRECTED_KEY } },
-            set: { targetArrow: "triangle" },
+            set: { targetArrow: "triangle", ...(arrowSize === 3 ? {} : { arrowSize: arrowSize / 3 }) },
         });
     }
-    // Preview draws an edge in the mean of its two nodes' colors. graphty-element cannot bind an edge's color to its
-    // nodes' drawn colors yet, so the color is frozen here; replace this column with that binding once the element
-    // has it (tracking issue "graphty-element: bind an edge's color to its source node's drawn color").
-    const fill = (i: number): StyleValue => node.fill?.[i] ?? GEPHI_NODE_FILL;
-    const mixed = withoutOwn(edge.color, snapshot.edgeCount, (e) =>
-        mix(fill(snapshot.edgeSource(e)), fill(snapshot.edgeTarget(e))),
+    // Gephi draws an edge as thick as its weight (gephiEdges(): merged and shifted); a width of its own is the file's
+    const hidden = preview.on("edge.show") ? drawn.hidden : drawn.hidden.map(() => true);
+    const thickness = edgeThickness(
+        drawn.weight,
+        hidden.map((h) => !h),
+        preview,
     );
-    const uncolored = mixed.filter((v) => v !== null).length;
-    budget.spend("edge", snapshot.edgeCount);
-    // Gephi draws an edge as thick as its weight (1 for an edge with none); a width of its own is the file's
-    // The weights come from the snapshot's own weights (the role column exists only when some edge has none), read
-    // as the shortest decimal of their dtype. A weight of 0 or below is drawn 1 wide, so the edge stays visible.
-    // An undirected edge in a directed graph is one edge in the file and two halves here: both take the first's.
-    const first = firstHalf(snapshot);
-    const weights = explicitWeights(snapshot);
-    const weightWidth = withoutOwn(edge.width, snapshot.edgeCount, (e) => {
-        const w = Number(weights.text(first(e)) ?? 1);
-        return Number.isFinite(w) && w > 0 ? w : 1;
+    perElementDefault(
+        edge,
+        "edge",
+        WEIGHT_WIDTH,
+        // Gephi's self-loop is 1.3 times as thick (measured: weight 1 draws 1.3, 3.25 draws 4.225)
+        withoutOwn(edges.width, snapshot.edgeCount, (e) =>
+            snapshot.edgeSource(e) === snapshot.edgeTarget(e) ? SELF_LOOP_THICKNESS * thickness[e] : thickness[e],
+        ),
+        "EDGE_WEIGHT",
+    );
+    perElementDefault(edge, "edge", ["bends", "self-loop"], selfLoopBends(snapshot, thickness, hidden), "NODE_SIZE");
+    // a curved edge its nodes (and its arrowhead) swallow draws no line; its arrowhead is still drawn
+    const swallowed = preview.on("edge.curved")
+        ? swallowedEdges(snapshot, nodes, drawn.directed, thickness, preview)
+        : hidden.map(() => null);
+    // the edges Gephi does not draw: one of another direction than the graph's, one merged into a parallel edge, or a
+    // swallowed one with no arrowhead to keep
+    hidden.forEach((h, e) => {
+        const arrow = drawn.directed[e] && arrowSize > 0 && swallowed[e] === "line";
+        hidden[e] = h || (swallowed[e] !== null && !arrow);
     });
-    const unsized = weightWidth.filter((v) => v !== null).length;
-    if (unsized > 0) {
-        columns.set(WEIGHT_WIDTH_KEY, weightWidth);
-        rules.push({
-            id: "edge.tool.weight-width",
+    if (hidden.some(Boolean)) {
+        edge.columns.set(
+            HIDDEN_KEY,
+            hidden.map((h) => (h ? true : null)),
+        );
+        edge.rules.push({
+            id: "edge.tool.gephi-hidden",
             target: "edge",
-            role: "passthrough",
+            role: "group",
             origin: "tool",
-            where: { has: { style: WEIGHT_WIDTH_KEY } },
-            map: { width: { kind: "passthrough", by: { style: WEIGHT_WIDTH_KEY } } },
-            facts: { elements: unsized, reason: "EDGE_WEIGHT" },
+            where: { has: { style: HIDDEN_KEY } },
+            set: { visible: false },
         });
     }
-    if (uncolored > 0) {
-        columns.set(MIXED_COLOR_KEY, mixed);
-        rules.push({
-            id: "edge.tool.mixed-color",
-            target: "edge",
-            role: "passthrough",
-            origin: "tool",
-            where: { has: { style: MIXED_COLOR_KEY } },
-            map: { color: { kind: "passthrough", by: { style: MIXED_COLOR_KEY } } },
-            facts: { elements: uncolored, reason: "END_NODES_COLOR" },
-        });
+    const colors = edgeColors(snapshot, channels, gexf, preview);
+    perElementDefault(
+        edge,
+        "edge",
+        ["color", MIXED_COLOR_KEY],
+        withoutOwn(edges.color, snapshot.edgeCount, (e) => hexOf(colors[e])),
+        "END_NODE_COLORS",
+    );
+    perElementDefault(
+        edge,
+        "edge",
+        ["opacity", "end-opacity"],
+        withoutOwn(edges.color, snapshot.edgeCount, (e) => colors[e][3] / 255).map((v, e) => {
+            // a swallowed edge Gephi draws only the arrowhead of draws no line
+            if (swallowed[e] !== null && !hidden[e]) {
+                return 0;
+            }
+            return v === 1 ? null : v;
+        }),
+        "END_NODE_COLORS",
+    );
+    everyElement(edge, "edge", "preview-curve", preview.on("edge.curved") ? {} : { curved: false });
+    // Gephi's `edge.radius` leaves that much empty between each node and its edges' ends, arrowheads too
+    const nodeGap = preview.num("edge.radius");
+    everyElement(edge, "edge", "preview-radius", nodeGap > 0 ? { nodeGap } : {});
+    edgeLabelRules(edge, colors, gexf, preview);
+}
+
+/**
+ * Each edge's color and alpha (0..255) under `edge.color` and `edge.opacity`: MIXED (the default) is each channel,
+ * alpha too, the truncated mean of the two end nodes'; `source` and `target` are that node's; `original` is the edge's
+ * own viz color, black without one; `#rrggbb` is that color, opaque (`gexf-specimen-edges-lines-p3` .. `-p7`).
+ * graphty-element cannot bind an edge's color to its nodes' drawn colors, so the color is frozen here.
+ * @param snapshot - the graph
+ * @param channels - each node's color channels
+ * @param gexf - the GEXF drawing, or undefined
+ * @param preview - the settings
+ * @returns each edge's r, g, b and alpha
+ */
+function edgeColors(
+    snapshot: GraphSnapshot,
+    channels: readonly number[][],
+    gexf: GephiDrawing | undefined,
+    preview: GephiPreview,
+): number[][] {
+    const mode = preview.text("edge.color");
+    const factor = preview.num("edge.opacity") / 100;
+    const own = (e: number): number[] => {
+        const c = gexf?.original?.color?.[e];
+        const a = gexf?.original?.opacity?.[e];
+        return nodeChannels(typeof c === "string" ? c : GEPHI_NODE_FILL, typeof a === "number" ? a : null);
+    };
+    const custom = dependantColor(mode, [0, 0, 0]);
+    return Array.from({ length: snapshot.edgeCount }, (_, e) => {
+        const s = channels[snapshot.edgeSource(e)];
+        const t = channels[snapshot.edgeTarget(e)];
+        let c: number[];
+        if (mode === "source") {
+            c = [...s];
+        } else if (mode === "target") {
+            c = [...t];
+        } else if (mode === "original") {
+            c = own(e);
+        } else if (mode.startsWith("#") && custom !== null) {
+            c = [...custom, 255];
+        } else {
+            c = s.map((v, k) => Math.floor((v + t[k]) / 2));
+        }
+        return factor === 1 ? c : [c[0], c[1], c[2], c[3] * factor];
+    });
+}
+
+/**
+ * The edge label rules of `edge.label.show`: the font's size (not in proportion to anything), color, outline and
+ * font (`gexf-specimen-edge-labels-p2` .. `-p15`).
+ * @param edge - the edge rules, changed in place
+ * @param colors - each edge's color and alpha
+ * @param gexf - the GEXF drawing, or undefined
+ * @param preview - the settings
+ */
+function edgeLabelRules(
+    edge: GephiTargetRules,
+    colors: readonly number[][],
+    gexf: GephiDrawing | undefined,
+    preview: GephiPreview,
+): void {
+    if (gexf?.edgeLabels === undefined || !preview.on("edge.label.show")) {
+        return;
+    }
+    const font = preview.font("edge");
+    const color = preview.text("edge.label.color");
+    if (color !== "original") {
+        perElementDefault(
+            edge,
+            "edge",
+            ["labelColor", "preview-label-color"],
+            colors.map((c) => hexOf(dependantColor(color, c) ?? [0, 0, 0])),
+            "EDGE_LABEL_COLOR",
+        );
     }
-    return { rules, columns };
+    labelOutline(
+        edge,
+        "edge",
+        colors,
+        colors.map(() => font.size),
+        preview,
+    );
+    // Gephi centers an edge label on its line's middle (gexf-specimen-edge-labels-p2: 0.04 of the font off it)
+    everyElement(edge, "edge", "preview-label", {
+        labelSize: font.size,
+        labelPosition: "center",
+        ...fontValues(font, preview.on("edge.label.customFont")),
+    });
 }
 
 /**
@@ -506,24 +1310,6 @@ function gephiMix(a: string, b: string): string {
     return `#${out.toString(16).padStart(6, "0")}`;
 }
 
-/**
- * Preview's "darker" border color: each channel times 0.498, rounded (`ColorUtils.java` lines 22-34).
- * @param c - the fill, `#rrggbb`
- * @returns the border color
- */
-function gephiDarker(c: string): string {
-    const x = Number.parseInt(c.slice(1), 16);
-    let out = 0;
-    for (const shift of [16, 8, 0]) {
-        out |= Math.min(255, Math.round(((x >> shift) & 255) * GEPHI_BORDER_DARKEN)) << shift;
-    }
-    return `#${out.toString(16).padStart(6, "0")}`;
-}
-
-const mix = (a: StyleValue, b: StyleValue): StyleValue => gephiMix(String(a), String(b));
-const darker = (c: StyleValue): StyleValue => gephiDarker(String(c));
-const round6 = (x: number): number => Math.round(x * 1e6) / 1e6;
-
 /**
  * The edge whose source Gephi draws for each edge: an undirected edge in a directed graph is one edge in the file
  * and two halves here, and the second half takes the first half's.
@@ -557,10 +1343,10 @@ function withoutOwn(
 }
 
 /**
- * The styles of a GEXF file: each element's viz values as Gephi draws them, with Gephi Preview's defaults beneath
- * (black size-10 discs with a darker border, curved edges, an arrow at the target of every directed edge, the mixed
- * color of its nodes on every edge without a color of its own) and each node's label (see gephiRules()); plus a
- * `graphty.styles` block the file holds in `<meta>`.
+ * The styles of a GEXF file as Gephi's preview draws it: each node's label, fill and size, Gephi's defaults beneath
+ * (black size-10 discs, curved edges) and its per-element defaults (gephiRules()); the viz values Gephi does not draw
+ * are left out (withoutUndrawn()); plus a `graphty.styles` block the file holds in `<meta>`, whose file keeps every
+ * value.
  * @param snapshot - the graph the import built
  * @param context - the work budget and the block text the import kept
  * @returns the styles
@@ -569,18 +1355,47 @@ export function gexfStyles(snapshot: GraphSnapshot, context: StyleReadContext):
     const notes = new StyleNotes();
     const node = vizValues(snapshot, "node", notes, context);
     const edge = vizValues(snapshot, "edge", notes, context);
-    const block = typeof context.kept === "string" ? context.kept : null;
-    if (block !== null) {
+    const { block, preview } = keptOf(context.kept);
+    const nodeOpacity = node.fillOpacity;
+    const original = { color: edge.color, opacity: edge.opacity };
+    if (block === null) {
+        withoutUndrawn(node, edge);
+    } else {
         exactFromBlock(snapshot, block, node, edge);
     }
-    const gephi = gephiRules(snapshot, node, edge, context.budget);
+    const labels = drawnLabels(node.label, preview, "node", block !== null);
+    const overlapHidden =
+        block === null && labels !== undefined && preview.on("node.label.avoidOverlap")
+            ? gephiOverlapHidden(snapshot, labels, node.width, preview)
+            : null;
+    overlapHidden?.forEach((hide, i) => {
+        if (hide && labels !== undefined) {
+            labels[i] = null;
+        }
+    });
+    if (labels === undefined) {
+        delete node.label;
+    } else {
+        node.label = labels;
+    }
+    const edgeLabels = drawnLabels(edgeLabelValues(snapshot), preview, "edge", block !== null);
+    if (edgeLabels !== undefined) {
+        edge.label = edgeLabels;
+    }
+    const rules = gephiRules(
+        snapshot,
+        { fill: node.fill, fillOpacity: nodeOpacity, width: node.width },
+        { color: edge.color, width: edge.width },
+        context.budget,
+        { preview, original, edgeLabels, overlapSettled: overlapHidden !== null },
+    );
     return {
         canonical: true,
         dialect: "gexf",
         tool: "gephi",
         units: "relative",
-        node: { values: node, ...gephi.node },
-        edge: { values: edge, ...gephi.edge },
+        node: { values: node, ...rules.node },
+        edge: { values: edge, ...rules.edge },
         notes: notes.list(),
         opacityInColor: true,
         block,
@@ -591,6 +1406,61 @@ export function gexfStyles(snapshot: GraphSnapshot, context: StyleReadContext):
     };
 }
 
+/**
+ * What the import kept for the styles: the `graphty.styles` block, and the Preview settings of the `gephiPreview`
+ * option.
+ * @param kept - the kept value: the block's text, or `{ block, gephiPreview }`
+ * @returns the block (null without one) and the Preview settings
+ */
+function keptOf(kept: unknown): { readonly block: string | null; readonly preview: GephiPreview } {
+    if (typeof kept === "string") {
+        return { block: kept, preview: new GephiPreview() };
+    }
+    if (typeof kept === "object" && kept !== null) {
+        const { block, gephiPreview } = kept as { block?: unknown; gephiPreview?: Record<string, string> };
+        return { block: typeof block === "string" ? block : null, preview: new GephiPreview(gephiPreview) };
+    }
+    return { block: null, preview: new GephiPreview() };
+}
+
+/**
+ * Each edge's `label` attribute.
+ * @param snapshot - the graph
+ * @returns the labels, or undefined when no edge has one
+ */
+function edgeLabelValues(snapshot: GraphSnapshot): (StyleValue | null)[] | undefined {
+    const col = snapshot.edges.byRole("label");
+    if (col === null) {
+        return undefined;
+    }
+    return Array.from({ length: snapshot.edgeCount }, (_, e) => {
+        const v = plainCell(col.value(e));
+        return typeof v === "string" && v.length > 0 ? v : null;
+    });
+}
+
+/**
+ * Leaves out the viz values Gephi does not draw, for a file graphty did not write: its preview draws every node an
+ * opaque disc (a node's alpha only tints its edges) and every edge a solid line in its end nodes' mixed color, as
+ * thick as its weight (graphstore keeps no edge thickness or shape, and EdgeColor MIXED ignores an edge's color).
+ * Every `viz:shape` is drawn a disc, an `image` shape too: Gephi Toolkit 0.11.3 draws no picture
+ * (`gexf-specimen-images-charts`: a data: URI and a web URL both drawn as the node's colored disc).
+ * @param node - the node values, changed in place
+ * @param edge - the edge values, changed in place
+ */
+function withoutUndrawn(
+    node: Record<string, (StyleValue | null)[]>,
+    edge: Record<string, (StyleValue | null)[]>,
+): void {
+    delete node.shape;
+    delete node.image;
+    delete node.fillOpacity;
+    delete edge.color;
+    delete edge.opacity;
+    delete edge.width;
+    delete edge.lineStyle;
+}
+
 /**
  * For a file graphty wrote: where a viz value is the nearest GEXF value of what the `graphty.styles` block gives (a
  * hexagon written as a disc, a width and height written as one size), the block's exact value is the truth, so a
@@ -607,49 +1477,33 @@ function exactFromBlock(
     node: Record<string, (StyleValue | null)[]>,
     edge: Record<string, (StyleValue | null)[]>,
 ): void {
-    const parsed = parseStyleBlock(text, styleFingerprint(snapshot));
-    const ex = parsed.ok ? blockStyles(parsed.block, snapshot, "gexf") : null;
-    if (ex === null) {
-        return;
-    }
-    const exact = (
-        values: Record<string, (StyleValue | null)[]>,
-        target: StyleTarget,
-        property: string,
-        written: (v: StyleValue, i: number) => StyleValue | null,
-    ): void => {
-        const native = values[property];
-        if (native === undefined) {
-            return;
-        }
-        const want = resolveStyles(ex, target, property as never, snapshot);
-        for (let i = 0; i < native.length; i++) {
-            const w = want[i];
-            // a size is written from the width and the height together: one the block leaves unset reads back too
-            const writable = w !== null || property === "width" || property === "height";
-            if (writable && native[i] !== w && native[i] !== null && native[i] === written(w as StyleValue, i)) {
-                native[i] = w;
-            }
-        }
-    };
-    const width = resolveStyles(ex, "node", "width", snapshot);
-    const height = resolveStyles(ex, "node", "height", snapshot);
-    const size = (i: number): StyleValue | null => {
-        const w = width[i];
-        const h = height[i];
-        return typeof w === "number" && typeof h === "number" ? Math.max(w, h) : (w ?? h);
-    };
-    const read = new Map([
+    const shapeRead = new Map([
         ["disc", "ellipse"],
         ["square", "rectangle"],
     ]);
-    exact(node, "node", "shape", (v) => {
-        const written = gexfNodeShape(String(v)).value;
-        return read.get(written) ?? written;
-    });
-    exact(edge, "edge", "lineStyle", (v) => gexfEdgeShape(String(v)).value);
-    exact(node, "node", "width", (_v, i) => size(i));
-    exact(node, "node", "height", (_v, i) => size(i));
+    const size = (want: ElementValues): StyleValue | null => {
+        const w = want("width");
+        const h = want("height");
+        return typeof w === "number" && typeof h === "number" ? Math.max(w, h) : (w ?? h);
+    };
+    // what the viz element written for an element's block values reads back as
+    const written: Readonly<Record<string, (want: ElementValues) => StyleValue | null>> = {
+        shape: (want) => {
+            const { value } = gexfNodeShape(String(want("shape")));
+            return shapeRead.get(value) ?? value;
+        },
+        width: size,
+        height: size,
+        lineStyle: (want) => gexfEdgeShape(String(want("lineStyle"))).value,
+    };
+    takeFromBlock(snapshot, text, "gexf", (target) => ({
+        values: target === "node" ? node : edge,
+        properties: target === "node" ? ["shape", "width", "height"] : ["lineStyle"],
+        readBack: (_i, want) => (property) => written[property](want),
+        // a size is written from the width and the height together: one the block leaves unset reads back too
+        take: (property, wanted, native) =>
+            native !== null && (wanted !== null || property === "width" || property === "height"),
+    }));
 }
 
 // ============================================================ writing
@@ -718,7 +1572,7 @@ export function gexfStyledExport(
             const s = nodeShapes[i];
             return (
                 colorElement(fill[i], fillOpacity[i], indent) +
-                (size === null ? "" : `${indent}<viz:size value="${String(size)}"/>\n`) +
+                (size === null ? "" : `${indent}<viz:size value="${String(size / 2)}"/>\n`) +
                 shapeElement(s, s === "image" ? String(image[i]) : null, indent)
             );
         },