@knowvah/dot-engine 1.1.0 → 1.2.0

package/dist/layout/dot/index.d.ts

@@ -66,7 +66,7 @@ export declare function dotPhasePost(g: Graph): void;
 /**
  * Runs the full dot layout pipeline on graph g.
  *
- * The optional `maxphase` attribute (read from g.attrs) controls how many
+ * The optional `phase` attribute (read from g.attrs) controls how many
  * phases run (1=rank only, 2=+mincross, 3=+position, ≥4 or absent=all).
  *
  * C's `dotLayout` checks `dot_mincross`'s return code and returns immediately

package/dist/layout/dot/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/layout/dot/index.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAyBzD,OAAO,EACL,QAAQ,EACR,WAAW,EACX,WAAW,EACX,WAAW,EACX,eAAe,EACf,UAAU,EACV,UAAU,EACV,YAAY,EACZ,UAAU,EACV,UAAU,EACV,UAAU,EACV,UAAU,GACX,MAAM,WAAW,CAAC;AAOnB;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAErD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,GAAG,IAAI,CAUxE;AAMD;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAK5E;AAOD;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI,CAM3C;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI,CAUnD;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI,CAG3C;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI,CAYhD;AAkBD;;;;;;;;;;;GAWG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI,CA4BpC;AAMD;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI,CAG7C;AAMD;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,EAAE,YAI/B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/layout/dot/index.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAyBzD,OAAO,EACL,QAAQ,EACR,WAAW,EACX,WAAW,EACX,WAAW,EACX,eAAe,EACf,UAAU,EACV,UAAU,EACV,YAAY,EACZ,UAAU,EACV,UAAU,EACV,UAAU,EACV,UAAU,GACX,MAAM,WAAW,CAAC;AAOnB;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAErD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,GAAG,IAAI,CAUxE;AAMD;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAK5E;AAOD;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI,CAM3C;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI,CAUnD;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI,CAG3C;AAiCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI,CAiBhD;AAkBD;;;;;;;;;;;GAWG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI,CA4BpC;AAMD;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI,CAG7C;AAMD;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,EAAE,YAI/B,CAAC"}

package/dist/layout/sfdp/init.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../src/layout/sfdp/init.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AASlD,OAAO,EACL,KAAK,QAAQ,EAGd,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,KAAK,uBAAuB,EAK7B,MAAM,wBAAwB,CAAC;AAEhC,8EAA8E;AAC9E,eAAO,MAAM,cAAc,IAAI,CAAC;AAIhC;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI,CAoB5C;AAqDD;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,uBAAuB,GAAG,IAAI,CAmBzE;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,KAAK,GAAG,QAAQ,CAmB7C;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,EAAE,CAQ1E;AAED;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAetD;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI,CAK1C"}
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../src/layout/sfdp/init.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AASlD,OAAO,EACL,KAAK,QAAQ,EAGd,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,KAAK,uBAAuB,EAK7B,MAAM,wBAAwB,CAAC;AAEhC,8EAA8E;AAC9E,eAAO,MAAM,cAAc,IAAI,CAAC;AAIhC;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI,CAoB5C;AAqDD;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,uBAAuB,GAAG,IAAI,CA8BzE;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,KAAK,GAAG,QAAQ,CAmB7C;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,EAAE,CAQ1E;AAED;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAetD;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI,CAK1C"}

package/dist/model/graph.d.ts

@@ -86,6 +86,30 @@ export declare class Graph {
      * @see lib/cgraph/graph.c:agsubg (attr defval copy)
      */
     graphDefaultsSnapshot?: Map<string, string>;
+    /**
+     * Keys in `attrs` the BUILDER seeded from `graphDefaultsSnapshot` rather than
+     * the input declaring them in this scope (see builder.ts GRAPH_LABEL_INHERIT_
+     * KEYS). cgraph distinguishes these structurally — a seeded value is inherited
+     * through the dict view and has no local symbol, while a local declaration
+     * creates one even when its value equals the inherited value — so the
+     * serializer needs the provenance to decide what write_dict would print.
+     * Undefined on the root graph and on any scope that seeded nothing.
+     * @see lib/cgraph/write.c:262 write_dict
+     */
+    seededAttrs?: Set<string>;
+    /**
+     * Graph-attribute keys whose declaration in THIS scope was the first anywhere
+     * in the graph. cgraph's `setattr` splits on exactly this: a key with no
+     * existing symbol takes the global-declaration branch, which ends up seeding
+     * every direct subgraph that already exists with a local empty value (see
+     * `eagerEmptyParts`); a key some earlier scope already declared takes the
+     * "new local definition" branch and touches no subgraph at all. So an
+     * identical `graph [fill=x]` statement makes a child print `fill=""` or print
+     * nothing purely according to whether a SIBLING declared `fill` first.
+     * Undefined on any scope that declared nothing new.
+     * @see lib/cgraph/attr.c:257 setattr (lsym / psym / global branches)
+     */
+    firstGraphDecl?: Set<string>;
     /**
      * Layout-engine info; replaces GD_* macros via agbindrec (AD-1).
      * @see lib/cgraph/cgraph.h:agbindrec

package/dist/model/graph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph.d.ts","sourceRoot":"","sources":["../../src/model/graph.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACtC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACtC,OAAO,EAAE,KAAK,SAAS,EAAiB,MAAM,gBAAgB,CAAC;AAE/D;;;;;;;;;GASG;AACH,MAAM,MAAM,SAAS,GACjB,UAAU,GACV,YAAY,GACZ,iBAAiB,GACjB,mBAAmB,CAAC;AAExB;;;;;;;;;;;;GAYG;AACH,qBAAa,KAAK;IAChB,yEAAyE;IACzE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB;;;;;;;;OAQG;IACH,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAE5B;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAEzB;;;;OAIG;IACH,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IAEzB;;;;OAIG;IACH,KAAK,EAAE,IAAI,EAAE,CAAC;IAEd;;;OAGG;IACH,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAE9B;;;;OAIG;IACH,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAE3B,mEAAmE;IACnE,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAElC,mEAAmE;IACnE,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAElC;;;;;;;;OAQG;IACH,qBAAqB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAE5C;;;OAGG;IACH,IAAI,EAAE,SAAS,CAAC;IAEhB;;;OAGG;IACH,MAAM,EAAE,KAAK,GAAG,IAAI,CAAC;IAErB;;;;OAIG;IACH,IAAI,EAAE,KAAK,CAAC;IAEZ;;;;;;;OAOG;IACH,GAAG,SAAK;IAER;;;;;OAKG;IACH,cAAc,SAAK;IAEnB;;;;;;;;;OASG;IACH,kBAAkB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAa;IAE5C,qCAAqC;gBACzB,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,SAAS,UAAQ;CAc7D"}
+{"version":3,"file":"graph.d.ts","sourceRoot":"","sources":["../../src/model/graph.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACtC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACtC,OAAO,EAAE,KAAK,SAAS,EAAiB,MAAM,gBAAgB,CAAC;AAE/D;;;;;;;;;GASG;AACH,MAAM,MAAM,SAAS,GACjB,UAAU,GACV,YAAY,GACZ,iBAAiB,GACjB,mBAAmB,CAAC;AAExB;;;;;;;;;;;;GAYG;AACH,qBAAa,KAAK;IAChB,yEAAyE;IACzE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB;;;;;;;;OAQG;IACH,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAE5B;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAEzB;;;;OAIG;IACH,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IAEzB;;;;OAIG;IACH,KAAK,EAAE,IAAI,EAAE,CAAC;IAEd;;;OAGG;IACH,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAE9B;;;;OAIG;IACH,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAE3B,mEAAmE;IACnE,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAElC,mEAAmE;IACnE,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAElC;;;;;;;;OAQG;IACH,qBAAqB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAE5C;;;;;;;;;OASG;IACH,WAAW,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAE1B;;;;;;;;;;;OAWG;IACH,cAAc,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAE7B;;;OAGG;IACH,IAAI,EAAE,SAAS,CAAC;IAEhB;;;OAGG;IACH,MAAM,EAAE,KAAK,GAAG,IAAI,CAAC;IAErB;;;;OAIG;IACH,IAAI,EAAE,KAAK,CAAC;IAEZ;;;;;;;OAOG;IACH,GAAG,SAAK;IAER;;;;;OAKG;IACH,cAAc,SAAK;IAEnB;;;;;;;;;OASG;IACH,kBAAkB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAa;IAE5C,qCAAqC;gBACzB,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,SAAS,UAAQ;CAc7D"}

package/dist/parser/builder.d.ts

@@ -41,7 +41,35 @@ export declare class StmtProcessor {
      * @see lib/cgraph/id.c:agnameof (`'%' + id`)
      */
     private anonCounter;
+    /**
+     * Strict-graph edge index: canonical endpoint-pair key → the edge already
+     * created for it. `agedge` on a strict graph probes for a pre-existing edge
+     * and returns it instead of creating a second one, so `strict digraph
+     * { a->b; a->b }` holds ONE edge. A Map (rather than scanning root.edges)
+     * keeps that probe O(1); it stays empty for non-strict graphs.
+     * @see lib/cgraph/edge.c:agedge (agfindedge_by_key probe, :262-287)
+     */
+    private readonly strictEdges;
     constructor(registry: NodeRegistry);
+    /**
+     * Canonical key for a strict-graph endpoint pair. C probes (t,h) and then,
+     * for an UNDIRECTED graph, (h,t) — so an undirected pair matches either way
+     * round and is canonicalized here by node id; a directed pair is not.
+     * @see lib/cgraph/edge.c:agedge:274-275 (`if (e == NULL && agisundirected(g))`)
+     */
+    private static strictKey;
+    /**
+     * Apply the DOT-syntax `:port:compass` endpoints to an edge's attrs.
+     *
+     * C's precedence is explicit attr > `:port` syntax > edge default (verified
+     * against the oracle: with `edge [headport=n]` declared, `a:e -> b:sw` yields
+     * headport `sw`, while `c:e -> d:sw [headport=w]` yields `w`). The guard is
+     * therefore against THIS statement's own attribute list — not the edge's
+     * accumulated map, which also holds inherited defaults and, for a strict
+     * duplicate, the earlier statement's values.
+     * @see lib/cgraph/grammar.y:396 (mkport)
+     */
+    private static applySyntaxPorts;
     /** Consume one anonymous id, returning cgraph's `2*counter+1`. */
     private nextAnonId;
     /**
@@ -52,6 +80,10 @@ export declare class StmtProcessor {
      */
     advanceAnonId(): void;
     processAssign(stmt: AssignStmt, graph: Graph): void;
+    /** Record a graph-attribute declaration, noting whether THIS scope was the
+     *  first to declare the key anywhere — the branch selector in cgraph's
+     *  setattr. @see lib/cgraph/attr.c:257 · model/graph.ts firstGraphDecl */
+    private declareGraphAttr;
     processAttr(stmt: AttrStmt, graph: Graph): void;
     processNodeStmt(stmt: NodeStmt, graph: Graph, root: Graph): void;
     processEdgeStmt(stmt: EdgeStmt, graph: Graph, root: Graph, directed: boolean): void;

package/dist/parser/builder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../../src/parser/builder.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AAEH,OAAO,EAAE,KAAK,EAAkB,MAAM,mBAAmB,CAAC;AAC1D,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAGxC,OAAO,KAAK,EACV,QAAQ,EACR,MAAM,EACN,QAAQ,EACR,QAAQ,EACR,QAAQ,EACR,UAAU,EACV,YAAY,EACZ,UAAU,EACV,WAAW,EACZ,MAAM,UAAU,CAAC;AAIlB;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAExD;AAED,wBAAgB,UAAU,CACxB,KAAK,EAAE,QAAQ,EAAE,EACjB,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAC1B,IAAI,CAIN;AAwDD,+DAA+D;AAC/D,qBAAa,YAAY;IACvB,OAAO,CAAC,MAAM,CAAK;IAEnB,KAAK,IAAI,IAAI;IAIb,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,GAAE,KAAY,GAAG,IAAI;CAW7D;AAID,kFAAkF;AAClF,qBAAa,aAAa;IACxB,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,UAAU,EAAE,GAAG,MAAM,EAAE;IAM/C,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,UAAU,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,IAAI;IAUtD,MAAM,CAAC,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,IAAI;CAOtE;AAID,uEAAuE;AACvE,qBAAa,aAAa;IAgBZ,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAfrC;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,WAAW,CAAK;gBAEK,QAAQ,EAAE,YAAY;IAEnD,kEAAkE;IAClE,OAAO,CAAC,UAAU;IAIlB;;;;;OAKG;IACH,aAAa,IAAI,IAAI;IAIrB,aAAa,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,KAAK,GAAG,IAAI;IAOnD,WAAW,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,GAAG,IAAI;IAW/C,eAAe,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,GAAG,IAAI;IAUhE,eAAe,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,QAAQ,EAAE,OAAO,GAAG,IAAI;IAenF,eAAe,CACb,IAAI,EAAE,YAAY,EAClB,KAAK,EAAE,KAAK,EACZ,IAAI,EAAE,KAAK,EACX,QAAQ,EAAE,OAAO,GAChB,KAAK;IAwCR,QAAQ,CACN,IAAI,EAAE,UAAU,EAChB,KAAK,EAAE,KAAK,EACZ,IAAI,EAAE,KAAK,EACX,QAAQ,EAAE,OAAO,GAChB,IAAI;IAUP;;;;;;OAMG;IACH,OAAO,CAAC,oBAAoB;IAQ5B,OAAO,CAAC,eAAe;IAiCvB,OAAO,CAAC,gBAAgB;CA8BzB;AAID,iFAAiF;AACjF,wBAAgB,UAAU,CACxB,KAAK,EAAE,UAAU,EAAE,EACnB,KAAK,EAAE,KAAK,EACZ,IAAI,EAAE,KAAK,EACX,QAAQ,EAAE,OAAO,EACjB,SAAS,EAAE,aAAa,GACvB,IAAI,CAIN;AAED,mDAAmD;AACnD,wBAAgB,YAAY,CAAC,GAAG,EAAE,WAAW,GAAG,KAAK,CAkBpD"}
+{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../../src/parser/builder.ts"],"names":[],"mappings":"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"}

package/dist/render/dot/agwrite.d.ts

@@ -0,0 +1,186 @@
+/**
+ * The agwrite serializer — write.c's graph/subgraph/node/edge emission, shared
+ * verbatim by `-Tdot` and `-Txdot`.
+ *
+ * Split out of dot.ts as an abstract base rather than a collaborator so every
+ * method body moves UNCHANGED: the serializer reads only three things from the
+ * renderer (`emitDraws`, `clusters`, `drawsOf`), which are declared abstract
+ * here and supplied by XdotRenderer. Keeping the bodies byte-identical matters
+ * more than the inheritance being fashionable — this is ported C, and a
+ * mechanical move is auditable against write.c in a way a rewrite is not.
+ *
+ * @see lib/cgraph/write.c
+ */
+import type { Graph } from '../../model/graph.js';
+import type { Node } from '../../model/node.js';
+import type { Edge } from '../../model/edge.js';
+import type { XdotDraws } from './types.js';
+/** write.c's serializer half of the dot/xdot renderer. @see lib/cgraph/write.c */
+export declare abstract class DotWriterBase {
+    /** @see dot.ts XdotRenderer.emitDraws */
+    protected abstract readonly emitDraws: boolean;
+    /** Clusters in render order (GD_clust); filled by the renderer's endCluster. */
+    protected clusters: Graph[];
+    /** Draw strings for `obj`, or undefined in a format that emits none. */
+    protected abstract drawsOf(obj: Node | Edge | Graph): XdotDraws | undefined;
+    /**
+     * Emit `key="value"`, escaping the value the way agwrite's agcanonStr does: a
+     * `"` becomes `\"` unless it is already part of an escape sequence (see
+     * agcanonEscape). A draw string carries label text that may contain a bare `"`
+     * (would close the attribute early) or a source `\"`/`\\` (must not be
+     * double-escaped). The byte-length prefix stays on the UNescaped text (the
+     * parser un-escapes before parseXDot re-reads it), matching native exactly.
+     * @see lib/cgraph/write.c:_agstrcanon (135-167)
+     */
+    private drawAttr;
+    /** `llx,lly,urx,ury` from a graph's layout bb. */
+    private bbStr;
+    /**
+     * Serialize the whole laid-out graph to xdot DOT text — a faithful port of
+     * cgraph's agwrite (lib/cgraph/write.c). Recurses the subgraph tree
+     * (write_subgs/write_body), scoping each node/edge to the subgraph(s) it
+     * belongs to via preorder numbers (write_node_test/write_edge_test), and
+     * re-emits an object bare (no attrs) on any scope after the first
+     * (attrs_written). This reproduces native's per-subgraph edge re-declarations
+     * — e.g. an edge in a rank=same subgraph is drawn once, then re-declared bare.
+     * @see lib/cgraph/write.c:agwrite
+     */
+    protected serialize(g: Graph): string;
+    /** Preorder-number the subgraph tree. @see write.c:subgdfs */
+    private subgdfs;
+    /** A subgraph is anonymous when its name is empty or a `%N` local name. */
+    private isAnonymous;
+    /** A graph carries a `bb` attribute when it is the root or has a layout bb
+     *  (clusters, and any subgraph output.c computed a box for). Native seeds `bb`
+     *  on every graph via safe_dcl, so the value differs (set vs empty "") between
+     *  a boxed graph and an unboxed child — the driver that makes an anon subgraph
+     *  under the root or a cluster "relevant". @see lib/common/output.c:safe_dcl */
+    private hasBb;
+    /** Anonymous subgraph with no own node/edge defaults and no graph attrs
+     *  differing from its parent → inlined into the parent. Native compares every
+     *  graph attr over the root attr dict; the load-bearing ones are `bb` (set on
+     *  the parent, empty on the child) and `rank`. @see write.c:irrelevant_subgraph */
+    private irrelevantSubgraph;
+    /** Non-draw graph attrs a subgraph emits (rank for rank=same; clusters use
+     *  clusterAttrs). Only comparator-relevant fields need be exact.
+     *
+     *  `rec_attach_bb` walks the ROOT and then `GD_clust` recursively, so a
+     *  subgraph the layout did not box is attached NEITHER `bb` NOR the label
+     *  triple — both keep the INPUT's values, which agwrite echoes. circo and
+     *  twopi lay out no clusters at all (`GD_clust` empty — mirrored here by
+     *  `this.clusters`, filled from endCluster), so on a re-fed dot output their
+     *  `cluster0` comes back carrying the *previous* run's `bb` and `lp`.
+     *  @see lib/common/output.c:249 rec_attach_bb */
+    private subgGraphAttrs;
+    private indent;
+    /** @see write.c:write_hdr */
+    private writeHdr;
+    /**
+     * Emit this scope's `graph` / `node` / `edge` default statements, in that
+     * order. @see lib/cgraph/write.c:307 write_dicts
+     */
+    private writeDicts;
+    /**
+     * One `<name> [...]` default statement. Entries are emitted in **strcmp order
+     * of attribute name**: cgraph's attribute dicts are `Dttree`s keyed on
+     * `Agsym_t.name` with a NULL comparf (attr.c:34), so `dtfirst`/`dtnext` walk
+     * them sorted — the oracle's `graph [bb, rankdir]` and `[height, pos, width]`.
+     *
+     * Layout mirrors write_dict exactly: a single entry stays on one line, and two
+     * or more break after each `,` with the body indented one level deeper and the
+     * closing `];` back at the statement's own level.
+     *
+     * Not ported: the `EMPTY(defval) && !sym->print` skip (write.c:271-280). Every
+     * entry here was explicitly declared or computed, i.e. `print` is set, so that
+     * branch is unreachable until the eager-propagation artifact lands — an
+     * `agapply`-installed empty default is the only `print == false` producer.
+     *
+     * @see lib/cgraph/write.c:262 write_dict
+     */
+    private writeDict;
+    /**
+     * One object's `[...]` attribute block, or '' when it has no attributes.
+     * Entries sort strcmp like every dict (attr.c:34). Layout is
+     * write_nondefault_attrs, which differs from write_dict in two ways: the block
+     * opens with a literal TAB before `[`, and the closing `]` follows the last
+     * value directly — there is no newline+indent before it.
+     * @see lib/cgraph/write.c:471 write_nondefault_attrs
+     */
+    private objAttrBlock;
+    /** @see write.c:write_trl */
+    private writeTrl;
+    /** @see write.c:write_subgs */
+    private writeSubgs;
+    /** @see write.c:write_body — subgraphs, then this scope's nodes and edges. */
+    private writeBody;
+    /** @see write.c:write_node_test — every xdot node carries pos/size, so it is
+     *  never "default"; write it in the first scope that has not yet emitted it.
+     *  Cluster nodes (fdp compound proxies, ND_clustnode) are never declared —
+     *  C's write_plain/writenodeandport suppress them. @see lib/common/output.c:146 */
+    private writeNodeTest;
+    /** Emitted node name: a cluster node's synthetic `__i:<cluster>` id is written
+     *  as the cluster name it stands for. @see lib/common/output.c:114 */
+    private emitNodeName;
+    /** @see write.c:write_edge_test */
+    private writeEdgeTest;
+    /** @see write.c:write_node */
+    private writeNode;
+    /** @see write.c:write_edge — attrs only on first emission, bare thereafter. */
+    /**
+     * The `:port` / `:port:compass` suffix C writes after an endpoint name.
+     *
+     * These are NOT ordinary attributes on the way out: write_nondefault_attrs
+     * skips the tailport/headport symbols (write.c:487-492) precisely because
+     * this function re-emits them as endpoint syntax, so an edge parsed from
+     * `A:f0:ne -> B` round-trips through the port syntax rather than through a
+     * `tailport="f0:ne"` attribute.
+     *
+     * C reads the value with agxget, which falls back to the edge dict default,
+     * and gates on the SYMBOL existing at all — both are subsumed here by the
+     * attr-then-default lookup coming back undefined. An html-like value is
+     * canonicalized whole; a plain one splits on its FIRST `:` (strchr) so the
+     * port and the compass point are canonicalized separately.
+     * @see lib/cgraph/write.c:565 write_port
+     */
+    private portSuffix;
+    private writeEdge;
+    /** Root-graph attribute block: `_draw_`, `_ldraw_`, `bb`, `xdotversion`. */
+    private graphAttrs;
+    /** Cluster attribute block. C's xdot_end_cluster ALWAYS agsets `_draw_` when
+     *  the graph has clusters (even empty, e.g. peripheries=0), so emit it
+     *  unconditionally; `_ldraw_` only when the cluster has a label.
+     *  @see plugin/core/gvrender_core_dot.c:284 xdot_end_cluster */
+    private clusterAttrs;
+    /** Node attribute block: pos/width/height plus `_draw_`/`_ldraw_`. `scope` is
+     *  the subgraph the node is being WRITTEN in, whose node dict every value is
+     *  compared against. @see lib/cgraph/write.c:537-545 write_node */
+    private nodeAttrs;
+    /** The `[...]` attribute body for an edge (draw ops + spline `pos`), or ''. */
+    private edgeAttrStr;
+    /** `xlp` — only when the node HAS an xlabel AND the xlabel placer actually set
+     *  its position (`ND_xlabel(n)->set`). An xlabel that was never placed is
+     *  omitted entirely, so an input `xlp` survives and is echoed.
+     *  @see lib/common/output.c:309-313 */
+    private nodeXlpPart;
+    /** `rects` — record field boxes. C gates on the SHAPE NAME being exactly
+     *  "record" (`strcmp(ND_shape(n)->name, "record") == 0`), so `Mrecord` and
+     *  HTML-table nodes get NO rects; confirmed against the native oracle. When
+     *  the shape is not a record the input's `rects` is never overwritten and is
+     *  echoed — patchwork forces every node to `box`, so a re-fed dot output
+     *  returns its old record rects untouched. @see lib/common/output.c:314-317 */
+    private nodeRectsPart;
+    /** The six `_draw_`-family attributes of an edge, in C's order. */
+    private edgeDrawParts;
+    /**
+     * `lp`/`xlp`/`head_lp`/`tail_lp` for one edge, in C's order.
+     *
+     * Note the asymmetry C encodes: `lp`/`head_lp`/`tail_lp` are emitted whenever
+     * the label EXISTS, but `xlp` additionally requires `->set` — an unplaced
+     * xlabel is omitted. Each gate is independent, and each FAILED gate leaves the
+     * input's own value in the slot for write.c to echo: an unrouted edge
+     * (patchwork routes none) returns the `lp` a previous dot run wrote.
+     * @see lib/common/output.c:377-396
+     */
+    private edgeLabelPosParts;
+}
+//# sourceMappingURL=agwrite.d.ts.map

package/dist/render/dot/agwrite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agwrite.d.ts","sourceRoot":"","sources":["../../../src/render/dot/agwrite.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAChD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAYhD,OAAO,KAAK,EAAE,SAAS,EAAU,MAAM,YAAY,CAAC;AAEpD,kFAAkF;AAClF,8BAAsB,aAAa;IACjC,yCAAyC;IACzC,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC/C,gFAAgF;IAChF,SAAS,CAAC,QAAQ,EAAE,KAAK,EAAE,CAAM;IACjC,wEAAwE;IACxE,SAAS,CAAC,QAAQ,CAAC,OAAO,CAAC,GAAG,EAAE,IAAI,GAAG,IAAI,GAAG,KAAK,GAAG,SAAS,GAAG,SAAS;IAE3E;;;;;;;;OAQG;IACH,OAAO,CAAC,QAAQ;IAIhB,kDAAkD;IAClD,OAAO,CAAC,KAAK;IAMb;;;;;;;;;OASG;IACH,SAAS,CAAC,SAAS,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM;IAgBrC,8DAA8D;IAC9D,OAAO,CAAC,OAAO;IAOf,2EAA2E;IAC3E,OAAO,CAAC,WAAW;IAInB;;;;oFAIgF;IAChF,OAAO,CAAC,KAAK;IAIb;;;uFAGmF;IACnF,OAAO,CAAC,kBAAkB;IAe1B;;;;;;;;;qDASiD;IACjD,OAAO,CAAC,cAAc;IAUtB,OAAO,CAAC,MAAM;IAId,6BAA6B;IAC7B,OAAO,CAAC,QAAQ;IAehB;;;OAGG;IACH,OAAO,CAAC,UAAU;IAWlB;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,CAAC,SAAS;IAejB;;;;;;;OAOG;IACH,OAAO,CAAC,YAAY;IAapB,6BAA6B;IAC7B,OAAO,CAAC,QAAQ;IAKhB,+BAA+B;IAC/B,OAAO,CAAC,UAAU;IAYlB,8EAA8E;IAC9E,OAAO,CAAC,SAAS;IAmBjB;;;uFAGmF;IACnF,OAAO,CAAC,aAAa;IAKrB;0EACsE;IACtE,OAAO,CAAC,YAAY;IAQpB,mCAAmC;IACnC,OAAO,CAAC,aAAa;IAIrB,8BAA8B;IAC9B,OAAO,CAAC,SAAS;IAUjB,+EAA+E;IAC/E;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAC,UAAU;IASlB,OAAO,CAAC,SAAS;IAajB,4EAA4E;IAC5E,OAAO,CAAC,UAAU;IAgBlB;;;oEAGgE;IAChE,OAAO,CAAC,YAAY;IAYpB;;uEAEmE;IACnE,OAAO,CAAC,SAAS;IAwBjB,+EAA+E;IAC/E,OAAO,CAAC,WAAW;IAyBnB;;;2CAGuC;IACvC,OAAO,CAAC,WAAW;IAOnB;;;;;mFAK+E;IAC/E,OAAO,CAAC,aAAa;IASrB,mEAAmE;IACnE,OAAO,CAAC,aAAa;IAYrB;;;;;;;;;OASG;IACH,OAAO,CAAC,iBAAiB;CAqB1B"}

package/dist/render/dot/attrs.d.ts

@@ -0,0 +1,220 @@
+/**
+ * Attribute helpers for the `-Tdot` writer — the `attach_attrs_and_arrows`
+ * side of output.c, plus the value-record and dict-default rules
+ * write_nondefault_attrs / write_dict compare against.
+ *
+ * @see lib/common/output.c:254 attach_attrs_and_arrows
+ * @see lib/cgraph/write.c:471 write_nondefault_attrs
+ */
+import type { Graph } from '../../model/graph.js';
+import type { Node } from '../../model/node.js';
+import type { Edge } from '../../model/edge.js';
+import type { FieldT } from '../../common/types.js';
+/**
+ * C's `attach_attrs` edge loop skips IGNORED edges and edges with no spline
+ * (`ED_spl(e) == NULL`) via `continue`, so such an edge is attached NEITHER
+ * `pos` NOR any of `lp`/`xlp`/`head_lp`/`tail_lp` — even when it carries a
+ * label. All five attributes therefore share this one gate.
+ * @see lib/common/output.c:349-353
+ */
+export declare function edgeAttrsAttached(e: Edge): boolean;
+/**
+ * Append the leaf-field rectangles of a record node, mirroring the recursion in
+ * `set_record_rects`: a field with sub-fields contributes nothing itself, while
+ * a LEAF field (`n_flds == 0`) contributes its box translated by the node centre
+ * as `llx,lly,urx,ury` at `%.5g`. C emits each field followed by a space and
+ * then pops the trailing one — joining with a single space is equivalent.
+ * @see lib/common/output.c:215 set_record_rects
+ */
+export declare function appendRecordRects(n: Node, f: FieldT, out: string[]): void;
+/**
+ * Echo an attribute that `attach_attrs_and_arrows` did NOT overwrite.
+ *
+ * Every computed attribute is `agset` behind a gate (`rects` only for a
+ * `record` shape; an edge's `lp` only for a routed edge that HAS a label;
+ * a graph's `lp` only when `GD_label(g)` exists...). When the gate FAILS, C
+ * simply does not write — so the slot keeps whatever the INPUT file parsed
+ * into it, and `agwrite` (which serializes the whole attribute table, not
+ * just the fields layout computed) prints that stale value verbatim. This is
+ * highly visible under patchwork, which forces every shape to `box` and routes
+ * no edges: on a re-fed dot output (most of the corpus) native echoes back the
+ * `rects` / `lp` a *previous* dot run wrote, in that run's coordinate space.
+ *
+ * cgraph interns attribute strings, so a value equal to the declared (empty)
+ * default is the SAME pointer as the default and write.c's
+ * `data->str[sym->id] != sym->defval` test drops it — hence an empty value is
+ * never printed.
+ * @see lib/cgraph/write.c:427 write_nondefault_attrs · lib/common/output.c:270
+ */
+/** Names the serializer computes for a node; never echoed from input. */
+export declare const COMPUTED_NODE_ATTRS: Set<string>;
+/** Names the serializer computes for an edge. `tailport`/`headport` are excluded
+ *  too: write_nondefault_attrs skips those symbols because they are written as
+ *  `:port` syntax on the endpoints instead. @see lib/cgraph/write.c:487-492 */
+export declare const COMPUTED_EDGE_ATTRS: Set<string>;
+/** dot's synthesized AGNODE `label` default. @see lib/common/const.h NODENAME_ESC */
+export declare const NODENAME_ESC = "\\N";
+/** Effective edge defaults at `scope`, inner overriding outer — mirrors the
+ *  builder's snapshotEdgeDefaults walk (builder.ts:294). Edges have no stored
+ *  snapshot: the builder copies inherited defaults straight into `edge.attrs`,
+ *  so the only way to tell a defaulted value from an explicit one is to compare
+ *  against this walk. That merge also means `edge.attrs` already IS the cgraph
+ *  value record `objInputParts` expects — the node side has to build one
+ *  (`nodeRecord`) because node defaults are kept in a separate snapshot. */
+export declare function effectiveEdgeDefaults(scope: Graph): Map<string, string>;
+/**
+ * Effective node defaults at `scope`, inner overriding outer — the dict
+ * write_node compares each node against (`d`, threaded from write_body,
+ * write.c:537-545). This is the scope the node is WRITTEN in, which is not
+ * necessarily where it was created.
+ *
+ * Includes dot's synthesized `label` default: `graph_init` installs
+ * NODENAME_ESC on the root when the input declares none (input.c:737-739), and
+ * it is part of the dict C compares against. `nodeRecord` seeds the same value
+ * under the same condition so the two cancel — omitting it from either side
+ * would print `label="\N"` (or `label=""`) on every node in the corpus.
+ * @see lib/cgraph/write.c:537-545 write_node · lib/common/input.c:737-739
+ */
+export declare function effectiveNodeDefaults(scope: Graph): Map<string, string>;
+/**
+ * One node's cgraph value RECORD: the node-dict defaults in effect where the
+ * node was CREATED, overridden by its own explicit attributes.
+ *
+ * `addattr` seeds a node's slot from the default at declaration time and an
+ * explicit `n [k=v]` overwrites it; neither is disturbed by a LATER
+ * `node [k=…]` in the same scope, which only moves the dict symbol. That gap is
+ * the whole mechanism: `{node[shape=house]; A; node[shape=invhouse]; B}` leaves
+ * A's record at `house` against a dict default of `invhouse`, so C prints
+ * `shape=house` on A and nothing on B.
+ * @see lib/cgraph/attr.c:210 addattr · lib/cgraph/write.c:485
+ */
+export declare function nodeRecord(n: Node): Map<string, string>;
+/**
+ * One object's attribute block: every name whose value RECORD differs from the
+ * writing scope's dict default. A name in the dict but not the record compares
+ * as empty and prints as `k=""` — `digraph G { a; node[color=red]; b; }` emits
+ * `a [color=""]`, which a record-only walk structurally cannot produce.
+ * @see lib/cgraph/write.c:471 write_nondefault_attrs
+ */
+export declare function objInputParts(record: Map<string, string>, defaults: Map<string, string>, computed: Set<string>): string[];
+/**
+ * A COMPUTED node/edge attribute, dropped when its value equals the applicable
+ * dict default.
+ *
+ * `safe_dcl` declares each computed name with an empty default only when the
+ * symbol does not already exist — an input file that says `node [width=0.5]`
+ * leaves `sym->defval` at `0.5`. cgraph interns strings, so `agxset`ing a
+ * computed `0.5` stores the SAME refstr as the default and
+ * write_nondefault_attrs' `data->str[sym->id] != sym->defval` test drops it.
+ * tests/graphs/arrows.gv is the clean case: every node emits `height=0.5`
+ * (no declared default) but none emits `width`.
+ *
+ * `formatted` is passed in rather than derived so each call site keeps its own
+ * quoting; `raw` is the unquoted text that C would have interned.
+ * @see lib/common/utils.c:1065 safe_dcl · lib/cgraph/write.c:485
+ */
+export declare function computedPart(key: string, raw: string, defaults: Map<string, string> | undefined): string[];
+/** Attribute names the serializer computes itself; input values are echoed by
+ *  `graphInputParts`, so these must not be echoed twice. */
+export declare const COMPUTED_GRAPH_ATTRS: Set<string>;
+/** Walk to the root graph (cgraph `agroot`). */
+export declare function rootOf(g: Graph): Graph;
+/**
+ * A scope's own graph-attribute dict entries — the INPUT attributes, echoed by
+ * write_dict because in cgraph a graph's attributes ARE its dict defaults.
+ *
+ * For a non-root scope the test is PROVENANCE, not value. `setattr` gives a
+ * subgraph its own dict symbol for every attribute the input declares in that
+ * scope, and write_dict prints each local symbol whose value is non-empty —
+ * there is no comparison against the inherited value, so re-declaring an
+ * attribute to the value it already inherited still prints. Oracle-pinned:
+ * `digraph G { foo="x"; { foo="x"; a; b } }` emits `foo=x` on the subgraph.
+ *
+ * The only entries in `attrs` that are NOT local declarations are the ones the
+ * builder seeded from the snapshot so cluster-label inheritance survives the
+ * layout's cluster rebuilds; those carry no dict symbol in C and are recorded in
+ * `seededAttrs`. (A value-equality test stood in for this before the marker
+ * existed, and wrongly swallowed genuine re-declarations.)
+ *
+ * Also reproduces C's EAGER-propagation artifact. `agattr` creating a NEW global
+ * graph attribute runs `agapply(root, addattr, rsym, true)`, installing the
+ * symbol — with its pre-declaration (empty) default — on every subgraph that
+ * ALREADY EXISTS. So a subgraph opened before the declaration carries a local
+ * empty value and agwrite prints e.g. `rankdir=""`, while a sibling opened after
+ * it inherits and prints nothing. `graphDefaultsSnapshot` records exactly which
+ * defaults were in effect when the scope opened, so "declared at root after this
+ * scope opened" is `root.attrs.has(k) && !snapshot.has(k)`.
+ * @see lib/cgraph/attr.c:287 (agapply/addattr) · lib/cgraph/write.c:262
+ */
+export declare function graphInputParts(g: Graph, top: boolean, emitDraws: boolean): string[];
+/**
+ * `name=value` parts for one attribute-default map, values canonicalized by the
+ * `_agstrcanon` port (conditional quoting — `rankdir=LR` bare, `bb="0,0,1,1"`
+ * quoted), matching write_canonstr. @see lib/cgraph/write.c:write_canonstr
+ */
+export declare function dictParts(defaults: Map<string, string>): string[];
+/**
+ * Node-dict parts for a scope. At the root, dot's `graph_init` installs an
+ * AGNODE `label` default of NODENAME_ESC (`\N`) when absent — the port models
+ * attributes as per-object Maps and reproduces that default at each use-site
+ * (see the N_label note in common/graph-init.ts), and the serializer is such a
+ * use-site. An explicit root-level `node [label=...]` wins over the synthesized
+ * default. @see lib/common/input.c:737-739 (N_label)
+ */
+export declare function nodeDictParts(g: Graph, top: boolean): string[];
+export declare function echoAttr(attrs: Map<string, string>, key: string): string[];
+/**
+ * write_dict's conditional empty-value skip, as OBSERVED against the oracle.
+ *
+ * A non-empty local value always prints. An empty one is dropped only when the
+ * INHERITED value is present and empty too; an inherited value that is absent
+ * or non-empty leaves the empty local value printed, and so does the root,
+ * which inherits nothing. Pinned with `digraph G { [foo=<i>;] { foo=""; … } }`:
+ * inherited absent PRINTS, inherited `"x"` PRINTS, inherited `""` SKIPS, and
+ * the root's own `foo=""` PRINTS in every one of those.
+ *
+ * Neither half of the C's guard can be read literally. `Agsym_t.print`
+ * (cgraph.h:644) is assigned nowhere in the tree, so porting
+ * `EMPTY(psym->defval) && psym->print` verbatim makes the parent-empty skip
+ * unreachable; and the `view == NULL` skip would drop the root's `foo=""`,
+ * which native prints. The observed rule is authoritative here.
+ * @see lib/cgraph/write.c:271-278 write_dict
+ */
+export declare function writeDictSkips(v: string, inherited: string | undefined): boolean;
+/**
+ * `echoAttr` for a GRAPH attribute the layout did not overwrite — same as
+ * echoAttr except an EMPTY value can still be emitted, per `writeDictSkips`.
+ * So a re-fed dot output whose `{rank=same}` block carries `bb=""`/`lp=""`
+ * under a boxed, labelled cluster echoes both back verbatim
+ * (tests/share/KW91.gv).
+ */
+export declare function echoGraphAttr(g: Graph, key: string): string[];
+/**
+ * The `lp`/`lwidth`/`lheight` triple for a graph or cluster, in C's order.
+ * `rec_attach_bb` attaches them to the root graph AND recursively to every
+ * cluster, but ONLY when the graph carries a label with non-empty text
+ * (`GD_label(g) && GD_label(g)->text[0]`) — an absent or empty-text label emits
+ * none of the three. `lp` is the label centre in points (`%.5g`); `lwidth` and
+ * `lheight` are the label's `dimen` converted to inches and written `%.2f`.
+ * When the gate fails, the input's own values survive and are echoed: patchwork
+ * and osage never build a cluster label object, so a re-fed dot file's cluster
+ * `lp` comes straight back out.
+ * @see lib/common/output.c:239-248 rec_attach_bb
+ */
+export declare function graphLabelAttrs(g: Graph): string[];
+/**
+ * Format edge spline points for the DOT `pos` attribute. Per bezier: the start
+ * endpoint `s,sp` when `sflag` set, then the end endpoint `e,ep` when `eflag`
+ * set, then `bez.size` control points — all at `%.5g`, exactly as native's
+ * spline serialization. Beziers are separated by `;`, points within one by a
+ * space. @see lib/common/output.c:353-372
+ */
+export declare function formatEdgePos(e: Edge): string;
+/** `formatEdgePos`'s value without the `pos="…"` wrapper — the text C interns
+ *  and compares against the symbol default. `null` when no `pos` is attached. */
+export declare function edgePosRaw(e: Edge): string | null;
+/** Return the edge connector token. */
+export declare function edgeConnector(directed: boolean): string;
+/** Return true if the graph is directed or strict-directed. */
+export declare function isDirected(g: Graph): boolean;
+//# sourceMappingURL=attrs.d.ts.map

package/dist/render/dot/attrs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attrs.d.ts","sourceRoot":"","sources":["../../../src/render/dot/attrs.ts"],"names":[],"mappings":"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"}

package/dist/render/dot/edge-draw.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Edge spline + arrow draw-op emission — emit.c's multicolor / tapered / ortho
+ * branches, split out of dot.ts for file size. Same abstract-base approach as
+ * agwrite.ts: every body moves UNCHANGED and reaches the renderer's emit state
+ * (`penwidth`, `styleOp`, `penOp`) through inheritance rather than injection,
+ * so each branch stays diffable against the C.
+ *
+ * @see lib/common/emit.c:2389 multicolor · :2422 tapered · :2583 ortho
+ */
+import type { Edge } from '../../model/edge.js';
+import type { Bezier } from '../../model/geom.js';
+import type { ArrowDrawOp } from '../../common/arrows-types.js';
+import type { RenderJob } from '../../gvc/job.js';
+import { EmitState } from '../../gvc/job.js';
+import { DotWriterBase } from './agwrite.js';
+/** emit.c's edge-drawing half, between the serializer base and the renderer. */
+export declare abstract class EdgeDrawBase extends DotWriterBase {
+    /** setlinewidth state per emit_state. @see gvrender_core_dot.c penwidth[] */
+    protected penwidth: number[];
+    protected abstract styleOp(job: RenderJob): string;
+    protected abstract penOp(job: RenderJob): string;
+    /**
+     * The plain single-colour spline branch of beginEdge — lifted verbatim so the
+     * four-way spline-kind chain above stays readable; no branch was reordered or
+     * merged. splines=ortho + radius/style=rounded emits straight segments plus
+     * corner arcs as polylines (L), else the bezier itself.
+     * @see lib/common/emit.c:2583
+     */
+    protected emitPlainSpline(e: Edge, list: Bezier[], edraw: string[], job: RenderJob): void;
+    /** One bezier of a plain spline: rounded-ortho corner polylines when a radius
+     *  applies and the segment has enough control points, else the bezier. */
+    protected emitSplineBezier(bez: Bezier, radius: number | null, edraw: string[], job: RenderJob): void;
+    protected emitTaperedSpline(e: Edge, bz: Bezier | undefined, edraw: string[], job: RenderJob): void;
+    /**
+     * Emit a split-along-length `;` multicolor edge spline: split each routed
+     * bezier along its arc length into one sub-curve per color segment, drawn
+     * under that segment's pen. Reuses the same split geometry
+     * (splitSplineByColor) as the SVG path. @see lib/common/emit.c:1975 multicolor
+     */
+    protected emitSplitSpline(bzList: (Bezier | undefined)[], colorAttr: string, edraw: string[], job: RenderJob): {
+        firstColor: string;
+        endColor: string;
+    };
+    /**
+     * Emit the parallel-multicolor edge spline: one offset Bézier per color,
+     * offset SEP=2.0 perpendicular per pass — reusing the same offset geometry
+     * (buildOffsetLists/advanceTmpList) as the SVG parallel-edge path.
+     * @see lib/common/emit.c:2443 (parallel multicolor) / svg-parallel-edge.ts
+     */
+    protected emitParallelSpline(bzList: (Bezier | undefined)[], colorAttr: string, numc: number, edraw: string[], job: RenderJob): {
+        headColor: string;
+        tailColor: string;
+    };
+    /** Emit one arrow's primitive ops into `buf` (pen/fill from the edge color).
+     *  arrow_gen sets the default line style ("solid") and the edge penwidth
+     *  before each primitive, so a non-default penwidth emits `S setlinewidth(N)`
+     *  once (tracked per HDRAW/TDRAW state). @see arrows.c:arrow_gen */
+    protected emitArrows(buf: string[], ops: ArrowDrawOp[] | undefined, job: RenderJob, state: EmitState, penOverride?: string): void;
+}
+//# sourceMappingURL=edge-draw.d.ts.map

package/dist/render/dot/edge-draw.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edge-draw.d.ts","sourceRoot":"","sources":["../../../src/render/dot/edge-draw.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAGhD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAEhE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAS7C,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAgC7C,gFAAgF;AAChF,8BAAsB,YAAa,SAAQ,aAAa;IACtD,6EAA6E;IAC7E,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,CAAyB;IACrD,SAAS,CAAC,QAAQ,CAAC,OAAO,CAAC,GAAG,EAAE,SAAS,GAAG,MAAM;IAClD,SAAS,CAAC,QAAQ,CAAC,KAAK,CAAC,GAAG,EAAE,SAAS,GAAG,MAAM;IAEhD;;;;;;OAMG;IACH,SAAS,CAAC,eAAe,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,SAAS,GAAG,IAAI;IAmBzF;8EAC0E;IAC1E,SAAS,CAAC,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,SAAS,GAAG,IAAI;IAUrG,SAAS,CAAC,iBAAiB,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,MAAM,GAAG,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,SAAS,GAAG,IAAI;IAWnG;;;;;OAKG;IACH,SAAS,CAAC,eAAe,CACvB,MAAM,EAAE,CAAC,MAAM,GAAG,SAAS,CAAC,EAAE,EAC9B,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,EAAE,EACf,GAAG,EAAE,SAAS,GACb;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE;IAe3C;;;;;OAKG;IACH,SAAS,CAAC,kBAAkB,CAC1B,MAAM,EAAE,CAAC,MAAM,GAAG,SAAS,CAAC,EAAE,EAC9B,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EAAE,EACf,GAAG,EAAE,SAAS,GACb;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE;IAyB3C;;;wEAGoE;IACpE,SAAS,CAAC,UAAU,CAClB,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,WAAW,EAAE,GAAG,SAAS,EAAE,GAAG,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,EAC/E,WAAW,CAAC,EAAE,MAAM,GACnB,IAAI;CAgBR"}