@graphty/graph-io 0.3.47 → 0.3.49

package/src/styles/index.ts

@@ -11,7 +11,9 @@ export {
     type ArrowAnnotation,
     type FileAnnotations,
     type GraphAnnotation,
+    type ImageAnnotation,
     readAnnotations,
+    readImageAnnotations,
     type ShapeAnnotation,
     type TextAnnotation,
 } from "./annotations.js";
@@ -29,6 +31,7 @@ export {
 } from "./cyjs/index.js";
 export {
     TOOL_DEFAULTS,
+    type ToolArrowhead,
     type ToolDefaults,
     toolDefaults,
     type ToolDefaultValue,
@@ -46,6 +49,7 @@ export {
 } from "./io/index.js";
 export {
     featuresOf,
+    matchPredicate,
     MAX_STYLE_RULES,
     type PlanOptions,
     planStyles,
@@ -53,5 +57,6 @@ export {
     styleFingerprint,
     type StyleValues,
 } from "./plan/index.js";
+export { isStyleSlotColumn } from "./slots.js";
 export type * from "./types.js";
 export { isStyleValue, STYLE_ENUMS, STYLE_PROPERTIES, type StyleValueKind } from "./vocabulary.js";

package/src/styles/internal.ts

@@ -13,5 +13,6 @@ export * from "./defaults.js";
 export * from "./io/index.js";
 export * from "./notes.js";
 export * from "./plan/index.js";
+export * from "./slots.js";
 export type * from "./types.js";
 export * from "./vocabulary.js";

package/src/styles/io/block.ts

@@ -727,6 +727,15 @@ function predicate(v: unknown): Predicate {
     return o as Predicate;
 }
 
+/**
+ * A positive finite number.
+ * @param v - the parsed value
+ * @returns the number
+ */
+function positive(v: unknown): number {
+    return typeof v === "number" && Number.isFinite(v) && v > 0 ? v : invalid();
+}
+
 /**
  * A mapping. A mapping of a kind this version does not know is kept and gives no value.
  * @param v - the parsed mapping
@@ -760,6 +769,7 @@ function mapping(v: unknown): Mapping {
                         above: scalar(q.above),
                     };
                 }),
+                ...(o.step === undefined ? {} : { step: positive(o.step) }),
             };
         default:
             return { ...o, kind: name(o.kind), by } as unknown as Mapping;

package/src/styles/io/generic.ts

@@ -9,10 +9,18 @@ import type { GraphSnapshot } from "@graphty/graph-format";
 
 import { keptForStyles } from "../../common/report.js";
 import type { GraphImporter, ImportReport } from "../../types.js";
+import { readAnnotations, readImageAnnotations } from "../annotations.js";
 import { StyleBudget } from "../budget.js";
 import { canonColor, colorOpacity } from "../canon/color.js";
 import { canonEnum, type StyleEnumKind } from "../canon/enums.js";
-import { canonBoolean, canonNumber, canonOpacity, DOT_POINTS_PER_INCH, styleLengthUnit } from "../canon/number.js";
+import {
+    canonBoolean,
+    canonNumber,
+    canonOpacity,
+    canonSigned,
+    DOT_POINTS_PER_INCH,
+    styleLengthUnit,
+} from "../canon/number.js";
 import type { CanonSite } from "../canon/site.js";
 import { canonText } from "../canon/text.js";
 import { STYLE_ISSUE } from "../codes.js";
@@ -27,6 +35,7 @@ import type {
     ReaderOutput,
     StyleColumn,
     StyleDialect,
+    StyleFingerprint,
     StyleNote,
     StyleProperty,
     StyleTarget,
@@ -64,7 +73,17 @@ export interface ExtractStylesOptions extends StyleImportOptions {
 }
 
 const TARGETS: readonly StyleTarget[] = ["node", "edge"];
-const ENUM_KINDS: ReadonlySet<string> = new Set(["shape", "borderStyle", "lineStyle", "arrow", "weight", "position"]);
+const ENUM_KINDS: ReadonlySet<string> = new Set([
+    "shape",
+    "borderStyle",
+    "lineStyle",
+    "arrow",
+    "arrowSide",
+    "weight",
+    "position",
+    "labelFit",
+    "borderPosition",
+]);
 
 /** What the readers here produce before planning: canonical values and the data columns they came from. */
 interface StyleTruth {
@@ -104,29 +123,18 @@ export function extractStyles(
     const signal = options.signal ?? undefined;
     const notes = new StyleNotes();
     const budget = options.budget ?? new StyleBudget();
+    // pictures are read by readImageAnnotations()
+    const pictures = readImageAnnotations(snapshot).length > 0;
+    for (const kind of readAnnotations(snapshot).skipped) {
+        if (!(pictures && kind === "ImageAnnotation")) {
+            notes.add(STYLE_ISSUE.ANNOTATION_SKIPPED, "graph", "annotations", { sample: kind });
+        }
+    }
     const canonical = readStyleValues(importer, snapshot, report, { notes, budget, signal });
     const fingerprint = styleFingerprint(snapshot);
-    const blockText = canonical?.block ?? graphValue(snapshot, STYLE_BLOCK_NAME);
-    if (blockText !== undefined) {
-        const parsed = parseStyleBlock(blockText, fingerprint);
-        if (parsed.ok) {
-            const truth = canonical === null ? {} : { node: canonical.node.values, edge: canonical.edge.values };
-            const fromBlock = blockStyles(
-                parsed.block,
-                snapshot,
-                importer.format,
-                truth,
-                canonical?.notes ?? [],
-                canonical?.tool ?? null,
-                canonical?.opacityInColor === true,
-            );
-            if (fromBlock !== null) {
-                return fromBlock;
-            }
-            notes.add(STYLE_ISSUE.BLOCK_IGNORED, null, null, { sample: "INVALID" });
-        } else {
-            notes.add(STYLE_ISSUE.BLOCK_IGNORED, null, null, { sample: parsed.reason });
-        }
+    const fromBlock = stylesFromBlock(importer, snapshot, canonical, notes, fingerprint);
+    if (fromBlock !== null) {
+        return fromBlock;
     }
     if (canonical === null) {
         const list = notes.list();
@@ -163,6 +171,52 @@ export function extractStyles(
     return { ...planned, styles: { ...planned.styles, notes: [...canonical.notes, ...planned.styles.notes] } };
 }
 
+/**
+ * The styles a file's `graphty.styles` block gives, with the importer's values as the truth; a block that does not
+ * parse or describes another graph is noted as ignored.
+ * @param importer - the importer that read the file
+ * @param snapshot - the graph it built
+ * @param canonical - what the importer read, or null
+ * @param notes - the notes so far; an ignored block is noted here
+ * @param fingerprint - the graph's style fingerprint
+ * @returns the styles, or null when the file has no usable block
+ */
+function stylesFromBlock(
+    importer: GraphImporter,
+    snapshot: GraphSnapshot,
+    canonical: ReturnType<typeof readStyleValues>,
+    notes: StyleNotes,
+    fingerprint: StyleFingerprint,
+): ExtractedStyles | null {
+    const blockText = canonical?.block ?? graphValue(snapshot, STYLE_BLOCK_NAME);
+    if (blockText === undefined) {
+        return null;
+    }
+    const parsed = parseStyleBlock(blockText, fingerprint);
+    if (!parsed.ok) {
+        notes.add(STYLE_ISSUE.BLOCK_IGNORED, null, null, { sample: parsed.reason });
+        return null;
+    }
+    const truth = canonical === null ? {} : { node: canonical.node.values, edge: canonical.edge.values };
+    const fromBlock = blockStyles(
+        parsed.block,
+        snapshot,
+        importer.format,
+        truth,
+        canonical?.notes ?? [],
+        canonical?.tool ?? null,
+        canonical?.opacityInColor === true,
+    );
+    if (fromBlock === null) {
+        notes.add(STYLE_ISSUE.BLOCK_IGNORED, null, null, { sample: "INVALID" });
+        return null;
+    }
+    const skipped = notes.list();
+    return skipped.length === 0
+        ? fromBlock
+        : { ...fromBlock, styles: { ...fromBlock.styles, notes: [...fromBlock.styles.notes, ...skipped] } };
+}
+
 /**
  * What a file's styles are before planning: each element's canonical value per property, as the importer's own
  * `styles()` gives them (the simple path canonicalized) or, for an importer without one, as the generic reader reads
@@ -553,6 +607,8 @@ function canonValue(
                 site,
                 dialect === "graphviz" && (property === "width" || property === "height") ? DOT_POINTS_PER_INCH : 1,
             );
+        case "signed":
+            return canonSigned(raw, site);
         case "opacity":
             return canonOpacity(raw, dialect, site);
         case "boolean":

package/src/styles/io/round-trip.ts

@@ -0,0 +1,202 @@
+/**
+ * The round-trip repair every styled format shares: for a file graphty wrote, a value read from the format's own
+ * drawing keys that is only what graphty's writer writes for the `graphty.styles` block's exact value (a pentagon
+ * written as a hexagon, an opacity rounded to 255 steps) is read as the block's value, so a re-import gives back the
+ * same rules. A value another program changed since stays the truth. Each format passes what its writer writes for an
+ * element, read back the way its reader reads it.
+ */
+
+import type { GraphSnapshot } from "@graphty/graph-format";
+
+import { styleFingerprint } from "../plan/features.js";
+import { resolveStyles } from "../plan/resolve.js";
+import type { ExtractedStyles, StyleColumn, StyleProperty, StyleTarget, StyleValue } from "../types.js";
+import { blockStyles, parseStyleBlock } from "./block.js";
+
+/** One element's value of a property, null when it has none. */
+export type ElementValues = (property: string) => StyleValue | null;
+
+/** The block's values of a property, one per element. */
+type BlockValues = (target: StyleTarget, property: string) => readonly (StyleValue | null)[];
+
+/**
+ * The values a `graphty.styles` block gives every element, worked out once per property.
+ * @param snapshot - the graph
+ * @param ex - the block's styles
+ * @returns the block's values
+ */
+function blockValues(snapshot: GraphSnapshot, ex: ExtractedStyles): BlockValues {
+    const cache = new Map<string, readonly (StyleValue | null)[]>();
+    return (target, property) => {
+        const key = `${target} ${property}`;
+        let held = cache.get(key);
+        if (held === undefined) {
+            held = resolveStyles(ex, target, property as StyleProperty, snapshot);
+            cache.set(key, held);
+        }
+        return held;
+    };
+}
+
+/**
+ * Each element's values of the properties a writer writes, as a getter per element; any other property reads as null.
+ * @param picture - each element's value of a property
+ * @param target - nodes or edges
+ * @param properties - the properties the writer writes
+ * @returns the getter
+ */
+export function elementValues(
+    picture: BlockValues,
+    target: StyleTarget,
+    properties: readonly string[],
+): (i: number) => ElementValues {
+    const columns = new Map<string, readonly (StyleValue | null)[]>();
+    for (const p of properties) {
+        columns.set(p, picture(target, p));
+    }
+    return (i) => (property) => columns.get(property)?.[i] ?? null;
+}
+
+/** One target's round trip, as a format describes it. */
+interface RoundTrip {
+    /** The values the reader read, per property; a property whose values change gets a new array. */
+    readonly values: Partial<Record<string, StyleColumn>>;
+    /** The properties compared with the block's. */
+    readonly properties: Iterable<string>;
+    /** The properties the writer is given the block's values of; any other reads as null. Default: every one. */
+    readonly writes?: readonly string[];
+    /**
+     * An element's block values written the way the writer writes them and read back the way the reader reads them.
+     * @param i - the element
+     * @param want - the element's block values
+     * @returns the values read back, or null when the element is not compared
+     */
+    readBack(i: number, want: ElementValues): ElementValues | null;
+    /**
+     * Whether a property's value of an element may be taken from the block at all (before comparing). Default: always.
+     * @param property - the property
+     * @param wanted - the block's value
+     * @param native - the value read
+     */
+    take?(property: string, wanted: StyleValue | null, native: StyleValue | null): boolean;
+}
+
+/**
+ * Wherever a value read is not the block's but is what the writer writes for the block's value, takes the block's.
+ * @param target - nodes or edges
+ * @param n - the element count
+ * @param block - the block's values
+ * @param trip - the target's round trip; its values change in place
+ */
+function takeBlockValues(target: StyleTarget, n: number, block: BlockValues, trip: RoundTrip): void {
+    const { values } = trip;
+    const get = blockGetter(target, block, trip.writes);
+    const properties = [...trip.properties];
+    const changed = new Map<string, (StyleValue | null)[]>();
+    for (let i = 0; i < n; i++) {
+        const want = get(i);
+        const back = trip.readBack(i, want);
+        if (back === null) {
+            continue;
+        }
+        for (const property of properties) {
+            const w = want(property);
+            if (takes(trip, property, w, values[property]?.[i] ?? null, back)) {
+                columnOf(changed, values, property, n)[i] = w;
+            }
+        }
+    }
+    for (const [property, column] of changed) {
+        values[property] = column;
+    }
+}
+
+/**
+ * Each element's block values, limited to the properties the writer is given when it is given only some.
+ * @param target - nodes or edges
+ * @param block - the block's values
+ * @param writes - the properties the writer is given, or undefined for every one
+ * @returns the element's values, by element
+ */
+function blockGetter(
+    target: StyleTarget,
+    block: BlockValues,
+    writes: readonly string[] | undefined,
+): (i: number) => ElementValues {
+    if (writes !== undefined) {
+        return elementValues(block, target, writes);
+    }
+    return (i) => (p) => block(target, p)[i] ?? null;
+}
+
+/**
+ * Whether the block's value replaces the value read: the format allows it, they differ, and the value read is what the
+ * writer writes for the block's value.
+ * @param trip - the target's round trip
+ * @param property - the property
+ * @param wanted - the block's value
+ * @param native - the value read
+ * @param back - the element's block values written and read back
+ * @returns whether to take the block's value
+ */
+function takes(
+    trip: RoundTrip,
+    property: string,
+    wanted: StyleValue | null,
+    native: StyleValue | null,
+    back: ElementValues,
+): boolean {
+    return trip.take?.(property, wanted, native) !== false && native !== wanted && native === (back(property) ?? null);
+}
+
+/**
+ * The changed copy of a property's values, made on first use.
+ * @param changed - the changed copies so far
+ * @param values - the values read
+ * @param property - the property
+ * @param n - the element count
+ * @returns the property's changed copy
+ */
+function columnOf(
+    changed: Map<string, (StyleValue | null)[]>,
+    values: Partial<Record<string, StyleColumn>>,
+    property: string,
+    n: number,
+): (StyleValue | null)[] {
+    let column = changed.get(property);
+    if (column === undefined) {
+        const own = values[property];
+        column = own === undefined ? new Array<StyleValue | null>(n).fill(null) : [...own];
+        changed.set(property, column);
+    }
+    return column;
+}
+
+/**
+ * For a file graphty wrote: wherever a value read from the format's own keys is not the `graphty.styles` block's
+ * value but is what graphty's writer writes for it, takes the block's value, so a re-import gives back the same rules.
+ * A block that does not parse or describes another graph changes nothing.
+ * @param snapshot - the graph
+ * @param text - the block's text, or null when the file has none
+ * @param format - the format the block was read from
+ * @param trip - each target's round trip, given the block's values and its styles; null leaves the target as read
+ */
+export function takeFromBlock(
+    snapshot: GraphSnapshot,
+    text: string | null,
+    format: string,
+    trip: (target: StyleTarget, block: BlockValues, styles: ExtractedStyles) => RoundTrip | null,
+): void {
+    const parsed = text === null ? null : parseStyleBlock(text, styleFingerprint(snapshot));
+    const ex = parsed?.ok === true ? blockStyles(parsed.block, snapshot, format) : null;
+    if (ex === null) {
+        return;
+    }
+    const block = blockValues(snapshot, ex);
+    for (const target of ["node", "edge"] as const) {
+        const t = trip(target, block, ex);
+        if (t !== null) {
+            takeBlockValues(target, target === "node" ? snapshot.nodeCount : snapshot.edgeCount, block, t);
+        }
+    }
+}

package/src/styles/io/writer.ts

@@ -9,6 +9,7 @@ import type { GraphSnapshot } from "@graphty/graph-format";
 import { agree, plural } from "../../common/plural.js";
 import type { GraphExporter, LossNote } from "../../types.js";
 import { STYLE_ISSUE } from "../codes.js";
+import { toolDefaults } from "../defaults.js";
 import { styleFingerprint } from "../plan/features.js";
 import { canonicalFor, dataCell, degreeValues, plainCell, resolveStyles } from "../plan/resolve.js";
 import type {
@@ -469,6 +470,7 @@ export function isKeptGraphtyProperty(note: LossNote, exporter: GraphExporter):
 
 /**
  * The losses of an export with styles: W_STYLE_NOT_WRITTEN for every property the format does not write natively
+ * that at least one element carries a value of
  * (all of them for an exporter without a `styles` member), and W_STYLE_RULES_NOT_KEPT when the block is not kept.
  * @param extracted - the styles
  * @param exporter - the exporter
@@ -495,7 +497,11 @@ function lossNotes(
                     notes.push(...pairNotes(snapshot, exporter, property, picture("edge", property as StyleProperty)));
                 }
             } else {
-                notes.push(notWrittenNote(target, property, exporter, picture));
+                // a rule whose property no element ends up carrying loses nothing
+                const note = notWrittenNote(target, property, exporter, picture);
+                if (note.count !== 0) {
+                    notes.push(note);
+                }
             }
         }
     }
@@ -516,7 +522,8 @@ function lossNotes(
 }
 
 /**
- * W_STYLE_NOT_WRITTEN for every graph property the format does not write.
+ * W_STYLE_NOT_WRITTEN for every graph property the format does not write, except one whose value is what the program
+ * the format is written for draws anyway (a white background for yEd): nothing is lost there.
  * @param extracted - the styles
  * @param exporter - the exporter
  * @param caps - its style capabilities, or null
@@ -528,8 +535,11 @@ function graphLossNotes(
     caps: StyleWriteCapabilities | null,
 ): LossNote[] {
     const graphWritten = new Set<string>(caps?.graph ?? []);
-    return Object.keys(extracted.styles.graph)
-        .filter((property) => !graphWritten.has(property))
+    const drawn: Readonly<Record<string, { readonly value: unknown } | undefined>> =
+        (caps?.tool === undefined ? null : toolDefaults(caps.tool))?.graph ?? {};
+    return Object.entries(extracted.styles.graph)
+        .filter(([property, value]) => !graphWritten.has(property) && drawn[property]?.value !== value)
+        .map(([property]) => property)
         .map((property) =>
             Object.freeze({
                 code: STYLE_ISSUE.NOT_WRITTEN,

package/src/styles/notes.ts

@@ -27,6 +27,7 @@ const PHRASES: ReadonlyMap<StyleNoteCode, string> = new Map<StyleNoteCode, strin
     ["W_STYLE_EXTRA_LABELS", "elements have more than one label; the first was kept"],
     ["W_STYLE_INHERIT_COLOR", "inherited colors cannot be expressed"],
     ["W_STYLE_NOT_CARRIED", "style properties have no counterpart and were not carried"],
+    ["W_STYLE_ANNOTATION_SKIPPED", "annotations of a kind graph-io does not read were skipped"],
     ["W_STYLE_BAD_MAPPING", "mappings cannot be read"],
     ["W_STYLE_MAPPING_COLUMN_MISSING", "mappings read a column the file does not have"],
     ["W_STYLE_REFERENCE_CYCLE", "style references are circular or too deep"],

package/src/styles/plan/features.ts

@@ -5,6 +5,7 @@
 
 import type { GraphSnapshot } from "@graphty/graph-format";
 
+import { pairFolding } from "../../common/direction.js";
 import type { ColumnRef, Scalar, StyleFeature, StyleFingerprint, StyleTarget } from "../types.js";
 import { dataCell, degreeValues } from "./resolve.js";
 
@@ -17,11 +18,29 @@ const PARENT_COLUMN = "graphty.parent";
 /** An integer column of at least this many values that fills a whole range is an index, not a quantity. */
 const MIN_INDEX = 8;
 
+/**
+ * Whether the snapshot stores some undirected edge as a pair of directed rows.
+ * @param snapshot - the graph
+ * @returns true when an edge row folds into its mate
+ */
+function hasFoldedPairs(snapshot: GraphSnapshot): boolean {
+    const folding = pairFolding(snapshot);
+    if (!folding.expanded) {
+        return false;
+    }
+    for (let e = 0; e < snapshot.edgeCount; e++) {
+        if (folding.folded(e)) {
+            return true;
+        }
+    }
+    return false;
+}
+
 /**
  * The candidate explaining columns of one target: every scalar attribute (the reserved `graphty.*` columns,
  * coordinates and Cytoscape's selection state excepted), the group a node sits in as the style column `group`, and
  * for nodes the degree (and the in- and out-degree of a directed graph) as `{ computed }` references, which follow
- * later edits of the graph.
+ * later edits of the graph; no degree where an undirected edge is stored as a directed pair.
  * @param snapshot - the graph
  * @param target - nodes or edges
  * @returns the features, in column order with the degrees last
@@ -46,7 +65,9 @@ export function featuresOf(snapshot: GraphSnapshot, target: StyleTarget): StyleF
             out.push({ ref: { style: "group" }, values: group });
         }
     }
-    if (target === "node" && n > 0) {
+    // An undirected edge stored as two directed rows (a mixed file's `*Edges`, a GEXF undirected edge in a directed
+    // graph) counts at both ends here and once in a reader that folds the pair, which no explanation may depend on.
+    if (target === "node" && n > 0 && !hasFoldedPairs(snapshot)) {
         const kinds: ("degree" | "indegree" | "outdegree")[] = snapshot.directed
             ? ["degree", "indegree", "outdegree"]
             : ["degree"];

package/src/styles/plan/index.ts

@@ -4,4 +4,4 @@
 
 export { featuresOf, styleFingerprint } from "./features.js";
 export { MAX_STYLE_RULES, type PlanOptions, planStyles, type StyleValues } from "./plan.js";
-export { resolveStyles } from "./resolve.js";
+export { matchPredicate, resolveStyles } from "./resolve.js";

package/src/styles/plan/plan.ts

@@ -8,7 +8,7 @@
 
 import { StyleBudget } from "../budget.js";
 import { STYLE_ISSUE } from "../codes.js";
-import { toolDefaults } from "../defaults.js";
+import { toolDefaults, type ToolDerivedDefault } from "../defaults.js";
 import { StyleNotes } from "../notes.js";
 import type {
     ExtractedStyles,
@@ -52,7 +52,19 @@ export const MAX_STYLE_RULES = 16;
 /** The most candidate features tested per target, fewest distinct values first. */
 const MAX_FEATURES = 64;
 /** Lengths a tool states in its own unit; they are left out when the file's unit differs. */
-const LENGTHS: ReadonlySet<string> = new Set(["width", "height", "borderWidth", "labelSize"]);
+const LENGTHS: ReadonlySet<string> = new Set([
+    "width",
+    "height",
+    "borderWidth",
+    "labelSize",
+    "labelWrapWidth",
+    "labelPaddingX",
+    "labelPaddingY",
+    "labelOffsetX",
+    "labelOffsetY",
+    "fanSpacing",
+    "nodeGap",
+]);
 
 /**
  * What the planner is given: the canonical per-element values a style reader produced, the rules the file declares,
@@ -172,7 +184,7 @@ export function planStyles(values: StyleValues, features: StyleFeatures, options
                 out,
                 allFeatures[target],
                 new Set(options.rawColumns?.[target] ?? []),
-                toolSet,
+                { set: toolSet, derived: defaults?.derived ?? [] },
                 options.signal,
             ),
         );
@@ -506,7 +518,9 @@ function passCandidate(
  * @param out - the reader's output
  * @param features - the candidate features
  * @param rawNames - the data columns the values were read from
- * @param toolSet - the tool's default values, or null
+ * @param tool - the tool's default values (or null) and its defaults that are rules
+ * @param tool.set - the tool's default values, or null
+ * @param tool.derived - the tool's defaults that are rules
  * @param signal - cancels the planning
  * @returns the target's rules, bottom to top
  */
@@ -515,10 +529,11 @@ function planTarget(
     out: ReaderOutput | undefined,
     features: readonly StyleFeature[],
     rawNames: ReadonlySet<string>,
-    toolSet: Record<string, StyleValue> | null,
+    tool: { readonly set: Record<string, StyleValue> | null; readonly derived: readonly ToolDerivedDefault[] },
     signal: AbortSignal | undefined,
 ): StyleRule[] {
     const { target, n } = plan;
+    const toolSet = tool.set;
     for (const [k, v] of out?.columns ?? []) {
         plan.columns.set(k, v);
     }
@@ -536,6 +551,7 @@ function planTarget(
                       set: toolSet,
                   },
               ];
+    toolRule.push(...derivedRules(plan, tool.derived, features, out?.rules ?? [], truth));
     const declared = prepareDeclared(plan, out?.rules ?? [], features);
     const declaredProps = new Set(declared.flatMap(writes));
 
@@ -631,6 +647,50 @@ function planTarget(
     return drafts.map(finish);
 }
 
+/**
+ * The tool's defaults that are rules, for those the planner can state over the graph's own columns: a label from a
+ * column (Cytoscape's `name`, sigma's and vis-network's `label`) on every node that has a value there, when the reader
+ * gives no node a label. A default a reader already states with a tool rule of its own (Graphviz's `\N`, Gephi's
+ * source color), or a property the reader gives values for, is the reader's.
+ * @param plan - the target's state
+ * @param derived - the tool's defaults that are rules
+ * @param features - the candidate features, which hold the data columns' values
+ * @param given - the reader's rules
+ * @param truth - the reader's values per property
+ * @returns the rules, bottom to top
+ */
+function derivedRules(
+    plan: TargetPlan,
+    derived: readonly ToolDerivedDefault[],
+    features: readonly StyleFeature[],
+    given: readonly StyleRule[],
+    truth: ReadonlyMap<string, unknown>,
+): Draft[] {
+    const stated = new Set([...given.filter((r) => r.origin === "tool").flatMap(writes), ...truth.keys()]);
+    const out: Draft[] = [];
+    for (const d of derived) {
+        if (plan.target !== "node" || d.kind !== "labelFromColumn" || stated.has("label")) {
+            continue;
+        }
+        const { column } = d;
+        const feature = features.find((f) => "data" in f.ref && f.ref.data === column);
+        if (feature?.values.some((v) => v !== null && v !== "") !== true) {
+            continue;
+        }
+        stated.add("label");
+        out.push({
+            id: uniqueId(plan, "node.tool.label"),
+            target: "node",
+            role: "passthrough",
+            origin: "tool",
+            where: { has: { data: column } },
+            map: { label: { kind: "passthrough", by: { data: column } } },
+            facts: { reason: "NODE_NAME" },
+        });
+    }
+    return out;
+}
+
 /**
  * The inferred defaults: each property non-null and equal on every element; the others are left to explain. A
  * property a declared rule writes is the declared rule's.
@@ -1009,12 +1069,16 @@ function enforceCap(
         if (cands.length === 0) {
             break;
         }
+        // the tool's defaults (its rule over every element) go last of the tool's rules: the copy holds only the
+        // file's own values, so folding them would leave every element the file does not style with no value at all
+        const everyone = (r: Draft): number => (r.origin === "tool" && "all" in r.where ? 1 : 0);
         cands.sort((a, b) => {
             const pa = a.role === "passthrough" ? 1 : 0;
             const pb = b.role === "passthrough" ? 1 : 0;
             return (
                 pa - pb ||
                 (FOLD_ORDER[a.origin] ?? 1) - (FOLD_ORDER[b.origin] ?? 1) ||
+                everyone(a) - everyone(b) ||
                 ruleSize(b) - ruleSize(a) ||
                 drafts.indexOf(b) - drafts.indexOf(a)
             );