@knowvah/dot-engine 0.1.0

package/dist/api.js

@@ -0,0 +1,719 @@
+// src/model/graphInfo.ts
+function makeGraphInfo() {
+  return {
+    bb: { ll: { x: 0, y: 0 }, ur: { x: 0, y: 0 } },
+    rankdir: 0,
+    flags: 0,
+    charset: 0,
+    gui_state: 0,
+    has_labels: 0,
+    has_images: false
+  };
+}
+
+// src/model/graph.ts
+var Graph = class {
+  /** Graph name; agnameof equivalent. @see lib/cgraph/cgraph.h:agnameof */
+  name;
+  /**
+   * True when the graph was declared with NO name (`digraph {`), as opposed to
+   * an explicit empty name (`digraph "" {`). Both store `name === ''`, but
+   * cgraph gives the truly-anonymous root the internal id `%1` (agnameof) while
+   * the empty-named one keeps `""`. Only the imagemap `<map id/name>` reads this
+   * (map.ts:mapGraphName); dot/xdot re-serialization keeps `name` so an
+   * anonymous root round-trips as `digraph {`, not `digraph %1 {`.
+   * @see lib/cgraph/id.c:idmap (anon → `%1`) ; lib/cgraph/agraph.c:agnameof
+   */
+  anonymous;
+  /**
+   * Directed/strict classification; mirrors Agdesc_t.directed and
+   * Agdesc_t.strict. @see lib/cgraph/cgraph.h:Agdesc_s
+   */
+  kind;
+  /**
+   * Node set in insertion order, keyed by name.
+   * Mirrors Agraph_t.n_seq (sequence dict) merged with n_id access.
+   * @see lib/cgraph/cgraph.h:Agraph_s
+   */
+  nodes;
+  /**
+   * All edges owned by this graph (root graph only for ownership; subgraphs
+   * reference a subset). Mirrors Agraph_t.e_seq.
+   * @see lib/cgraph/cgraph.h:Agraph_s
+   */
+  edges;
+  /**
+   * Named subgraphs, keyed by name. Mirrors Agraph_t.g_seq/g_id.
+   * @see lib/cgraph/cgraph.h:Agraph_s
+   */
+  subgraphs;
+  /**
+   * String attributes (agget/agset equivalents).
+   * Replaces the Agattr_t / Agsym_t machinery for simple key-value access.
+   * @see lib/cgraph/cgraph.h:Agattr_s
+   */
+  attrs;
+  /** Default attributes applied to all nodes in this graph scope. */
+  nodeDefaults;
+  /** Default attributes applied to all edges in this graph scope. */
+  edgeDefaults;
+  /**
+   * Snapshot of the enclosing graphs' graph-attribute defaults (this graph ->
+   * root, inner wins) captured when this subgraph was OPENED during parsing.
+   * Graph attributes set on an ancestor AFTER this subgraph was created are not
+   * included — mirroring cgraph's parse-time agsubg defval copy. Used for
+   * order-correct label/font inheritance (e.g. a root `label=` declared after a
+   * cluster must NOT apply to that cluster). Undefined on the root graph.
+   * @see lib/cgraph/graph.c:agsubg (attr defval copy)
+   */
+  graphDefaultsSnapshot;
+  /**
+   * Layout-engine info; replaces GD_* macros via agbindrec (AD-1).
+   * @see lib/cgraph/cgraph.h:agbindrec
+   */
+  info;
+  /**
+   * Immediate parent graph. null for root graphs.
+   * @see lib/cgraph/cgraph.h:Agraph_s
+   */
+  parent;
+  /**
+   * Root (main) graph. Self-referential for root graphs;
+   * points up for subgraphs.
+   * @see lib/cgraph/cgraph.h:Agraph_s
+   */
+  root;
+  /**
+   * Subgraph sequence number (AGSEQ). A global counter on the root, assigned
+   * at creation in source order, counting anonymous subgraphs. The root keeps
+   * the default 0 (par == NULL never calls agnextseq). Consumed by getObjId to
+   * emit cluster ids `clust<seq>`.
+   * @see lib/cgraph/cgraph.h:AGSEQ
+   * @see lib/cgraph/graph.c:agopen (AGSEQ(g) = agnextseq(par, AGRAPH))
+   */
+  seq = 0;
+  /**
+   * Root-only counter mirroring `clos->seq[AGRAPH]`: the running maximum AGSEQ
+   * handed out to subgraphs. Meaningful only on the root graph; `assignSubgSeq`
+   * pre-increments it. Other graphs leave it at 0.
+   * @see lib/cgraph/graph.c:agnextseq (++clos->seq[AGRAPH])
+   */
+  subgSeqCounter = 0;
+  /**
+   * Names of graph attributes (AGRAPH) declared anywhere in this hierarchy —
+   * the port's stand-in for cgraph's `Agsym_t` symbol table. Populated on the
+   * ROOT only, at parse time, whenever a graph attribute is assigned on any
+   * (sub)graph: setting `ordering=out` on a subgraph declares "ordering"
+   * graph-wide with an empty default, so `agGraphAttr(root, "ordering")` returns
+   * `""` (not undefined) — mirroring `agfindgraphattr`/`late_string`. Read via
+   * `agGraphAttr` (model/cgraph-ops.ts); empty on non-root graphs.
+   * @see lib/cgraph/attr.c:agattr (graph-wide declaration, "" default)
+   */
+  declaredGraphAttrs = /* @__PURE__ */ new Set();
+  /** @see lib/cgraph/graph.c:agopen */
+  constructor(name, kind, anonymous = false) {
+    this.name = name;
+    this.anonymous = anonymous;
+    this.kind = kind;
+    this.nodes = /* @__PURE__ */ new Map();
+    this.edges = [];
+    this.subgraphs = /* @__PURE__ */ new Map();
+    this.attrs = /* @__PURE__ */ new Map();
+    this.nodeDefaults = /* @__PURE__ */ new Map();
+    this.edgeDefaults = /* @__PURE__ */ new Map();
+    this.info = makeGraphInfo();
+    this.parent = null;
+    this.root = this;
+  }
+};
+
+// src/model/nodeInfo.ts
+function makeNodeInfo() {
+  return {
+    coord: { x: 0, y: 0 },
+    width: 0,
+    height: 0,
+    bb: { ll: { x: 0, y: 0 }, ur: { x: 0, y: 0 } },
+    ht: 0,
+    lw: 0,
+    rw: 0,
+    outline_width: 0,
+    outline_height: 0,
+    state: 0,
+    gui_state: 0,
+    clustnode: false,
+    // --- lazily-assigned fields, pre-declared to lock the hidden class ---
+    base_width: void 0,
+    base_height: void 0,
+    label: void 0,
+    xlabel: void 0,
+    shape: void 0,
+    shape_info: void 0,
+    rank: void 0,
+    order: void 0,
+    rankIsXCoord: void 0,
+    mval: void 0,
+    node_type: void 0,
+    ranktype: void 0,
+    weight_class: void 0,
+    mark: void 0,
+    onstack: void 0,
+    has_port: void 0,
+    showboxes: void 0,
+    in: void 0,
+    out: void 0,
+    flat_in: void 0,
+    flat_out: void 0,
+    other: void 0,
+    save_in: void 0,
+    save_out: void 0,
+    tree_in: void 0,
+    tree_out: void 0,
+    next: void 0,
+    prev: void 0,
+    par: void 0,
+    low: void 0,
+    lim: void 0,
+    priority: void 0,
+    UF_size: void 0,
+    UF_parent: void 0,
+    rep: void 0,
+    set: void 0,
+    clust: void 0,
+    posAlg: void 0,
+    pinned: void 0,
+    id: void 0,
+    heapindex: void 0,
+    hops: void 0,
+    pos: void 0,
+    dist: void 0,
+    alg: void 0
+  };
+}
+
+// src/model/node.ts
+var Node = class {
+  /**
+   * Unique integer ID per root graph; maps to AGID in the C implementation.
+   * @see lib/cgraph/cgraph.h:AGID
+   */
+  id;
+  /** Node name; agnameof equivalent. @see lib/cgraph/cgraph.h:agnameof */
+  name;
+  /**
+   * String attributes (agget/agset equivalents).
+   * @see lib/cgraph/cgraph.h:Agattr_s
+   */
+  attrs;
+  /**
+   * Layout-engine info; replaces ND_* macros via agbindrec (AD-1).
+   * @see lib/cgraph/cgraph.h:agbindrec
+   */
+  info;
+  /**
+   * Root graph that owns this node.
+   * @see lib/cgraph/cgraph.h:Agnode_s
+   */
+  root;
+  /**
+   * Frozen snapshot of the node-attribute defaults (`node [...]`) in effect —
+   * from the declaring subgraph up through its ancestors — at the moment this
+   * node was first created. Captured at creation (not read live at render) so
+   * that a `node [...]` declared *after* this node in the same or an ancestor
+   * scope does not retroactively apply, matching DOT semantics. Present on
+   * parser-built nodes (even when empty); undefined on programmatically created
+   * nodes, which fall back to live graph defaults in `nodeAttr`.
+   */
+  nodeDefaultsSnapshot;
+  /** @see lib/cgraph/node.c:agnode */
+  constructor(id, name, root) {
+    this.id = id;
+    this.name = name;
+    this.attrs = /* @__PURE__ */ new Map();
+    this.info = makeNodeInfo();
+    this.root = root;
+  }
+  /**
+   * Returns out-edges of this node in graph g (where this node is the tail).
+   *
+   * ORDER: cgraph's per-node out-edge dict sorts by the SEQ of the edge's
+   * out-half node — the HEAD — then by edge seq (edge.c:agedgeseqcmpf,
+   * Ag_mainedge_seq_disc). Iteration is therefore by (head creation order,
+   * edge creation order), NOT by plain edge insertion order. This ordering
+   * is load-bearing for emission order and for force-accumulation order in
+   * the iterative engines.
+   *
+   * INVARIANT: In the C cgraph library, the adjacency list for a node begins
+   * with the node's own self-loop (index 0), and neighbor traversal MUST start
+   * at index 1. This convention originates from lib/cgraph/edge.c and
+   * agfstedge/agnxtedge. In this TypeScript implementation, self-loops are
+   * included in outEdges() but are excluded from inEdges() — matching the
+   * agnxtedge behavior that skips self-loops as in-edges. Callers iterating
+   * over neighbors must account for self-loop edges appearing in outEdges().
+   *
+   * @see lib/cgraph/edge.c:agfstout
+   * @see lib/cgraph/edge.c:agnxtout
+   * @see lib/cgraph/edge.c:agedgeseqcmpf
+   */
+  outEdges(g) {
+    return g.edges.filter((e) => e.tail === this).sort((a, b) => a.head.id - b.head.id || a.seq - b.seq);
+  }
+  /**
+   * Returns in-edges of this node in graph g (where this node is the head).
+   * Self-loops are excluded per C agnxtedge semantics. Ordered by the SEQ
+   * of the in-half node — the TAIL — then edge seq (agedgeseqcmpf).
+   *
+   * @see lib/cgraph/edge.c:agfstin
+   * @see lib/cgraph/edge.c:agnxtin
+   * @see lib/cgraph/edge.c:agnxtedge (skips self-loops as in-edges)
+   * @see lib/cgraph/edge.c:agedgeseqcmpf
+   */
+  inEdges(g) {
+    return g.edges.filter((e) => e.head === this && e.tail !== this).sort((a, b) => a.tail.id - b.tail.id || a.seq - b.seq);
+  }
+};
+
+// src/model/cgraph-ops.ts
+var LOCALNAMEPREFIX = "%";
+function freshNodeId(root) {
+  let max = -1;
+  for (const n of root.nodes.values()) {
+    if (n.id > max) max = n.id;
+  }
+  return max + 1;
+}
+function agnode(g, name, create) {
+  const root = g.root;
+  if (name !== null && name !== "") {
+    const existing = root.nodes.get(name);
+    if (existing !== void 0) return existing;
+    if (!create) return null;
+    const node2 = new Node(freshNodeId(root), name, root);
+    root.nodes.set(name, node2);
+    return node2;
+  }
+  if (!create) return null;
+  const id = freshNodeId(root);
+  const anonName = LOCALNAMEPREFIX + String(id);
+  const node = new Node(id, anonName, root);
+  root.nodes.set(anonName, node);
+  return node;
+}
+function assignSubgSeq(parent, sg) {
+  sg.seq = ++parent.root.subgSeqCounter;
+}
+function agsubg(parent, name, create) {
+  const existing = parent.subgraphs.get(name);
+  if (existing !== void 0) return existing;
+  if (!create) return null;
+  const subg = new Graph(name, parent.kind);
+  subg.parent = parent;
+  subg.root = parent.root;
+  assignSubgSeq(parent, subg);
+  parent.subgraphs.set(name, subg);
+  return subg;
+}
+function agsubnode(g, n, create) {
+  if (g.root !== n.root) return null;
+  const existing = g.nodes.get(n.name);
+  if (existing !== void 0) return existing;
+  if (!create) return null;
+  const par = g.parent;
+  if (par !== null) {
+    agsubnode(par, n, create);
+  }
+  g.nodes.set(n.name, n);
+  return n;
+}
+
+// src/model/edgeInfo.ts
+function makePort() {
+  return {
+    p: { x: 0, y: 0 },
+    theta: 0,
+    bp: null,
+    defined: false,
+    constrained: false,
+    // C's default Center port has clip = true; edges clip to the node
+    // boundary unless head/tailclip disables it.
+    // @see lib/common/shapes.c:Center
+    clip: true,
+    dyna: false,
+    order: 0,
+    side: 0,
+    name: null
+  };
+}
+function makeEdgeInfo(tailPort, headPort) {
+  return {
+    tail_port: tailPort,
+    head_port: headPort,
+    // --- lazily-assigned fields, pre-declared to lock the hidden class ---
+    spl: void 0,
+    label: void 0,
+    head_label: void 0,
+    tail_label: void 0,
+    xlabel: void 0,
+    headArrowOps: void 0,
+    tailArrowOps: void 0,
+    constraint: void 0,
+    edge_type: void 0,
+    compound: void 0,
+    adjacent: void 0,
+    label_ontop: void 0,
+    gui_state: void 0,
+    to_orig: void 0,
+    to_virt: void 0,
+    lost: void 0,
+    alg: void 0,
+    weight: void 0,
+    minlen: void 0,
+    cutvalue: void 0,
+    tree_index: void 0,
+    xpenalty: void 0,
+    count: void 0,
+    conc_opp_flag: void 0,
+    showboxes: void 0,
+    stale_arrow_attrs: void 0,
+    factor: void 0,
+    dist: void 0,
+    path: void 0,
+    samehead: void 0,
+    sametail: void 0,
+    lhead: void 0,
+    ltail: void 0,
+    reversed: void 0
+  };
+}
+
+// src/model/edge.ts
+var Edge = class _Edge {
+  // Code review: process-wide static seq counter, never reset between renders
+  // (C's AGSEQ lives in a per-agopen Agclos_t). Safe today — every reader only
+  // compares .seq values within one graph's own edges for relative ordering —
+  // and it evades the module-globals fitness scan (a private static field, not
+  // a module-scope `let`). Revisit if any consumer serializes an absolute .seq
+  // or relies on the counter resetting per parse/createGraph.
+  /** @see lib/cgraph/cgraph.h:AGSEQ */
+  static _nextSeq = 0;
+  /**
+   * Monotone sequence number — equivalent to AGSEQ(e) in C.
+   * Used by edgeidcmpf for stable sort ordering.
+   *
+   * Mutable because C's new_virtual_edge overwrites a virtual edge's AGSEQ
+   * with AGSEQ(orig) after allocation; copyVirtualEdgeInfo mirrors that.
+   * @see lib/cgraph/cgraph.h:AGSEQ, lib/dotgen/fastgr.c:new_virtual_edge
+   */
+  seq;
+  /**
+   * Per-graph creation-order index (1-based).
+   * Set by the parser after root.edges.push(). Used as the SVG edge id,
+   * matching C's AGSEQ-based edge id assignment.
+   */
+  graphSeq = 0;
+  /**
+   * Source node (arrow origin).
+   * C: AGTAIL(e) = AGMKIN(e)->node = in.node
+   * @see lib/cgraph/cgraph.h:AGTAIL
+   */
+  tail;
+  /**
+   * Destination node (arrow target).
+   * C: AGHEAD(e) = AGMKOUT(e)->node = out.node
+   * @see lib/cgraph/cgraph.h:AGHEAD
+   */
+  head;
+  /**
+   * Edge key; empty string for anonymous edges.
+   * Corresponds to the `name` argument of agedge().
+   * @see lib/cgraph/cgraph.h:agedge
+   */
+  name;
+  /**
+   * String attributes (agget/agset equivalents).
+   * @see lib/cgraph/cgraph.h:Agattr_s
+   */
+  attrs;
+  /**
+   * Layout-engine info; replaces ED_* macros via agbindrec (AD-1).
+   * @see lib/cgraph/cgraph.h:agbindrec
+   */
+  info;
+  /** @see lib/cgraph/edge.c:agedge */
+  constructor(tail, head, name) {
+    this.seq = _Edge._nextSeq++;
+    this.tail = tail;
+    this.head = head;
+    this.name = name;
+    this.attrs = /* @__PURE__ */ new Map();
+    this.info = makeEdgeInfo(makePort(), makePort());
+  }
+};
+
+// src/api/edge-ops.ts
+function isUndirected(g) {
+  const k = g.root.kind;
+  return k === "undirected" || k === "strict-undirected";
+}
+function isStrict(g) {
+  const k = g.root.kind;
+  return k === "strict-directed" || k === "strict-undirected";
+}
+function findExistingEdge(root, tail, head, undirected) {
+  for (const e of root.edges) {
+    if (e.tail === tail && e.head === head) return e;
+    if (undirected && e.tail === head && e.head === tail) return e;
+  }
+  return null;
+}
+function insertEdge(g, root, edge) {
+  root.edges.push(edge);
+  edge.graphSeq = root.edges.length;
+  for (let cur = g; cur !== null && cur !== root; cur = cur.parent) {
+    cur.nodes.set(edge.tail.name, edge.tail);
+    cur.nodes.set(edge.head.name, edge.head);
+    cur.edges.push(edge);
+  }
+}
+function addEdge(g, tail, head, name) {
+  const root = g.root;
+  const undirected = isUndirected(g);
+  if (isStrict(g)) {
+    const existing = findExistingEdge(root, tail, head, undirected);
+    if (existing !== null) return existing;
+  }
+  const edge = new Edge(tail, head, name ?? "");
+  insertEdge(g, root, edge);
+  return edge;
+}
+
+// src/errors.ts
+var FRIENDLY_MESSAGES = {
+  SYNTAX_ERROR: "There is a syntax error in the DOT source.",
+  SYNTAX_UNEXPECTED_EOF: "The DOT source ended unexpectedly \u2014 a bracket or statement may be unclosed.",
+  EDGE_OP_DIRECTED_IN_UNDIRECTED: "A directed edge '->' was used in an undirected graph; use '--' instead.",
+  EDGE_OP_UNDIRECTED_IN_DIRECTED: "An undirected edge '--' was used in a directed graph; use '->' instead.",
+  HTML_PARSE_ERROR: "An HTML-like label could not be parsed.",
+  RENDER_ERROR: "The graph could not be laid out or rendered.",
+  GENERIC_ERROR: "An unexpected error occurred while rendering the graph."
+};
+function friendlyMessageFor(code) {
+  return FRIENDLY_MESSAGES[code];
+}
+var RenderError = class extends Error {
+  type = "render";
+  code;
+  friendlyMessage;
+  constructor(message, code = "RENDER_ERROR") {
+    super(message);
+    this.name = "RenderError";
+    this.code = code;
+    this.friendlyMessage = friendlyMessageFor(code);
+  }
+};
+
+// src/common/html-string.ts
+var HTML_STRING_MARK = "
";
+
+// src/api/builder.ts
+var NodeHandle = class {
+  /** @internal */
+  _node;
+  constructor(node) {
+    this._node = node;
+  }
+  get name() {
+    return this._node.name;
+  }
+  setAttr(k, v) {
+    this._node.attrs.set(k, v);
+  }
+  setHtmlAttr(k, v) {
+    this._node.attrs.set(k, HTML_STRING_MARK + v);
+  }
+  getAttr(k) {
+    return this._node.attrs.get(k);
+  }
+};
+var EdgeHandle = class {
+  /** @internal */
+  _edge;
+  constructor(edge) {
+    this._edge = edge;
+  }
+  get tail() {
+    return this._edge.tail.name;
+  }
+  get head() {
+    return this._edge.head.name;
+  }
+  setAttr(k, v) {
+    this._edge.attrs.set(k, v);
+  }
+  setHtmlAttr(k, v) {
+    this._edge.attrs.set(k, HTML_STRING_MARK + v);
+  }
+  getAttr(k) {
+    return this._edge.attrs.get(k);
+  }
+};
+function resolveNode(g, ref) {
+  if (typeof ref === "string") {
+    const node = agnode(g, ref, true);
+    if (node === null) {
+      throw new RenderError(`Failed to resolve node '${ref}' in graph '${g.name}'`, "GENERIC_ERROR");
+    }
+    return node;
+  }
+  return ref._node;
+}
+function applyAttrs(map, attrs) {
+  if (attrs === void 0) return;
+  for (const [k, v] of Object.entries(attrs)) {
+    map.set(k, v);
+  }
+}
+var GraphBuilder = class _GraphBuilder {
+  _graph;
+  _context;
+  constructor(graph, context) {
+    this._graph = graph;
+    this._context = context;
+  }
+  get graph() {
+    return this._graph;
+  }
+  addNode(name, attrs) {
+    return addNodeToContext(this._graph, this._context, name, attrs);
+  }
+  addEdge(tail, head, attrs) {
+    const tailNode = resolveNode(this._graph, tail);
+    const headNode = resolveNode(this._graph, head);
+    const edge = addEdge(this._graph, tailNode, headNode);
+    applyAttrs(edge.attrs, attrs);
+    return new EdgeHandle(edge);
+  }
+  addSubgraph(name, attrs) {
+    const sg = agsubg(this._context, name, true);
+    if (sg === null) {
+      throw new RenderError(`Failed to create subgraph '${name}'`, "GENERIC_ERROR");
+    }
+    applyAttrs(sg.attrs, attrs);
+    return new _GraphBuilder(this._graph, sg);
+  }
+  setAttr(k, v) {
+    this._context.attrs.set(k, v);
+  }
+  setHtmlAttr(k, v) {
+    this._context.attrs.set(k, HTML_STRING_MARK + v);
+  }
+  getAttr(k) {
+    return this._context.attrs.get(k);
+  }
+};
+function addNodeToContext(root, context, name, attrs) {
+  const node = agnode(root, name, true);
+  if (node === null) throw new RenderError(`Failed to create node '${name}'`, "GENERIC_ERROR");
+  applyAttrs(node.attrs, attrs);
+  if (context !== root) agsubnode(context, node, true);
+  return new NodeHandle(node);
+}
+var KIND_TABLE = {
+  "true:true": "strict-directed",
+  "true:false": "directed",
+  "false:true": "strict-undirected",
+  "false:false": "undirected"
+};
+function resolveKind(opts) {
+  const d = String(opts?.directed ?? true);
+  const s = String(opts?.strict ?? false);
+  return KIND_TABLE[`${d}:${s}`] ?? "directed";
+}
+function createGraph(opts) {
+  const g = new Graph(opts?.name ?? "", resolveKind(opts));
+  return new GraphBuilder(g, g);
+}
+
+// src/api/geometry.ts
+var INCHES_TO_POINTS = 72;
+function makeFlipY(bbHeight, yAxis) {
+  if (yAxis === "up") return (y) => y;
+  return (y) => bbHeight - y;
+}
+function snapshotNode(node, flipY) {
+  const coord = node.info.coord;
+  return {
+    name: node.name,
+    x: coord.x,
+    y: flipY(coord.y),
+    width: node.info.width * INCHES_TO_POINTS,
+    height: node.info.height * INCHES_TO_POINTS
+  };
+}
+function collectEdgePoints(edge, flipY) {
+  const spl = edge.info.spl;
+  if (spl === void 0) return [];
+  const pts = [];
+  for (const bz of spl.list) {
+    for (let k = 0; k < bz.size; k++) {
+      const pt = bz.list[k];
+      pts.push({ x: pt.x, y: flipY(pt.y) });
+    }
+  }
+  return pts;
+}
+function snapshotEdge(edge, flipY) {
+  const geom = {
+    tail: edge.tail.name,
+    head: edge.head.name,
+    points: collectEdgePoints(edge, flipY)
+  };
+  const lbl = edge.info.label;
+  if (lbl !== void 0) {
+    geom.label = { x: lbl.pos.x, y: flipY(lbl.pos.y) };
+  }
+  return geom;
+}
+function snapshotCluster(sg, yAxis, flipY) {
+  const bb = sg.info.bb;
+  return {
+    name: sg.name,
+    x: bb.ll.x,
+    // 'up' keeps the lower-left y; 'down' flips the upper-right y to the
+    // top-left of the box (flipY is monotonic-decreasing there).
+    y: yAxis === "up" ? bb.ll.y : flipY(bb.ur.y),
+    width: bb.ur.x - bb.ll.x,
+    height: bb.ur.y - bb.ll.y
+  };
+}
+function collectClusters(sg, yAxis, flipY, out) {
+  for (const c of sg.info.clust ?? []) {
+    if (c.info.bb !== void 0) out.push(snapshotCluster(c, yAxis, flipY));
+    collectClusters(c, yAxis, flipY, out);
+  }
+}
+function getLayout(g, opts) {
+  if (g.info?.laidOut !== true) {
+    throw new RenderError(
+      "getLayout requires a laid-out graph; run ctx.layout(g, engine) or render() first",
+      "GENERIC_ERROR"
+    );
+  }
+  const yAxis = opts?.yAxis ?? "down";
+  const bb = g.info.bb;
+  const bbWidth = bb.ur.x - bb.ll.x;
+  const bbHeight = bb.ur.y - bb.ll.y;
+  const flipY = makeFlipY(bbHeight, yAxis);
+  const bounds = yAxis === "down" ? { x: 0, y: 0, width: bbWidth, height: bbHeight } : { x: bb.ll.x, y: bb.ll.y, width: bbWidth, height: bbHeight };
+  const nodes = Array.from(g.nodes.values()).map((n) => snapshotNode(n, flipY));
+  const edges = g.edges.map((e) => snapshotEdge(e, flipY));
+  const clusters = [];
+  collectClusters(g, yAxis, flipY, clusters);
+  return { bounds, nodes, edges, clusters };
+}
+export {
+  addEdge,
+  createGraph,
+  getLayout
+};
+//# sourceMappingURL=api.js.map