@graphty/graph-io 0.3.9 → 0.3.11

package/src/formats/csv/importer.ts

@@ -1,7 +1,8 @@
 /**
  * The CSV / TSV importer (design sections 8.4 and 8.6; research note 07 section 2.6): a streaming
  * edge-list reader for the generic (`source,target[,weight,...]`), Gephi (`Source,Target,Type,Id,
- * Label,Weight,...`) and headerless (`u v [w]`) dialects, with an optional node table merged by id.
+ * Label,Weight,...`) and headerless (`u v [w]`) dialects, with an optional node table merged by id,
+ * and, with `table: "adjacency"`, an adjacency table (`node,neighbour[:weight],...`).
  *
  * - The delimiter is sniffed from a preview unless given; LF, CRLF and lone-CR files all read.
  * - The first row is a header when it holds a known column name or when it is all text over a
@@ -19,6 +20,17 @@
  *   section 5.1 and the sink infers the column dtype (widening per column, never per cell); an
  *   all-text column of low cardinality becomes a dict (design section 5.4); an `id` column of the
  *   edge table is the edge id (role id, unique); a `label` column is the label (role label).
+ * - An adjacency table has no header (unless `header: true`, which skips the first row): each row
+ *   is a node followed by its neighbours, one edge per neighbour in row order. A neighbour cell
+ *   `id:weight` carries the edge's weight when the text after its LAST colon is a number; a cell
+ *   ending in a bare colon (`a:1:`) is the id before it with no weight; any other cell is the id
+ *   as written (`http://x`). A row holding only its node adds an isolated node. An empty adjacency
+ *   table is the empty graph. The delimiter sniff skips a candidate under which a closing quote is
+ *   followed by other text, since the field counts it otherwise relies on vary by row.
+ * - A node table without an id column is refused unless `rowNumberIds` is set: then each data row's
+ *   0-based number is its id, coerced by `ids` like any other id cell. The option applies to the
+ *   node table (the `nodes` input, or the input itself when nothing is paired with it), whose first
+ *   row it makes a header under `header: "auto"`; a paired edge table is read as without it.
  * - Per-row problems (wrong field count, blank endpoint, invalid weight, bad Type, refused id)
  *   are recorded and the row skipped; the import aborts with ImportError once `errorLimit` is
  *   exceeded, on a malformed or unterminated quoted field, on an empty input and on a header
@@ -80,10 +92,12 @@ export interface CsvImportOptions {
     /** Whether the first row is a header; "auto" (default) decides from its content. */
     header?: boolean | "auto" | undefined;
     /**
-     * What the input is: an edge table, a node table, or "auto" (default): an edge table when
-     * source and target columns resolve, a node table when only an id column does.
+     * What the input is: an edge table, a node table, an adjacency table (`node,neighbour[:weight],...`
+     * per row, no header by default), or "auto" (default): an edge table when source and target
+     * columns resolve, a node table when only an id column does. An adjacency table is never
+     * guessed: nothing in its rows tells it from an edge list.
      */
-    table?: "edges" | "nodes" | "auto" | undefined;
+    table?: "edges" | "nodes" | "adjacency" | "auto" | undefined;
     /** The source column, by name or 0-based position; resolved from the header by default. */
     sourceColumn?: CsvColumnRef | undefined;
     /** The target column, by name or 0-based position; resolved from the header by default. */
@@ -97,6 +111,13 @@ export interface CsvImportOptions {
     idColumn?: CsvColumnRef | undefined;
     /** A node table read before the edges: its ids become nodes and its other columns node attributes. */
     nodes?: ImportInput | undefined;
+    /**
+     * A node table whose header has no id column gets its ids from the row numbers (0 for the first
+     * data row), coerced by `ids`, instead of failing with E_CSV_NO_ID_COLUMN. The node table is the
+     * `nodes` input when one is given (the edge table is then read as without this option), else
+     * the input itself; its first row is a header even under `header: "auto"`. False by default.
+     */
+    rowNumberIds?: boolean | undefined;
 }
 
 /** Issue code: the input holds no header row at all. */
@@ -126,7 +147,7 @@ export const ROLE_TAKEN_CODE = SHARED_ROLE_TAKEN_CODE;
 /** Issue code: a repeated edge id (the column is unique); the edge is skipped. */
 export const DUPLICATE_EDGE_ID_CODE = SHARED_DUPLICATE_EDGE_ID_CODE;
 
-const TABLE_MODES: ReadonlySet<string> = new Set(["edges", "nodes", "auto"]);
+const TABLE_MODES: ReadonlySet<string> = new Set(["edges", "nodes", "adjacency", "auto"]);
 
 /** The common options an edge-table import reads (the rest is reported by reportUnusedOptions). */
 const USED_OPTIONS: ReadonlySet<keyof CommonImportOptions> = new Set<keyof CommonImportOptions>([
@@ -154,13 +175,14 @@ const BAD_DELIMITERS: ReadonlySet<string> = new Set(['"', "\n", "\r"]);
 interface ResolvedCsvOptions {
     readonly delimiter: string | null;
     readonly header: boolean | "auto";
-    readonly table: "edges" | "nodes" | "auto";
+    readonly table: "edges" | "nodes" | "adjacency" | "auto";
     readonly sourceColumn: CsvColumnRef | null;
     readonly targetColumn: CsvColumnRef | null;
     /** The direction column reference; null for none; undefined for the Gephi rule. */
     readonly typeColumn: CsvColumnRef | null | undefined;
     readonly idColumn: CsvColumnRef | null;
     readonly nodes: ImportInput | null;
+    readonly rowNumberIds: boolean;
 }
 
 /** The columns of an edge table, by index. */
@@ -182,12 +204,20 @@ interface NodePlan {
     readonly kind: "nodes";
     readonly names: readonly string[];
     readonly width: number;
-    /** The column ids are read from, or -1 under nodeIdFrom "index". */
+    /** The column ids are read from, or -1 under nodeIdFrom "index" or rowNumberIds. */
     readonly id: number;
+    /** Whether a row's id is its row number coerced by `ids` (rowNumberIds); else the raw ordinal under -1. */
+    readonly rowNumber: boolean;
     readonly label: number;
     readonly attributes: readonly number[];
 }
 
+/** An adjacency table: no columns, a node and its neighbours per row. */
+interface AdjacencyPlan {
+    readonly kind: "adjacency";
+    readonly names: readonly string[];
+}
+
 /** Everything one import call shares between its tables. */
 interface ImportState {
     readonly sink: GraphSink;
@@ -255,7 +285,7 @@ function resolveCsvOptions(options: (CsvImportOptions & CommonImportOptions) | u
         });
     }
     if (o.table !== undefined && !TABLE_MODES.has(o.table)) {
-        throw new GraphFormatError("E_UNSUPPORTED", 'option table: expected "edges", "nodes" or "auto"', {
+        throw new GraphFormatError("E_UNSUPPORTED", 'option table: expected "edges", "nodes", "adjacency" or "auto"', {
             option: "table",
             found: o.table,
         });
@@ -266,6 +296,28 @@ function resolveCsvOptions(options: (CsvImportOptions & CommonImportOptions) | u
     if (o.typeColumn !== null) {
         checkColumnRef("typeColumn", o.typeColumn);
     }
+    if (o.table === "adjacency") {
+        for (const name of ["sourceColumn", "targetColumn", "typeColumn", "idColumn"] as const) {
+            if (o[name] !== undefined) {
+                throw new GraphFormatError("E_UNSUPPORTED", `option ${name}: an adjacency table has no columns`, {
+                    option: name,
+                    found: o[name],
+                });
+            }
+        }
+        if (o.rowNumberIds === true) {
+            throw new GraphFormatError("E_UNSUPPORTED", "option rowNumberIds: an adjacency table names its nodes", {
+                option: "rowNumberIds",
+                found: o.rowNumberIds,
+            });
+        }
+    }
+    if (o.rowNumberIds !== undefined && typeof o.rowNumberIds !== "boolean") {
+        throw new GraphFormatError("E_UNSUPPORTED", "option rowNumberIds: expected a boolean", {
+            option: "rowNumberIds",
+            found: o.rowNumberIds,
+        });
+    }
     return {
         delimiter: o.delimiter ?? null,
         header: o.header ?? "auto",
@@ -275,6 +327,7 @@ function resolveCsvOptions(options: (CsvImportOptions & CommonImportOptions) | u
         typeColumn: o.typeColumn,
         idColumn: o.idColumn ?? null,
         nodes: o.nodes ?? null,
+        rowNumberIds: o.rowNumberIds ?? false,
     };
 }
 
@@ -411,6 +464,40 @@ function parseKind(text: string): EdgeKind | null | undefined {
     }
 }
 
+/**
+ * Split an adjacency neighbour cell into its id and weight: the text after the LAST colon is the
+ * weight when it is a number, nothing when it is empty (`a:1:` is the id `a:1`, unweighted, the
+ * form the exporter writes for an id containing a colon), and part of the id otherwise.
+ * @param text - the cell text
+ * @returns the id text and the weight (undefined when the cell has none)
+ */
+export function splitNeighbour(text: string): { readonly id: string; readonly weight: number | undefined } {
+    const colon = text.lastIndexOf(":");
+    if (colon < 0) {
+        return { id: text, weight: undefined };
+    }
+    const suffix = text.slice(colon + 1);
+    if (suffix.length === 0) {
+        return { id: text.slice(0, colon), weight: undefined };
+    }
+    const weight = numberOrNull(suffix);
+    return weight === null ? { id: text, weight: undefined } : { id: text.slice(0, colon), weight };
+}
+
+/**
+ * A weight suffix as a number, or null when the text is not one.
+ * @param text - the suffix
+ * @returns the number, or null
+ */
+function numberOrNull(text: string): number | null {
+    try {
+        return parseWeightText(text) ?? null;
+    } catch {
+        // not a number: the colon belongs to the id
+        return null;
+    }
+}
+
 /**
  * Read one CSV table into the sink.
  */
@@ -419,9 +506,16 @@ class TableReader {
 
     private readonly reader: CsvRecordReader;
 
-    private readonly kind: "edges" | "nodes" | "auto";
+    private readonly kind: "edges" | "nodes" | "adjacency" | "auto";
 
-    private plan: EdgePlan | NodePlan | null = null;
+    /**
+     * Whether rowNumberIds applies to this table: a node table, or an "auto" table with no paired
+     * node table. Never the edge table of a paired import, which must still fail loudly when its
+     * header names no endpoints.
+     */
+    private readonly rowNumbers: boolean;
+
+    private plan: EdgePlan | NodePlan | AdjacencyPlan | null = null;
 
     private writers: (InferredColumn | null)[] = [];
 
@@ -445,12 +539,20 @@ class TableReader {
      * @param kind - what the table is, or "auto"
      * @param progress - whether this table reports byte progress
      */
-    constructor(state: ImportState, input: ImportInput, kind: "edges" | "nodes" | "auto", progress: boolean) {
+    constructor(
+        state: ImportState,
+        input: ImportInput,
+        kind: "edges" | "nodes" | "adjacency" | "auto",
+        progress: boolean,
+    ) {
         this.state = state;
         this.kind = kind;
+        this.rowNumbers = state.csv.rowNumberIds && (kind === "nodes" || (kind === "auto" && state.csv.nodes === null));
         const readerOptions: CsvReaderOptions = {
             delimiter: state.csv.delimiter,
             comments: COMMENT_CHARS,
+            // field counts say nothing about an adjacency table, whose rows vary in width
+            skipQuoteErrors: kind === "adjacency",
             signal: state.common.signal,
             onProgress: progress ? state.common.onProgress : null,
             encoding: state.common.encoding,
@@ -477,6 +579,10 @@ class TableReader {
     private async readRows(iterator: AsyncGenerator<string[], void, undefined>): Promise<void> {
         const { report } = this.state;
         const first = await iterator.next();
+        if (first.done && this.kind === "adjacency") {
+            // an adjacency table has no header: an empty one is the empty graph
+            return;
+        }
         const firstRow: string[] = first.done
             ? report.fail(EMPTY_INPUT_CODE, "the input is empty: no header row and no records")
             : first.value;
@@ -484,7 +590,14 @@ class TableReader {
         const firstQuoted = this.reader.quoted.slice(0, firstRow.length);
         const pending: { row: string[]; quoted: readonly boolean[]; line: number }[] = [];
         let header: boolean;
-        const { header: mode } = this.state.csv;
+        // an adjacency table has no header unless the caller says so: its rows vary in width; a
+        // table numbered by rowNumberIds has one, since a headerless table takes its ids from column 0
+        let mode = this.state.csv.header;
+        if (mode === "auto" && this.kind === "adjacency") {
+            mode = false;
+        } else if (mode === "auto" && this.rowNumbers) {
+            mode = true;
+        }
         if (mode === "auto") {
             const second = await iterator.next();
             const secondRow: string[] | null = second.done ? null : second.value;
@@ -542,8 +655,11 @@ class TableReader {
      * @param line - the header line
      * @returns the plan; the import aborts when no endpoints (or id) resolve
      */
-    private resolvePlan(names: readonly string[], header: boolean, line: number): EdgePlan | NodePlan {
+    private resolvePlan(names: readonly string[], header: boolean, line: number): EdgePlan | NodePlan | AdjacencyPlan {
         const { csv, report } = this.state;
+        if (this.kind === "adjacency") {
+            return { kind: "adjacency", names: [] };
+        }
         const width = names.length;
         let source = -1;
         let target = -1;
@@ -585,7 +701,7 @@ class TableReader {
             );
         }
         const idResolves = header ? findColumn(names, ID_NAMES) >= 0 : width >= 1;
-        if (this.kind === "auto" && csv.idColumn === null && !idResolves) {
+        if (this.kind === "auto" && csv.idColumn === null && !idResolves && !this.rowNumbers) {
             report.fail(
                 NO_ENDPOINT_COLUMNS_CODE,
                 `no source / target columns and no id column in the header (${shown}); the input is neither an edge table nor a node table`,
@@ -696,6 +812,10 @@ class TableReader {
                 id = -1;
                 break;
             default:
+                if (idColumn < 0 && this.rowNumbers) {
+                    id = -1;
+                    break;
+                }
                 if (idColumn < 0) {
                     report.fail(
                         NO_ID_COLUMN_CODE,
@@ -717,7 +837,8 @@ class TableReader {
                 attributes.push(i);
             }
         }
-        return { kind: "nodes", names, width: names.length, id, label, attributes };
+        const rowNumber = id < 0 && common.nodeIdFrom !== "index";
+        return { kind: "nodes", names, width: names.length, id, rowNumber, label, attributes };
     }
 
     /**
@@ -726,6 +847,9 @@ class TableReader {
      */
     private prepareColumns(line: number): void {
         const plan = this.requirePlan();
+        if (plan.kind === "adjacency") {
+            return;
+        }
         const { sink, report } = this.state;
         const domain = plan.kind === "edges" ? "edge" : "node";
         const origin = { format: "csv" };
@@ -759,7 +883,7 @@ class TableReader {
      * The plan, which exists once the header was read.
      * @returns the plan
      */
-    private requirePlan(): EdgePlan | NodePlan {
+    private requirePlan(): EdgePlan | NodePlan | AdjacencyPlan {
         if (this.plan === null) {
             throw new GraphFormatError("E_UNSUPPORTED", "the header has not been read", { reason: "no plan" });
         }
@@ -777,8 +901,73 @@ class TableReader {
         this.dataRows++;
         if (plan.kind === "edges") {
             this.processEdgeRow(plan, row, quoted, line);
-        } else {
+        } else if (plan.kind === "nodes") {
             this.processNodeRow(plan, row, quoted, line);
+        } else {
+            this.processAdjacencyRow(row, quoted, line);
+        }
+    }
+
+    /**
+     * Push one adjacency row: the node, then one edge per set neighbour cell, in row order.
+     * @param row - the cells
+     * @param quoted - whether each cell was quoted
+     * @param line - the row's line
+     */
+    private processAdjacencyRow(row: string[], quoted: readonly boolean[], line: number): void {
+        const { report, sink, resolver, common } = this.state;
+        const { counts } = report;
+        const { where } = this;
+        where.line = line;
+        where.element = null;
+        let neighbours = 0;
+        for (let k = 1; k < row.length; k++) {
+            if (!isUnset(row[k], quoted[k])) {
+                neighbours++;
+            }
+        }
+        if (isUnset(row[0], quoted[0])) {
+            report.error("missing-value", MISSING_ID_CODE, `line ${line}: blank node cell`, { line });
+            counts.skippedNodes++;
+            counts.skippedEdges += neighbours;
+            return;
+        }
+        const kind: EdgeKind = (this.state.commentDirected ?? common.defaultDirected) ? "directed" : "undirected";
+        if (!this.state.headerSet) {
+            this.state.headerSet = true;
+            resolver.setHeader(kind !== "undirected", where);
+        }
+        let source: NodeId;
+        try {
+            where.element = row[0];
+            source = this.coerce(row[0]);
+            if (sink.indexOf(source) === INVALID_INDEX) {
+                counts.nodes++;
+            }
+            sink.addNode(source);
+        } catch (err) {
+            report.recordError(err, where);
+            counts.skippedNodes++;
+            counts.skippedEdges += neighbours;
+            return;
+        }
+        for (let k = 1; k < row.length; k++) {
+            if (isUnset(row[k], quoted[k])) {
+                continue;
+            }
+            where.element = row[k];
+            try {
+                const cell = splitNeighbour(row[k]);
+                const target = this.coerce(cell.id);
+                const targetNew = sink.indexOf(target) === INVALID_INDEX;
+                const before = sink.edgeCount;
+                resolver.addEdge(source, target, kind, common.weightFrom === null ? undefined : cell.weight, where);
+                counts.edges += sink.edgeCount - before;
+                counts.nodes += targetNew ? 1 : 0;
+            } catch (err) {
+                report.recordError(err, where);
+                counts.skippedEdges++;
+            }
         }
     }
 
@@ -911,7 +1100,7 @@ class TableReader {
         where.element = idText;
         let index: number;
         try {
-            const id = plan.id >= 0 ? this.coerce(idText) : ordinal;
+            const id = plan.id >= 0 || plan.rowNumber ? this.coerce(idText) : ordinal;
             if (sink.indexOf(id) !== INVALID_INDEX) {
                 report.warning(
                     "merged",

package/src/formats/csv/records.ts

@@ -27,7 +27,7 @@ export const UNCLOSED_QUOTE_CODE = "E_CSV_UNCLOSED_QUOTE";
 export const BAD_QUOTE_CODE = "E_CSV_QUOTE";
 
 /** The delimiters tried, in priority order, when none is given. */
-const DELIMITER_CANDIDATES: readonly string[] = Object.freeze([",", "\t", ";", "|", " "]);
+export const DELIMITER_CANDIDATES: readonly string[] = Object.freeze([",", "\t", ";", "|", " "]);
 
 /** Rows the delimiter sniff looks at. */
 const PREVIEW_ROWS = 10;
@@ -67,6 +67,11 @@ export interface RecordSyntax {
      * sniff. A later line starting with one of them is an ordinary record. Default: none.
      */
     readonly comments?: readonly string[] | undefined;
+    /**
+     * Whether the delimiter sniff skips a candidate under which a closing quote is followed by
+     * other text (see sniffDelimiter). False by default: that text then aborts the read.
+     */
+    readonly skipQuoteErrors?: boolean | undefined;
 }
 
 /**
@@ -117,9 +122,17 @@ export function sniffNewline(text: string): "\n" | "\r" {
  * @param delimiter - the delimiter
  * @param quote - the quote character
  * @param maxRows - the most rows to return
- * @returns the rows as cell arrays (blank lines skipped)
+ * @param strictQuotes - return null when a closing quote is followed by text other than the
+ * delimiter or a line break (the import would abort under this delimiter)
+ * @returns the rows as cell arrays (blank lines skipped), or null (see strictQuotes)
  */
-function splitRecords(text: string, delimiter: string, quote: string, maxRows: number): string[][] {
+function splitRecords(
+    text: string,
+    delimiter: string,
+    quote: string,
+    maxRows: number,
+    strictQuotes = false,
+): string[][] | null {
     const rows: string[][] = [];
     const delimiterCode = delimiter.charCodeAt(0);
     const quoteCode = quote.charCodeAt(0);
@@ -144,6 +157,9 @@ function splitRecords(text: string, delimiter: string, quote: string, maxRows: n
                 state = QUOTED;
                 continue;
             }
+            if (strictQuotes && c !== delimiterCode && c !== LF && c !== CR) {
+                return null;
+            }
             state = AFTER_QUOTED;
             segment = i;
         }
@@ -227,6 +243,10 @@ function stripLeadingComments(text: string, comments: readonly string[]): string
  * kept for callers that sniffed it)
  * @param candidates - the delimiters to try, in priority order
  * @param quote - the quote character
+ * @param skipQuoteErrors - also never choose a candidate under which a closing quote is followed
+ * by other text. Only for inputs whose field counts say nothing (an adjacency table's rows vary in
+ * width): elsewhere a stray character after a quote would make a worse candidate win silently
+ * instead of aborting the read
  * @returns the delimiter, or null
  */
 export function sniffDelimiter(
@@ -234,6 +254,7 @@ export function sniffDelimiter(
     newline: "\n" | "\r" = "\n",
     candidates: readonly string[] = DELIMITER_CANDIDATES,
     quote = '"',
+    skipQuoteErrors = false,
 ): string | null {
     let best: string | null = null;
     let bestDelta = Infinity;
@@ -243,7 +264,12 @@ export function sniffDelimiter(
         if (delimiter === quote || delimiter === newline) {
             continue;
         }
-        let rows = splitRecords(text, delimiter, quote, PREVIEW_ROWS).filter((row) => !isBlankRow(row));
+        const split = splitRecords(text, delimiter, quote, PREVIEW_ROWS, skipQuoteErrors);
+        if (split === null) {
+            // a quoted cell this delimiter does not close: it is not the file's delimiter
+            continue;
+        }
+        let rows = split.filter((row) => !isBlankRow(row));
         if (rows.length > 1 && !terminated) {
             // the preview is a prefix of the file: its last row may be cut short
             rows = rows.slice(0, -1);
@@ -454,7 +480,9 @@ export class RecordReader implements AsyncIterable<number> {
         // the sniff is a heuristic over the first rows: a single chunk holding a huge quoted cell
         // is capped so the candidate scans stay bounded
         const body = stripLeadingComments(text.slice(0, PREVIEW_CHARS), this.syntax.comments ?? []);
-        this.delimiterText = sniffDelimiter(body, sniffNewline(body), candidates, this.syntax.quote) ?? candidates[0];
+        this.delimiterText =
+            sniffDelimiter(body, sniffNewline(body), candidates, this.syntax.quote, this.syntax.skipQuoteErrors) ??
+            candidates[0];
     }
 }
 
@@ -736,6 +764,8 @@ export interface CsvReaderOptions extends ReadOptions {
     readonly delimiter?: string | null | undefined;
     /** The characters opening a leading comment line (RecordSyntax.comments); none by default. */
     readonly comments?: readonly string[] | undefined;
+    /** RecordSyntax.skipQuoteErrors; false by default. */
+    readonly skipQuoteErrors?: boolean | undefined;
 }
 
 /**
@@ -759,7 +789,12 @@ export class CsvRecordReader implements AsyncIterable<string[]> {
         this.inner = new RecordReader(
             input,
             report,
-            { delimiter: options.delimiter ?? null, quote: '"', comments: options.comments },
+            {
+                delimiter: options.delimiter ?? null,
+                quote: '"',
+                comments: options.comments,
+                skipQuoteErrors: options.skipQuoteErrors,
+            },
             { signal: options.signal, onProgress: options.onProgress, encoding: options.encoding },
         );
     }

package/src/formats/dot/exporter.ts

@@ -123,6 +123,7 @@ const SKIPPED_NODE_ROLES: ReadonlySet<string> = new Set([
     "timestamps",
     "spells",
     "open",
+    "spellsOpen",
     "timeText",
     "directed",
     "pair",
@@ -148,6 +149,7 @@ const SKIPPED_EDGE_ROLES: ReadonlySet<string> = new Set([
     "timestamps",
     "spells",
     "open",
+    "spellsOpen",
     "timeText",
     "parent",
     "parents",

package/src/formats/gexf/exporter.ts

@@ -172,6 +172,7 @@ interface RoleColumns {
     end: Column | null;
     timestamp: Column | null;
     spells: Column | null;
+    spellsOpen: Column | null;
     timestamps: Column | null;
     open: Column | null;
     position: Column | null;
@@ -417,6 +418,8 @@ function roleShapeOk(role: string, column: Column, domain: "node" | "edge"): boo
             return domain === "edge" && isNumericScalar(column);
         case "spells":
             return isNumericList(column, 2);
+        case "spellsOpen":
+            return column.dtype === "list" && column.meta.itemDtype === "u8";
         case "timestamps":
             return isNumericList(column, 1);
         case "position":
@@ -442,6 +445,7 @@ const MAPPED_ROLES: ReadonlySet<string> = new Set([
     "end",
     "timestamp",
     "spells",
+    "spellsOpen",
     "timestamps",
     "open",
     "position",
@@ -462,6 +466,7 @@ const ROLE_NAMES: Readonly<Record<string, string>> = Object.freeze({
     end: NODE_COLUMNS.end,
     timestamp: NODE_COLUMNS.timestamp,
     spells: NODE_COLUMNS.spells,
+    spellsOpen: NODE_COLUMNS.spellsOpen,
     timestamps: NODE_COLUMNS.timestamps,
     open: NODE_COLUMNS.open,
     position: NODE_COLUMNS.position,
@@ -495,6 +500,7 @@ function collectRoles(
         end: null,
         timestamp: null,
         spells: null,
+        spellsOpen: null,
         timestamps: null,
         open: null,
         position: null,
@@ -1197,6 +1203,8 @@ function lifetimeAttrs(roles: RoleColumns, row: number, plan: ExportPlan): strin
 
 /**
  * The `<spells>` element of one element: its spells column, plus (1.2) its timestamps as [t, t].
+ * In 1.2 a spell whose spells.open bits mark a bound open writes that bound as `startopen` /
+ * `endopen`; 1.3 has no open bounds, and check() reports the loss.
  * @param roles - the domain's role columns
  * @param row - the element's row
  * @param plan - the plan
@@ -1204,29 +1212,35 @@ function lifetimeAttrs(roles: RoleColumns, row: number, plan: ExportPlan): strin
  * @returns the lines, or an empty string
  */
 function spellsElement(roles: RoleColumns, row: number, plan: ExportPlan, indent: string): string {
-    const pairs: (readonly [number, number])[] = [];
+    const pairs: (readonly [number, number, number])[] = [];
     if (roles.spells !== null && roles.spells.isSet(row)) {
-        for (const pair of listItems(roles.spells, row)) {
+        const open =
+            plan.version === "1.2" && roles.spellsOpen !== null && roles.spellsOpen.isSet(row)
+                ? listItems(roles.spellsOpen, row)
+                : [];
+        listItems(roles.spells, row).forEach((pair, i) => {
             const [s, e] = Array.from(pair as ArrayLike<number>);
-            pairs.push([s, e]);
-        }
+            pairs.push([s, e, (open[i] as number | undefined) ?? 0]);
+        });
     }
     if (plan.version === "1.2" && roles.timestamps !== null && roles.timestamps.isSet(row)) {
         for (const t of listItems(roles.timestamps, row)) {
-            pairs.push([t as number, t as number]);
+            pairs.push([t as number, t as number, 0]);
         }
     }
     if (pairs.length === 0) {
         return "";
     }
     let out = `${indent}<spells>\n`;
-    for (const [s, e] of pairs) {
+    for (const [s, e, open] of pairs) {
         let attrs = "";
         if (Number.isFinite(s)) {
-            attrs += ` start="${escapeXmlAttribute(formatTimeValue(s, plan.timeFormat))}"`;
+            const name = (open & OPEN_START) === 0 ? "start" : "startopen";
+            attrs += ` ${name}="${escapeXmlAttribute(formatTimeValue(s, plan.timeFormat))}"`;
         }
         if (Number.isFinite(e)) {
-            attrs += ` end="${escapeXmlAttribute(formatTimeValue(e, plan.timeFormat))}"`;
+            const name = (open & OPEN_END) === 0 ? "end" : "endopen";
+            attrs += ` ${name}="${escapeXmlAttribute(formatTimeValue(e, plan.timeFormat))}"`;
         }
         out += `${indent}  <spell${attrs}/>\n`;
     }
@@ -1551,7 +1565,7 @@ function* writeGexf(
     const edgeList = snapshot.edgeList();
     const folding = pairFolding(snapshot, { foldMutual: true });
     const weights = explicitWeights(snapshot);
-    const defaultType: GexfEdgeType = snapshot.directed ? "directed" : "undirected";
+    const defaultType = defaultEdgeType(snapshot);
     let written = 0;
     for (let e = 0; e < snapshot.edgeCount; e++) {
         if (edgeType(snapshot, e, folding) !== null) {
@@ -1626,7 +1640,7 @@ function metaElement(meta: GraphSnapshot["meta"]): string {
  */
 function graphStart(snapshot: GraphSnapshot, plan: ExportPlan): string {
     const { meta } = snapshot;
-    let attrs = ` defaultedgetype="${snapshot.directed ? "directed" : "undirected"}"`;
+    let attrs = ` defaultedgetype="${defaultEdgeType(snapshot)}"`;
     let mode = meta.mode ?? "static";
     if (plan.temporal && mode === "static") {
         mode = "dynamic";
@@ -1676,7 +1690,22 @@ function graphStart(snapshot: GraphSnapshot, plan: ExportPlan): string {
 }
 
 /**
- * A graph header value the GEXF importer recorded in `meta.extra.gexf` (start, end, timestamp).
+ * The `defaultedgetype` to write: the snapshot's direction, or `mutual` for a directed snapshot
+ * whose source file declared a mutual default (the importer reads that default as directed, with
+ * every untyped edge mutual), so the default survives a round trip.
+ * @param snapshot - the snapshot
+ * @returns the edge type the header declares, and every edge without its own `type` takes
+ */
+function defaultEdgeType(snapshot: GraphSnapshot): GexfEdgeType {
+    if (!snapshot.directed) {
+        return "undirected";
+    }
+    return graphExtraText(snapshot, "defaultedgetype")?.trim().toLowerCase() === "mutual" ? "mutual" : "directed";
+}
+
+/**
+ * A graph header value the GEXF importer recorded in `meta.extra.gexf` (defaultedgetype, start,
+ * end, timestamp).
  * @param snapshot - the snapshot
  * @param key - the attribute name
  * @returns the text, or null when absent