@knowvah/dot-engine 1.9.0 → 2.0.1

package/src/index.ts

@@ -10,46 +10,42 @@
  */
 
 import { parse } from './parser/index.js';
-import { RenderError } from './errors.js';
+import {
+  InternalError,
+  invalidArgType,
+  isGvError,
+  isUsageError,
+  messageOf,
+  rethrowAtBoundary,
+} from './errors.js';
 import type { GvError, RenderResult } from './errors.js';
 import type { EngineName } from './gvc/context.js';
 import { render as deviceRender } from './gvc/device.js';
 import { createDefaultContext } from './gvc/default-context.js';
 
-/**
- * Duck-type a thrown value as a {@link GvError}: an object carrying a string
- * `type` and a string `code`. Covers `ParseError`, `HtmlParseError`, and
- * `RenderError` without per-subclass `instanceof`.
- */
-function isGvErrorLike(err: unknown): err is GvError {
-  return (
-    typeof err === 'object' &&
-    err !== null &&
-    typeof (err as { type?: unknown }).type === 'string' &&
-    typeof (err as { code?: unknown }).code === 'string'
-  );
-}
 
-/* v8 ignore start -- defensive normalizers for non-Error / genuinely-unknown
-   throws. Unreachable via the public API (renderSvg normalizes every throw to
-   GvError-like; parse only throws ParseError) but mandated by ADR-3 and the
-   render wrap. */
-function messageOf(err: unknown): string {
-  return err instanceof Error ? err.message : String(err);
-}
-function renderErrorFromUnknown(err: unknown): RenderError {
-  return new RenderError(messageOf(err), 'GENERIC_ERROR');
+
+/** Reject non-string `dotSource` / `engine` before any work starts. */
+function checkRenderArgs(dotSource: unknown, engine: unknown): void {
+  if (typeof dotSource !== 'string') {
+    throw invalidArgType('dotSource', 'string', dotSource);
+  }
+  if (typeof engine !== 'string') {
+    throw invalidArgType('engine', 'string', engine);
+  }
 }
-/* v8 ignore stop */
 
 /**
- * Normalize any thrown value to a plain, JSON-serializable {@link GvError}
- * (no stack). Structured throws are copied; unknown throws → `GENERIC_ERROR`.
+ * Normalize a thrown {@link GvError} to a plain, JSON-serializable data object
+ * (no stack, no `cause`). A value that is not a GvError is wrapped as an
+ * `InternalError` first.
  */
 function classifyError(err: unknown): GvError {
-  /* v8 ignore next -- the unknown-throw fallback is unreachable via the public
-     API (see helpers above); ADR-3 still mandates it. */
-  const gv: GvError = isGvErrorLike(err) ? err : renderErrorFromUnknown(err);
+  /* v8 ignore next 3 -- renderSvg already normalizes every non-usage throw to
+     a GvError, so only a throw escaping its context setup could land here. */
+  const gv: GvError = isGvError(err)
+    ? err
+    : new InternalError(messageOf(err), { cause: err });
   const out: GvError = {
     type: gv.type, code: gv.code, message: gv.message, friendlyMessage: gv.friendlyMessage,
   };
@@ -61,9 +57,14 @@ function classifyError(err: unknown): GvError {
 /**
  * Render a DOT-language string to SVG using the specified layout engine.
  *
- * Always throws a value implementing {@link GvError}: parse failures throw
- * `ParseError`; layout/render failures surface as `RenderError`
- * (`RENDER_ERROR`).
+ * Throws a {@link DotEngineError} for any problem with the input: `ParseError`
+ * (`SYNTAX_*`, `EDGE_OP_*`, `GENERIC_ERROR` for nesting too deep) for invalid
+ * DOT, `RenderError`
+ * (`RENDER_ERROR`, `UNKNOWN_LAYOUT`, `UNSUPPORTED_FEATURE`) for layout/render
+ * failures, and `InternalError` (`INTERNAL_ERROR`, `cause` = original) for a
+ * dot-engine bug. Invalid arguments throw a `TypeError` carrying a `code`. A
+ * malformed HTML-like label does not throw: as in C (htmlparse.y YYABORT) the
+ * label renders empty.
  *
  * @remarks
  * Security: when `dotSource` is untrusted, treat the returned SVG as
@@ -78,15 +79,21 @@ function classifyError(err: unknown): GvError {
  *                    ('dot', 'neato', 'fdp', 'sfdp', 'circo', 'twopi',
  *                    'osage', 'patchwork') or any custom-registered name
  * @returns SVG string
- * @throws ParseError if dotSource is not valid DOT
- * @throws RenderError if layout or rendering fails
+ * @throws TypeError `ERR_INVALID_ARG_TYPE` if `dotSource` or `engine` is not a string
+ * @throws TypeError `ERR_INVALID_ARG_VALUE` if `engine` names no registered engine
+ * @throws ParseError `SYNTAX_ERROR`, `SYNTAX_UNEXPECTED_EOF`,
+ *   `EDGE_OP_DIRECTED_IN_UNDIRECTED`, `EDGE_OP_UNDIRECTED_IN_DIRECTED` if
+ *   `dotSource` is not valid DOT
+ * @throws RenderError `RENDER_ERROR`, `UNKNOWN_LAYOUT` or `UNSUPPORTED_FEATURE`
+ *   if layout or rendering fails
+ * @throws InternalError `INTERNAL_ERROR` on a dot-engine bug
  */
 export function renderSvg(dotSource: string, engine: EngineName): string {
+  checkRenderArgs(dotSource, engine);
   const ctx = createDefaultContext();
   try {
     // parse() is inside the try so any non-ParseError throw (e.g. a raw
-    // RangeError from stack exhaustion) is still normalized to a GvError,
-    // honoring the "always throws a value implementing GvError" contract.
+    // RangeError from stack exhaustion) is still normalized (InternalError).
     const g = parse(dotSource);
     ctx.layout(g, engine);
     const svg = deviceRender(ctx, g, 'svg');
@@ -94,37 +101,40 @@ export function renderSvg(dotSource: string, engine: EngineName): string {
     ctx.freeLayout(g, engine);
     return svg;
   } catch (err: unknown) {
-    // A render-stage throw already implementing GvError (e.g. HtmlParseError)
-    // is re-surfaced unchanged; only genuinely-unknown throws become RENDER_ERROR.
-    /* v8 ignore next -- current engines don't throw a GvError-like value here */
-    if (isGvErrorLike(err)) throw err;
-    throw new RenderError(messageOf(err), 'RENDER_ERROR');
+    return rethrowAtBoundary(err);
   }
 }
 
 /**
  * Result-style render: returns `{ svg }` on success or `{ errors: [one] }` on
  * the first failure (svg XOR errors). Errors are plain JSON-serializable
- * {@link GvError} data objects.
+ * {@link GvError} data objects. Returns (never throws) for any DOT input and
+ * any failure of the graph itself; throws only for invalid arguments.
  *
  * @remarks
  * Security: same untrusted-input caveat as {@link renderSvg} — the returned
  * `svg` is attacker-controlled markup for untrusted `dotSource`; apply a CSP or
  * sanitize before embedding. See the README "Security" section.
+ *
+ * @throws TypeError `ERR_INVALID_ARG_TYPE` if `dotSource` or `engine` is not a string
+ * @throws TypeError `ERR_INVALID_ARG_VALUE` if `engine` names no registered engine
  */
 export function tryRenderSvg(dotSource: string, engine: EngineName): RenderResult {
+  checkRenderArgs(dotSource, engine);
   try {
     return { svg: renderSvg(dotSource, engine) };
   } catch (err: unknown) {
+    if (isUsageError(err)) throw err;
     return { errors: [classifyError(err)] };
   }
 }
 
 export { parse } from './parser/index.js';
 export { ParseError } from './parser/index.js';
-export { RenderError } from './errors.js';
+export { DotEngineError, InternalError, RenderError, isGvError } from './errors.js';
 export type {
   GvError,
+  UsageErrorCode,
   GvErrorType,
   GvErrorCode,
   GvExpectation,
@@ -163,3 +173,9 @@ export { render as renderWithContext } from './gvc/device.js';
 // rather than `render`. See decisions.md ADR-5 and the decision journal.
 export * from './api/index.js';
 export * from './render/index.js';
+
+// Async API (async-api ADR-7): renderAsync is re-exported via ./render above.
+export { renderSvgAsync } from './async/render-async.js';
+export type { AsyncSvgOptions, AsyncSvgResult } from './async/render-async.js';
+export { renderSvgInto } from './async/render-into.js';
+export type { RenderSvgIntoOptions, RenderSvgIntoResult } from './async/render-into.js';

package/src/label/index.ts

@@ -7,6 +7,7 @@
  */
 
 import { type Rect, overlap, combineRect, NUMDIMS } from './rectangle.js';
+import { InternalError } from '../errors.js';
 import {
   NODECARD,
   type Branch,
@@ -256,11 +257,14 @@ function rTreeInsert2(
   return 0; // should never happen
 }
 
-/** Validate rect: low side must be <= high side per dimension. */
+/**
+ * Validate rect: low side must be <= high side per dimension.
+ * @see label/index.c:RTreeInsert (assert at index.c:178)
+ */
 function validateRect(r: Rect): void {
   for (let i = 0; i < NUMDIMS; i++) {
     if (r.boundary[i] > r.boundary[NUMDIMS + i]) {
-      throw new Error('rTreeInsert: rect low > high');
+      throw new InternalError('rTreeInsert: rect low > high');
     }
   }
 }

package/src/label/node.ts

@@ -7,6 +7,7 @@
  * @see label/index.h
  */
 
+import { InternalError } from '../errors.js';
 import { type Rect, initRect, combineRect, rectArea, nullRect } from './rectangle.js';
 
 // C node.c uses uint64_t for bestIncr, bestArea, increase — subtraction wraps.
@@ -261,7 +262,7 @@ let _splitNodeImpl: (
   b: Branch,
   newNodeOut: { value: Node | null },
 ) => void = () => {
-  throw new Error('splitNode not yet registered — import split-q.ts first');
+  throw new InternalError('splitNode not yet registered — import split-q.ts first');
 };
 
 /** Register the splitNode implementation. Called by split-q.ts at load time. */

package/src/label/rectangle.ts

@@ -7,6 +7,8 @@
  * @see label/index.h
  */
 
+import { RenderError } from '../errors.js';
+
 /** @see label/index.h:NUMDIMS */
 export const NUMDIMS = 2;
 
@@ -71,7 +73,7 @@ export function nullRect(): Rect {
  * Returns 0 for undefined rects or zero-width dimensions.
  * Throws if area overflows Number.MAX_SAFE_INTEGER (browser-safe substitute
  * for C's graphviz_exit on UINT64_MAX overflow).
- * @see label/rectangle.c:RectArea
+ * @see label/rectangle.c:RectArea (agerrorf + graphviz_exit at rectangle.c:73)
  */
 export function rectArea(r: Rect): number {
   if (isUndefined(r)) return 0;
@@ -81,7 +83,7 @@ export function rectArea(r: Rect): number {
     const dim = r.boundary[i + NUMDIMS] - r.boundary[i];
     if (dim === 0) return 0;
     if (Number.MAX_SAFE_INTEGER / dim < area) {
-      throw new Error('label: area too large for rtree');
+      throw new RenderError('label: area too large for rtree', 'RENDER_ERROR');
     }
     area *= dim;
   }

package/src/layout/circo/circular.ts

@@ -159,14 +159,17 @@ export function copyPositions(_sg: SubGraph): void {
 // ---------------------------------------------------------------------------
 
 /**
- * Multi-component overlap adjustment stub. C runs adjustNodes(sg) on each
- * DERIVED component subgraph before packing (circularinit.c:212); porting
- * that requires width/pos plumbing on derived nodes and no divergent
- * corpus case reaches it yet. The single-component path (adjustNodesFull
- * on the real graph, circularinit.c:203) IS ported — see circoLayout.
+ * Per-component adjustNodes(sg). C calls it on each DERIVED component
+ * (circularinit.c:212), but the derived graph is a fresh root that never
+ * declares `overlap`, `normalize` or `scale`: agget(sg, "overlap") is NULL
+ * (AM_NONE) and removeOverlapWith only runs the no-op normalize/simpleScale.
+ * Verified against the native binary (T8, v2-silent-gaps): output is
+ * independent of those attributes, so this is a faithful no-op, not a gap.
+ * The single-component path (adjustNodesFull on the real graph,
+ * circularinit.c:203) IS ported — see circoLayout.
  */
 export function adjustNodes(_sg: SubGraph): void {
-  // deferred: see plans/xdot-conformance/decision-journal.md (PRISM entry)
+  // faithful no-op: the derived graph carries no overlap/normalize/scale attrs
 }
 
 // ---------------------------------------------------------------------------

package/src/layout/dot/pack-components.ts

@@ -20,6 +20,7 @@
  * @see lib/dotgen/dotinit.c:copyClusterInfo
  */
 
+import { InternalError } from '../../errors.js';
 import type { Graph } from '../../model/graph.js';
 import type { Node } from '../../model/node.js';
 import type { Point, Box } from '../../model/geom.js';
@@ -253,10 +254,13 @@ export function dotLayoutComponent(sg: Graph, root: Graph): void {
 // @see lib/dotgen/dotinit.c:copyClusterInfo (412)
 // ---------------------------------------------------------------------------
 
-/** Map a cluster clone back to its original root cluster. C's `mapClust`. */
+/**
+ * Map a cluster clone back to its original root cluster. C's `mapClust`.
+ * @see lib/pack/ccomps.c:mapClust (assert(op) at ccomps.c:366)
+ */
 function mapClust(clone: Graph, origOf: Map<Graph, Graph>): Graph {
   const orig = origOf.get(clone);
-  if (orig === undefined) throw new Error(`mapClust: no original for cluster ${clone.name}`);
+  if (orig === undefined) throw new InternalError(`mapClust: no original for cluster ${clone.name}`);
   return orig;
 }
 

package/src/layout/dot/position.ts

@@ -10,7 +10,11 @@ import type { Graph } from '../../model/graph.js';
 import type { Node } from '../../model/node.js';
 import type { Edge } from '../../model/edge.js';
 import { virtualNode } from './fastgr.js';
-import { SLACKNODE, LEAFSET } from './rank.js';
+import { SLACKNODE, LEAFSET, scaleClamp } from './rank.js';
+import { agGraphAttr } from '../../model/cgraph-ops.js';
+
+/** @see C INT_MAX — default network simplex iteration cap */
+const INT_MAX = 2147483647;
 import { rank } from './ns.js';
 import { markLowclusters } from './cluster.js';
 import {
@@ -103,8 +107,22 @@ export function connectGraph(g: Graph): void {
 // nsiter2 — @see lib/dotgen/position.c:nsiter2
 // ---------------------------------------------------------------------------
 
-/** @see lib/dotgen/position.c:nsiter2 — nslimit attribute not yet ported */
-export function nsiter2(_g: Graph): number { return 2147483647; }
+/**
+ * C's agget(g, "nslimit") INHERITS the root default, so a graph whose own
+ * attrs lack the key falls back to the parse-time snapshot, then the root
+ * (the same chain rank1 uses for nslimit1).
+ * @see lib/dotgen/position.c:nsiter2
+ */
+export function nsiter2(g: Graph): number {
+  const s = g.attrs.get('nslimit')
+    ?? g.graphDefaultsSnapshot?.get('nslimit')
+    ?? g.root.attrs.get('nslimit')
+    // Set only inside a subgraph: C declared it on the root with default "".
+    ?? agGraphAttr(g.root, 'nslimit');
+  if (s === undefined) return INT_MAX;
+  // atof: a non-numeric prefix parses as 0, not NaN.
+  return scaleClamp(g.nodes.size, parseFloat(s) || 0);
+}
 
 // ---------------------------------------------------------------------------
 // make_leafslots / expand_leaves — @see lib/dotgen/position.c

package/src/layout/fdp/derive.ts

@@ -22,6 +22,7 @@ import { Edge } from '../../model/edge.js';
 import type { Box } from '../../model/geom.js';
 import { doGraphLabel } from '../dot/graph-label.js';
 import { layoutMeasurer } from '../../common/nodeinit.js';
+import { inputscaleDivisor } from '../../common/utils-inputscale.js';
 import {
   type Bport,
   gdata,
@@ -79,8 +80,7 @@ function copyAttr(g: Graph, dg: Graph, attr: string): void {
 
 /**
  * Use a cluster's "coords" attribute, if any, for the initial position
- * of its derived node. PSinputscale (inputscale attr) is not ported —
- * no supported input sets it.
+ * of its derived node, divided by PSinputscale when > 0.
  * @see lib/fdpgen/layout.c:chkPos
  */
 function chkPos(g: Graph, n: Node, infop: LayoutInfo, bbp: Box): void {
@@ -92,10 +92,11 @@ function chkPos(g: Graph, n: Node, infop: LayoutInfo, bbp: Box): void {
   }
   const parsed = scanCoords(p);
   if (parsed === null) return; // C warns "expected four doubles"
-  bbp.ll.x = parsed.box.ll.x;
-  bbp.ll.y = parsed.box.ll.y;
-  bbp.ur.x = parsed.box.ur.x;
-  bbp.ur.y = parsed.box.ur.y;
+  const div = inputscaleDivisor(infop.rootg); // layout.c:320-324
+  bbp.ll.x = parsed.box.ll.x / div;
+  bbp.ll.y = parsed.box.ll.y / div;
+  bbp.ur.x = parsed.box.ur.x / div;
+  bbp.ur.y = parsed.box.ur.y / div;
   dndata(n).pinned = parsed.pinned;
 }
 

package/src/layout/fdp/index.ts

@@ -14,8 +14,10 @@ import type { Graph } from '../../model/graph.js';
 import type { LayoutEngine } from '../../gvc/context.js';
 import { setEdgeTypeFromAttr } from '../dot/index.js';
 import {
-  EDGETYPE_LINE, EDGETYPE_NONE, splineEdges, injectOraclePositions,
+  EDGETYPE_LINE, EDGETYPE_NONE, EDGETYPE_ORTHO, splineEdges, injectOraclePositions,
 } from '../neato/splines.js';
+import { EDGETYPE_COMPOUND } from '../dot/splines.js';
+import { RenderError } from '../../errors.js';
 import { neatoSetAspect } from '../neato/init.js';
 import { placeGraphLabel } from '../dot/position-bbox.js';
 import { gvPostprocess } from '../../common/postproc.js';
@@ -34,6 +36,10 @@ export { deriveGraph, type LayoutInfo } from './derive.js';
 export { fdpInitNodeEdge, fdpCleanup } from './init.js';
 export { fdpInitParams, fdpParms } from './tlayout-parms.js';
 
+/** @see lib/fdpgen/layout.c:fdpSplines (agwarningf text) */
+const CLUSTER_EDGE_WARNING =
+  'splines and cluster edges not supported - using line segments';
+
 /**
  * Graph-level initialization: edge type, gdata, clusters, parameters,
  * nodes and edges. GD_ndim is fixed at 2 (the "dim" attribute's 3D+
@@ -54,13 +60,47 @@ export function fdpInitGraph(g: Graph): void {
 }
 
 /**
- * Route edges by the resolved edge type. Compound (cluster) edges and
- * the HAS_CLUST_EDGE warning path are not ported — no supported input
- * has cluster-endpoint edges.
+ * Route edges with edge type `et`: splineEdges reads the type from GD_flags,
+ * so the C local `et = EDGETYPE_LINE` is applied for the call and restored.
+ * @see lib/neatogen/neatosplines.c:spline_edges1
+ */
+function splineEdges1(g: Graph, et: number): void {
+  const saved = g.info.flags;
+  g.info.flags = (saved & ~0xf) | et;
+  try {
+    splineEdges(g);
+  } finally {
+    g.info.flags = saved;
+  }
+}
+
+/**
+ * Route edges by the resolved edge type. C's State/Nop globals are not
+ * modeled: State < GVSPLINES at the tail holds exactly when the
+ * `et > EDGETYPE_ORTHO` block did not route (types <= ORTHO, or the
+ * HAS_CLUST_EDGE fallback), and Nop = 2 is only set on the compoundEdges
+ * path, which throws here. So the tail is the `else` of the block.
  * @see lib/fdpgen/layout.c:fdpSplines
  */
 function fdpSplines(g: Graph): void {
-  splineEdges(g); // spline_edges1(g, et) — straight lines + clipping
+  let et = g.info.flags & 0xf;
+  if (et > EDGETYPE_ORTHO) {
+    if (et === EDGETYPE_COMPOUND) {
+      // C: splineEdges(g, compoundEdges, EDGETYPE_SPLINE) — unported router.
+      throw new RenderError(
+        'splines=compound: cluster-avoiding edge routing (compoundEdges) is not supported yet',
+        'UNSUPPORTED_FEATURE',
+      );
+    }
+    if (g.info.n_cluster_edges) { // HAS_CLUST_EDGE(g)
+      console.warn(CLUSTER_EDGE_WARNING);
+      et = EDGETYPE_LINE;
+    } else {
+      splineEdges1(g, et);
+      return; // State == GVSPLINES
+    }
+  }
+  splineEdges1(g, et); // State < GVSPLINES
 }
 
 /**

package/src/layout/fdp/init.ts

@@ -17,6 +17,7 @@ import type { Graph } from '../../model/graph.js';
 import type { Node } from '../../model/node.js';
 import type { Edge } from '../../model/edge.js';
 import { commonInitNodeEdge, lateDouble, layoutMeasurer } from '../../common/nodeinit.js';
+import { inputscaleDivisor } from '../../common/utils-inputscale.js';
 import { initEdgeLabels } from '../../common/edge-label-init.js';
 import type { TextMeasurer } from '../../common/textmeasure.js';
 import { fdpParms } from './tlayout-parms.js';
@@ -25,24 +26,24 @@ import { processClusterEdges } from './cluster-edges.js';
 
 /**
  * Read user-supplied positions from the pos attribute (P_SET; P_PIN
- * with a "!" suffix or pin=true). PSinputscale (inputscale) is not
- * ported — no supported input sets it.
+ * with a "!" suffix or pin=true), divided by PSinputscale when > 0.
  * @see lib/fdpgen/fdpinit.c:initialPositions
  */
 function initialPositions(g: Graph): void {
+  const div = inputscaleDivisor(g);
   for (const np of g.nodes.values()) {
     const p = np.attrs.get('pos');
     if (p === undefined || p === '') continue;
-    applyPosAttr(np, p);
+    applyPosAttr(np, p, div);
   }
 }
 
 /** Parse one "x,y[!]" pos value onto np. @see fdpinit.c:47-66 */
-function applyPosAttr(np: Node, p: string): void {
+function applyPosAttr(np: Node, p: string, div: number): void {
   const m = /^(-?[\d.]+),(-?[\d.]+)\s*(!)?/.exec(p);
   if (m === null) return; // C warns "expected two floats"
-  np.info.pos![0] = parseFloat(m[1]!);
-  np.info.pos![1] = parseFloat(m[2]!);
+  np.info.pos![0] = parseFloat(m[1]!) / div;
+  np.info.pos![1] = parseFloat(m[2]!) / div;
   const pinAttr = np.attrs.get('pin');
   const pinned = m[3] === '!' ||
     (pinAttr !== undefined && /^(true|yes|1)$/i.test(pinAttr));

package/src/layout/fdp/layout.ts

@@ -16,6 +16,7 @@ import type { Box, Point } from '../../model/geom.js';
 import type { TextlabelT } from '../../common/types.js';
 import { lateInt, lateDouble } from '../../common/nodeinit.js';
 import type { PolygonT } from '../../common/types.js';
+import { agGraphAttr } from '../../model/cgraph-ops.js';
 import { isACluster } from '../dot/rank.js';
 import { BOTTOM_IX, TOP_IX } from '../dot/position-aux.js';
 import {
@@ -60,7 +61,7 @@ export function initInfo(g: Graph): LayoutInfo {
   getPackInfo(g, PackMode.Node, CL_OFFSET / 2, pack);
   return {
     rootg: g,
-    hasCoords: g.attrs.has('coords'),
+    hasCoords: agGraphAttr(g, 'coords') !== undefined,
     gid: 0,
     pack,
   };

package/src/layout/fdp/normalize.ts

@@ -34,12 +34,12 @@ function angleSet(g: Graph): number | null {
   if (a === undefined || a === '') return null;
   const ang = parseAngle(a);
   if (ang === null) return null;
-  return wrapDegrees(ang) * (Math.PI / 180);
+  return (wrapDegrees(ang) / 180.0) * Math.PI; // RADIANS(a) = a/180.0*M_PI
 }
 
-/** strtod with the mapbool fallback of angleSet. */
+/** strtod (leading whitespace, sign) with the mapbool fallback of angleSet. */
 function parseAngle(a: string): number | null {
-  const m = /^-?[\d.]+(?:[eE][-+]?\d+)?/.exec(a);
+  const m = /^\s*[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?/.exec(a);
   if (m !== null) return parseFloat(m[0]);
   /* no number */
   return mapbool(a) ? 0.0 : null;
@@ -55,34 +55,38 @@ function wrapDegrees(ang: number): number {
 /**
  * If "normalize" is set, move the first node to the origin, then
  * rotate the layout so the first edge sits at the given angle.
+ * Returns 1 if nodes moved, else 0.
  * @see lib/neatogen/adjust.c:normalize (15.0.0)
  */
-export function normalizeG(g: Graph): void {
+export function normalizeG(g: Graph): number {
   const phi0 = angleSet(g);
-  if (phi0 === null) return;
+  if (phi0 === null) return 0;
 
   const nodes = [...g.nodes.values()];
   const first = nodes[0];
-  if (first === undefined) return;
+  if (first === undefined) return 0;
   const px = first.info.pos![0]!;
   const py = first.info.pos![1]!;
   for (const v of nodes) {
     v.info.pos![0]! -= px;
     v.info.pos![1]! -= py;
   }
+  const ret = px || py ? 1 : 0;
 
   let e = null;
   for (const v of nodes) {
     const out = v.outEdges(g);
     if (out.length > 0) { e = out[0]!; break; }
   }
-  if (e === null) return;
+  if (e === null) return ret;
 
   /* rotation necessary; pos => ccw */
   const phi = phi0 - Math.atan2(
     e.head.info.pos![1]! - e.tail.info.pos![1]!,
     e.head.info.pos![0]! - e.tail.info.pos![0]!);
-  if (phi) rotateAll(nodes, e.tail, phi);
+  if (!phi) return ret;
+  rotateAll(nodes, e.tail, phi);
+  return 1;
 }
 
 /** Rotate all positions by phi about the orig node. */

package/src/layout/fdp/ports.ts

@@ -11,6 +11,7 @@
  *      (15.0.0)
  */
 
+import { InternalError } from '../../errors.js';
 import type { Graph } from '../../model/graph.js';
 import type { Node } from '../../model/node.js';
 import type { Edge } from '../../model/edge.js';
@@ -78,7 +79,7 @@ export function getEdgeList(n: Node, g: Graph): Erec[] {
     erecs.push({ e, alpha: Math.atan2(dy, dx), dist2: dx * dx + dy * dy });
   }
   if (erecs.length !== deg) {
-    throw new Error(`fdp getEdgeList: ${erecs.length} edges vs deg ${deg}`);
+    throw new InternalError(`fdp getEdgeList: ${erecs.length} edges vs deg ${deg}`);
   }
   erecs.sort(ecmp);
 
@@ -151,7 +152,7 @@ export function expandCluster(n: Node, cg: Graph): Graph {
       idx = genPorts(n, es[k]!, pp, idx, bnd);
     }
     if (idx !== sz) {
-      throw new Error(`fdp expandCluster: ${idx} ports vs wdeg ${sz}`);
+      throw new InternalError(`fdp expandCluster: ${idx} ports vs wdeg ${sz}`);
     }
 
     gdata(sg).ports = pp;

package/src/layout/fdp/xlayout.ts

@@ -17,6 +17,7 @@
  * @see lib/fdpgen/xlayout.c (15.0.0)
  */
 
+import { RenderError } from '../../errors.js';
 import type { Graph } from '../../model/graph.js';
 import type { Node } from '../../model/node.js';
 import { sepFactor, type ExpandT } from '../neato/sep-factor.js';
@@ -31,6 +32,7 @@ import {
 } from './fdp-model.js';
 import { coincidentDelta } from './tlayout.js';
 import { normalizeG } from './normalize.js';
+import { simpleScale } from '../neato/simple-scale.js';
 
 /** @see lib/fdpgen/xlayout.c:DFLT_overlap */
 const DFLT_OVERLAP = '9:prism';
@@ -313,14 +315,14 @@ export function fdpXLayout(g: Graph, xpms: XParams): void {
  *   scale family (scale/scalexy/compress) → scAdjust;
  *   AM_NONE ('' / 'true') and unported modes (voronoi) → no-op.
  * normalize reads "normalize" and simpleScale reads "scale"; deriveGraph
- * copies only overlap/sep/K, so both are faithfully dead here (as noted in
- * normalize.ts / sc-adjust.ts) unless set on the derived chain — simpleScale
- * follows the project's decision to leave it unported.
+ * copies only overlap/sep/K, so both are faithfully dead here unless set on
+ * the derived chain (native fdp ignores both attributes).
  * @see lib/neatogen/adjust.c:removeOverlapAs / removeOverlapWith / getAdjustMode
  */
 function removeOverlapAs(g: Graph, flag: string): void {
   if (g.nodes.size < 2) return; // removeOverlapWith: <2 nodes short-circuits
-  normalizeG(g); // removeOverlapWith runs normalize before the mode switch
+  normalizeG(g); // removeOverlapWith runs normalize + simpleScale first
+  simpleScale(g);
   const ntry = overlapPrismTries(flag);
   if (ntry !== null) {
     fdpAdjust(g, ntry); // AM_PRISM
@@ -333,9 +335,10 @@ function removeOverlapAs(g: Graph, flag: string): void {
   // Genuinely unported adjust algorithms: throw rather than silently leave
   // overlaps (no supported corpus input reaches these).
   if (UNPORTED_MODES.has(mode)) {
-    throw new Error(
+    throw new RenderError(
       `fdp: removeOverlapAs mode "${mode}" reached for graph "${g.name}" — ` +
       'that adjust algorithm (voronoi/oscale/vpsc/ortho/ipsep) is not ported',
+      'UNSUPPORTED_FEATURE',
     );
   }
   // AM_NONE ('', 'true', any boolean-true) → no overlap removal.