@knowvah/dot-engine 2.6.11 → 2.7.0

package/src/layout/neato/kkutils.ts

@@ -0,0 +1,96 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * Helpers of neatogen/kkutils.c: the all-pairs shortest-path matrix
+ * (`compute_apsp`) and the index sorts `quicksort_place` and
+ * `quicksort_placef`. The sorts go through `gv_sort`, i.e. libc `qsort`, which is
+ * not stable: tied keys keep the permutation the BSD/Apple qsort gives, so the
+ * sort runs through `gvQsort` (the reproduction of that algorithm).
+ *
+ * @see lib/neatogen/kkutils.c
+ * @see lib/util/sort.h:gv_sort
+ */
+
+import { gvQsort } from '../../util/bsd-qsort.js';
+import { bfs } from './bfs.js';
+import { ngdijkstra } from './dijkstra.js';
+import type { VtxData } from './dijkstra.js';
+
+/** Three-way compare of two keys; 0 on tie or NaN, as C's `<`/`>` chain. */
+function compareKeys(a: number, b: number): number {
+  if (a < b) return -1;
+  if (a > b) return 1;
+  return 0;
+}
+
+/**
+ * Sort `ordering[first..first+count)` with `qsort` by `place[ordering[i]]`.
+ * `gv_sort` skips the call when `nmemb <= 1`; `gvQsort` does the same.
+ * @see lib/util/sort.h:gv_sort
+ */
+function gvSortByPlace(
+  place: Float64Array | Float32Array,
+  ordering: Int32Array,
+  first: number,
+  count: number,
+): void {
+  const slice = Array.from(ordering.subarray(first, first + count));
+  gvQsort(slice, (x, y) => compareKeys(place[x]!, place[y]!));
+  for (let i = 0; i < count; i++) ordering[first + i] = slice[i]!;
+}
+
+/**
+ * Sort `ordering[0..size)` by ascending `place[ordering[i]]`.
+ * @see lib/neatogen/kkutils.c:quicksort_place
+ */
+export function quicksortPlace(place: Float64Array, ordering: Int32Array, size: number): void {
+  gvSortByPlace(place, ordering, 0, size);
+}
+
+/**
+ * Sort `ordering[first..last]` (inclusive) by ascending `place[ordering[i]]`
+ * (float keys); a no-op unless `first < last`.
+ * @see lib/neatogen/kkutils.c:quicksort_placef
+ */
+export function quicksortPlacef(
+  place: Float32Array,
+  ordering: Int32Array,
+  first: number,
+  last: number,
+): void {
+  if (first < last) {
+    gvSortByPlace(place, ordering, first, last - first + 1);
+  }
+}
+
+/**
+ * Weighted APSP: one `ngdijkstra` per source. `DistType` is C `int`.
+ * @see lib/neatogen/kkutils.c:compute_apsp_dijkstra
+ */
+function computeApspDijkstra(graph: VtxData[], n: number): Int32Array[] {
+  const dij: Int32Array[] = [];
+  for (let i = 0; i < n; i++) dij.push(new Int32Array(n));
+  for (let i = 0; i < n; i++) ngdijkstra(i, graph, n, dij[i]!);
+  return dij;
+}
+
+/**
+ * Unweighted APSP: one `bfs` per source.
+ * @see lib/neatogen/kkutils.c:compute_apsp_simple
+ */
+function computeApspSimple(graph: VtxData[], n: number): Int32Array[] {
+  const dij: Int32Array[] = [];
+  for (let i = 0; i < n; i++) dij.push(new Int32Array(n));
+  for (let i = 0; i < n; i++) bfs(i, graph, n, dij[i]!);
+  return dij;
+}
+
+/**
+ * All-pairs shortest-path lengths as `DistType` (int) rows: Dijkstra when the
+ * graph has edge lengths (`graph->ewgts`; the port's empty array is C NULL),
+ * BFS otherwise.
+ * @see lib/neatogen/kkutils.c:compute_apsp
+ */
+export function computeApsp(graph: VtxData[], n: number): Int32Array[] {
+  return graph[0]!.ewgts.length > 0 ? computeApspDijkstra(graph, n) : computeApspSimple(graph, n);
+}

package/src/layout/neato/make-graph-data.ts

@@ -0,0 +1,166 @@
+// SPDX-License-Identifier: EPL-2.0
+/**
+ * Neato's sparse graph (`vtx_data`) construction: `makeGraphData` and the
+ * DIGCOLA edge-direction pass (`dfsCycle`, `acyclic`) it ends with.
+ *
+ * @see lib/neatogen/neatoinit.c
+ */
+
+import { lateDouble } from '../../common/nodeinit.js';
+import type { Graph } from '../../model/graph.js';
+import type { Node } from '../../model/node.js';
+import type { DirectedVtxData } from './opt-arrangement.js';
+
+/** `MODE_IPSEP`, restated: init.ts imports this module. @see lib/neatogen/neatoprocs.h */
+const MODE_IPSEP = 3;
+
+/** `edists` value of an edge seen from its head (an in-edge). */
+const EDIST_IN = 1;
+/** `edists` value of an edge seen from its tail (an out-edge). */
+const EDIST_OUT = -1;
+/** `edists` value of an edge with `dir=none`. */
+const EDIST_NONE = 0;
+
+/** Any edge carries a len attr (C: agattr_text(g, AGEDGE, "len")). */
+export function graphHasLen(g: Graph): boolean {
+  for (const e of g.edges) {
+    if (e.attrs.has('len')) return true;
+  }
+  return false;
+}
+
+/** `edists` of a graph built with `haveDir` (always an array there; `NULL` otherwise). */
+const edistsOf = (v: DirectedVtxData): number[] => v.edists as number[];
+
+/** One `dfsCycle` activation: the vertex and the next `edges` slot to examine. */
+interface DfsFrame {
+  readonly i: number;
+  e: number;
+}
+
+/** The visit state C keeps in `ND_mark` / `ND_onstack`. */
+interface DfsState {
+  readonly mode: number;
+  readonly mark: Uint8Array;
+  readonly onstack: Uint8Array;
+}
+
+/**
+ * Back edge `i -> j` (slot `e` of `i`): reverse it. In IPSEP mode make it an
+ * in-edge at both ends, so that an edge constraint won't be generated!
+ * @see lib/neatogen/neatoinit.c:dfsCycle
+ */
+function reverseBackEdge(graph: DirectedVtxData[], i: number, e: number, mode: number): void {
+  const node = graph[i]!;
+  const j = node.edges[e]!;
+  edistsOf(node)[e] = mode === MODE_IPSEP ? EDIST_OUT : EDIST_IN;
+  const target = graph[j]!;
+  let f = 1;
+  while (f < target.nedges && target.edges[f] !== i) f++;
+  if (f >= target.nedges) throw new Error(`neato: edge ${i}-${j} has no reverse entry`);
+  edistsOf(target)[f] = EDIST_OUT;
+}
+
+/**
+ * dfs for breaking cycles in vtxdata. C recurses; the recursion is replaced by
+ * an explicit stack of (vertex, next edge slot) frames, which visits in the
+ * same order but cannot overflow the JS stack on a long path.
+ * @see lib/neatogen/neatoinit.c:dfsCycle
+ */
+export function dfsCycle(graph: DirectedVtxData[], start: number, st: DfsState): void {
+  const { mode, mark, onstack } = st;
+  const stack: DfsFrame[] = [{ i: start, e: 1 }];
+  mark[start] = 1;
+  onstack[start] = 1;
+  for (let frame = stack.at(-1); frame !== undefined; frame = stack.at(-1)) {
+    const { i } = frame;
+    const node = graph[i]!;
+    if (frame.e >= node.nedges) {
+      onstack[i] = 0;
+      stack.pop();
+      continue;
+    }
+    const e = frame.e++;
+    if (edistsOf(node)[e] === EDIST_IN) continue; // in edge
+    const j = node.edges[e]!;
+    if (onstack[j]) {
+      reverseBackEdge(graph, i, e, mode);
+    } else if (!mark[j]) {
+      mark[j] = 1;
+      onstack[j] = 1;
+      stack.push({ i: j, e: 1 });
+    }
+  }
+}
+
+/**
+ * do a dfs of the vtx_data, looking for cycles, reversing edges. C keeps the
+ * visit state in `ND_mark`/`ND_onstack`; it is local to this pass here.
+ * @see lib/neatogen/neatoinit.c:acyclic
+ */
+export function acyclic(graph: DirectedVtxData[], nv: number, mode: number): void {
+  const st: DfsState = { mode, mark: new Uint8Array(nv), onstack: new Uint8Array(nv) };
+  for (let i = 0; i < nv; i++) {
+    if (st.mark[i]) continue;
+    dfsCycle(graph, i, st);
+  }
+}
+
+/** `edists` of the edge `ep` as seen from `np`. @see lib/neatogen/neatoinit.c:makeGraphData */
+function edgeDist(dir: string | undefined, np: Node, head: Node): number {
+  if (dir !== undefined && dir.startsWith('none')) return EDIST_NONE;
+  return np === head ? EDIST_IN : EDIST_OUT;
+}
+
+/** What `makeGraphData` was asked to build. */
+interface GraphDataOpts {
+  readonly haveLen: boolean;
+  readonly haveDir: boolean;
+}
+
+/**
+ * Append `np`'s neighbours (out-edges then in-edges, loops skipped, multi-edges
+ * merged) to its entry.
+ * @see lib/neatogen/neatoinit.c:makeGraphData
+ */
+function addNeighbours(g: Graph, np: Node, entry: DirectedVtxData, o: GraphDataOpts): void {
+  const seen = new Map<number, number>();
+  for (const ep of [...np.outEdges(g), ...np.inEdges(g)]) {
+    if (ep.head === ep.tail) continue;
+    const vp = ep.tail === np ? ep.head : ep.tail;
+    const vid = vp.info.id!;
+    const dist = o.haveLen ? lateDouble(ep.attrs.get('len'), 1.0, 0) : 1.0;
+    const idx = seen.get(vid);
+    if (idx !== undefined) {
+      if (o.haveLen) entry.ewgts[idx] = Math.max(entry.ewgts[idx]!, dist);
+      continue;
+    }
+    seen.set(vid, entry.nedges);
+    entry.edges.push(vid);
+    if (o.haveLen || o.haveDir) entry.ewgts.push(dist); // C neatoinit.c:827: haveDir 1.0
+    if (o.haveDir) edistsOf(entry).push(edgeDist(ep.attrs.get('dir'), np, ep.head));
+    entry.nedges++;
+  }
+}
+
+/**
+ * C makeGraphData's vtx_data: per node out-edges then in-edges (agfstedge order), self at
+ * index 0, duplicate neighbours merged (len keeps the max). ewgts: lens (default 1.0) if any
+ * len attr, else 1.0 under haveDir (hier/ipsep), else absent (C NULL). Under haveDir `edists`
+ * holds the direction of each first-seen edge (-1 tail, +1 head, 0 for dir=none) and the
+ * graph is then made acyclic. eweights (haveWt) are not built: nothing on a supported path
+ * reads them.
+ * @see lib/neatogen/neatoinit.c:makeGraphData
+ * @see lib/neatogen/stuff.c:setEdgeLen
+ */
+export function makeGraphDataC(
+  g: Graph, nodeList: Node[], haveLen: boolean, haveDir: boolean, mode: number = -1,
+): DirectedVtxData[] {
+  const vtx: DirectedVtxData[] = nodeList.map((_, i) => ({
+    nedges: 1, edges: [i], ewgts: haveLen || haveDir ? [0] : [],
+    ...(haveDir ? { edists: [0] } : {}),
+  }));
+  for (const np of nodeList) addNeighbours(g, np, vtx[np.info.id!]!, { haveLen, haveDir });
+  if (haveDir) acyclic(vtx, nodeList.length, mode); // make graph acyclic
+  return vtx;
+}

package/src/layout/neato/matrix-ops.ts

@@ -10,8 +10,22 @@
  * @see lib/neatogen/matrix_ops.c
  */
 
+import { crand } from '../../common/crand.js';
+import { fma as softFma } from '../../common/fma.js';
+import type { VtxData } from './dijkstra.js';
+
 const fr = Math.fround;
 
+/**
+ * fmadd: round(a * b + c) once. `common/fma` splits operands (Dekker), which
+ * turns an infinite operand into NaN where the hardware fmadd gives inf, so
+ * non-finite products and addends take the plain expression (exact then).
+ */
+export function fma(a: number, b: number, c: number): number {
+  const p = a * b;
+  return Number.isFinite(p) && Number.isFinite(c) ? softFma(a, b, c) : p + c;
+}
+
 /** Subtract the mean (double precision). @see matrix_ops.c:orthog1 */
 export function orthog1(n: number, vec: Float64Array): void {
   let sum = 0;
@@ -110,3 +124,127 @@ export function invertSqrtVec(n: number, vec: Float32Array): void {
     if (vec[i]! > 0) vec[i] = 1 / fr(Math.sqrt(vec[i]!));
   }
 }
+
+// ---------------------------------------------------------------------------
+// Double-precision helpers (vectors_inner_product, scadd, norm, ...).
+//
+// The 16.1 oracle is built `-O3 -flto=thin` for arm64, so each helper is
+// inlined into every call site and compiled there on its own: a vectorized
+// reduction rounds the products of its leading `block * floor(n / block)`
+// elements before the in-order adds (no reassociation is allowed), while its
+// scalar remainder (or a whole scalar loop) contracts `acc += a * b` to fmadd.
+// The block width is therefore a property of the call site; callers pass it,
+// named after the site, and `BLOCK_NONE` stands for a plain scalar loop.
+// Elementwise `x += a * b` (scadd) is fmadd/fmla in every shape.
+// ---------------------------------------------------------------------------
+
+/** Block width of a call site compiled as a scalar loop (all fmadd). */
+export const BLOCK_NONE = 1;
+
+/**
+ * Sum of `a[i] * b[i]` over `n` terms, the first `block * floor(n / block)`
+ * unfused and the rest fused, as the oracle's inlined copy of the site.
+ * @see lib/neatogen/matrix_ops.c:vectors_inner_product
+ */
+export function innerProduct(n: number, v1: Float64Array, v2: Float64Array, block: number): number {
+  let result = 0;
+  const blocked = block === BLOCK_NONE ? 0 : n - (n % block);
+  let i = 0;
+  for (; i < blocked; i++) result += v1[i]! * v2[i]!;
+  for (; i < n; i++) result = fma(v1[i]!, v2[i]!, result);
+  return result;
+}
+
+/** vec1[0..end] += fac * vec2[0..end] (fmadd). @see lib/neatogen/matrix_ops.c:scadd */
+export function scadd(vec1: Float64Array, end: number, fac: number, vec2: Float64Array): void {
+  for (let i = 0; i <= end; i++) vec1[i] = fma(fac, vec2[i]!, vec1[i]!);
+}
+
+/** 2-norm of vec[0..end]. @see lib/neatogen/matrix_ops.c:norm */
+export function norm(vec: Float64Array, end: number, block: number): number {
+  return Math.sqrt(innerProduct(end + 1, vec, vec, block));
+}
+
+/** result = vector * alpha (aliasing allowed). @see lib/neatogen/matrix_ops.c:vectors_scalar_mult */
+export function vectorsScalarMult(
+  n: number, vector: Float64Array, alpha: number, result: Float64Array,
+): void {
+  for (let i = 0; i < n; i++) result[i] = vector[i]! * alpha;
+}
+
+/** dest = source. @see lib/neatogen/matrix_ops.c:copy_vector */
+export function copyVector(n: number, source: Float64Array, dest: Float64Array): void {
+  for (let i = 0; i < n; i++) dest[i] = source[i]!;
+}
+
+/** result = v1 + v2 (aliasing allowed). @see lib/neatogen/matrix_ops.c:vectors_addition */
+export function vectorsAddition(
+  n: number, v1: Float64Array, v2: Float64Array, result: Float64Array,
+): void {
+  for (let i = 0; i < n; i++) result[i] = v1[i]! + v2[i]!;
+}
+
+/** result = v1 - v2 (aliasing allowed). @see lib/neatogen/matrix_ops.c:vectors_subtraction */
+export function vectorsSubtraction(
+  n: number, v1: Float64Array, v2: Float64Array, result: Float64Array,
+): void {
+  for (let i = 0; i < n; i++) result[i] = v1[i]! - v2[i]!;
+}
+
+/** Largest |vector[i]| (start -1e50). @see lib/neatogen/matrix_ops.c:max_abs */
+export function maxAbs(n: number, vector: Float64Array): number {
+  let maxVal = -1e50;
+  for (let i = 0; i < n; i++) {
+    const a = Math.abs(vector[i]!);
+    if (a > maxVal) maxVal = a; // fmax: a NaN operand is ignored, as `>` does
+  }
+  return maxVal;
+}
+
+/**
+ * result = matrix * vector for an n x n float** matrix and double vector;
+ * each row's reduction is blocked as the call site was compiled.
+ * @see lib/neatogen/matrix_ops.c:right_mult_with_vector_f
+ */
+export function rightMultWithVectorF(
+  matrix: readonly Float32Array[], n: number, vector: Float64Array, result: Float64Array,
+  block: number,
+): void {
+  const blocked = block === BLOCK_NONE ? 0 : n - (n % block);
+  for (let i = 0; i < n; i++) {
+    const row = matrix[i]!;
+    let res = 0;
+    let j = 0;
+    for (; j < blocked; j++) res += row[j]! * vector[j]!;
+    for (; j < n; j++) res = fma(row[j]!, vector[j]!, res);
+    result[i] = res;
+  }
+}
+
+/**
+ * result = matrix * vector over the sparse `vtx_data` rows (`ewgts` weights).
+ * The loop is scalar in the oracle: every term is an fmadd.
+ * @see lib/neatogen/matrix_ops.c:right_mult_with_vector
+ */
+export function rightMultWithVector(
+  matrix: VtxData[], n: number, vector: Float64Array, result: Float64Array,
+): void {
+  for (let i = 0; i < n; i++) {
+    let res = 0;
+    const row = matrix[i]!;
+    for (let j = 0; j < row.nedges; j++) res = fma(row.ewgts[j]!, vector[row.edges[j]!]!, res);
+    result[i] = res;
+  }
+}
+
+/** `#define RANGE` @see lib/neatogen/matrix_ops.c */
+const RANGE = 500;
+
+/**
+ * `vec[i] = rand() % RANGE`, then orthogonalize against 1.
+ * @see lib/neatogen/matrix_ops.c:init_vec_orth1
+ */
+export function initVecOrth1(n: number, vec: Float64Array): void {
+  for (let i = 0; i < n; i++) vec[i] = crand() % RANGE;
+  orthog1(n, vec);
+}

package/src/layout/neato/multispline-router.ts

@@ -19,6 +19,7 @@
 import type { Point, Poly } from '../../pathplan/types.js';
 import { wind } from '../../pathplan/visibility.js';
 import { mkSurface } from './cdt-surface.js';
+import { dist2 } from '../../common/spline-midpoint.js';
 import { InternalError } from '../../errors.js';
 
 /** index pair. @see multispline.c:ipair */
@@ -87,9 +88,8 @@ function sharedEdge(faces: number[], p3: number, q3: number): Ipair {
 
 /** @see multispline.c:addTriEdge */
 export function addTriEdge(g: Tgraph, t: number, h: number, seg: Ipair): void {
-  const dist = Math.hypot(
-    g.nodes[t]!.ctr.x - g.nodes[h]!.ctr.x,
-    g.nodes[t]!.ctr.y - g.nodes[h]!.ctr.y);
+  /* DIST = sqrt(fused DIST2): libgvplugin_neato_layout _addTriEdge fmul/fmadd/fsqrt */
+  const dist = Math.sqrt(dist2(g.nodes[t]!.ctr, g.nodes[h]!.ctr));
   const idx = g.edges.length;
   g.edges.push({ t, h, seg, dist });
   g.nodes[t]!.edges.push(idx);

package/src/layout/neato/multispline.ts

@@ -25,6 +25,7 @@ import { clipAndInstall } from '../../common/splines-clip.js';
 import { makeStraightEdges, addEdgeLabels } from '../dot/straight-edges.js';
 import type { Router, Ipair } from './multispline-router.js';
 import { addEndpoint, edgeToSeg, triPath } from './multispline-router.js';
+import { agwarningf } from '../../common/agerr.js';
 
 export type { Router } from './multispline-router.js';
 export { mkRouter } from './multispline-router.js';
@@ -339,8 +340,8 @@ function chainOf(e: Edge): Edge[] {
  * @see multispline.c:genroute
  */
 function warnNoControlPoints(e: Edge): number {
-  console.warn(
-    `Warning: Could not create control points for multiple spline for edge (${e.tail.name},${e.head.name})`,
+  agwarningf(
+    `Could not create control points for multiple spline for edge (${e.tail.name},${e.head.name})`,
   );
   return 1;
 }

package/src/layout/neato/opt-arrangement.ts

@@ -0,0 +1,86 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * Optimal y arrangement of a directed graph: solves `L*y = b` by conjugate
+ * gradient over the unit-weight Laplacian, where `b` is the balance vector of
+ * the edge directions (`edists`).
+ *
+ * @see lib/neatogen/opt_arrangement.c
+ */
+
+import { conjugateGradient } from './conjgrad.js';
+import type { VtxData } from './dijkstra.js';
+import { initVecOrth1 } from './matrix-ops.js';
+
+/** `vtx_data` with the `DIGCOLA` `edists` field (`int8_t *`, `NULL` when absent). */
+export interface DirectedVtxData extends VtxData {
+  edists?: ArrayLike<number> | null;
+}
+
+/** `#define hierarchy_cg_tol` @see lib/neatogen/opt_arrangement.c */
+const HIERARCHY_CG_TOL = 1e-3;
+
+/**
+ * Build `b` with `-b[i] = sum_j -w_ij * delta_ij` (the balance vector; the
+ * matrix is -L, so `-Lx = -b` is solved). `b` is left untouched when node 0 has
+ * no `edists` (C: `continue`, `b` stays calloc-zero).
+ * @see lib/neatogen/opt_arrangement.c:construct_b
+ */
+export function constructB(graph: DirectedVtxData[], n: number, b: Float64Array): void {
+  for (let i = 0; i < n; i++) {
+    if (graph[0]!.edists == null) continue;
+    let bI = 0;
+    const node = graph[i]!;
+    for (let j = 1; j < node.nedges; j++) { // skip the self loop
+      // C ewgts is float; edists is int8_t
+      bI += Math.fround(Math.fround(node.ewgts[j]!) * node.edists![j]!);
+    }
+    b[i] = bI;
+  }
+}
+
+/**
+ * Replace every row's edge weights (lengths) by uniform Laplacian weights:
+ * `-(nedges-1)` on the diagonal, 1 off it. Returns the replaced rows' weights.
+ * @see lib/neatogen/opt_arrangement.c:compute_y_coords
+ */
+function setUniformWeights(graph: VtxData[], n: number): number[][] {
+  const old: number[][] = [];
+  for (let i = 0; i < n; i++) {
+    const node = graph[i]!;
+    old.push(node.ewgts);
+    const weights = new Array<number>(node.nedges).fill(1);
+    weights[0] = -(node.nedges - 1);
+    node.ewgts = weights;
+  }
+  return old;
+}
+
+/**
+ * Find the y coordinates of a directed graph by solving `L*y = b`. Starts from
+ * a `rand()`-seeded vector, so the result depends on the libc rand stream
+ * position (`common/crand`). Returns 1 when conjugate gradient fails.
+ * @see lib/neatogen/opt_arrangement.c:compute_y_coords
+ */
+export function computeYCoords(
+  graph: VtxData[],
+  n: number,
+  yCoords: Float64Array,
+  maxIterations: number,
+): 0 | 1 {
+  let rv: 0 | 1 = 0;
+  const b = new Float64Array(n);
+
+  constructB(graph, n, b);
+  initVecOrth1(n, yCoords);
+
+  // replace original edge weights (which are lengths) with uniform weights
+  const oldEwgts = setUniformWeights(graph, n);
+  // C tests `< 0` although conjugate_gradient returns 0 or 1, so rv never becomes 1
+  if (conjugateGradient(graph, yCoords, b, n, HIERARCHY_CG_TOL, maxIterations) < 0) {
+    rv = 1;
+  }
+  // restore original edge weights
+  for (let i = 0; i < n; i++) graph[i]!.ewgts = oldEwgts[i]!;
+  return rv;
+}

package/src/layout/neato/poly.ts

@@ -19,6 +19,7 @@ import type { Node } from '../../model/node.js';
 import type { Box, Point } from '../../model/geom.js';
 import { ShapeKind } from '../../common/types.js';
 import type { PolygonT } from '../../common/types.js';
+import { agerrorf } from '../../common/agerr.js';
 
 /** @see lib/neatogen/poly.c:BOX */
 export const POLY_BOX = 1;
@@ -258,7 +259,7 @@ export function makeAddPoly(n: Node, xmargin: number, ymargin: number): Poly | n
     case ShapeKind.SH_POINT:
       return finishPoly(genRound(n, xmargin, ymargin), POLY_CIRCLE);
     default:
-      console.error(`Error: makeAddPoly: unknown shape type ${shapeName(n)}\n`);
+      agerrorf(`makeAddPoly: unknown shape type ${shapeName(n)}\n`);
       return null;
   }
 }
@@ -296,7 +297,7 @@ function baseShape(n: Node): { verts: Point[]; kind: number } | null {
     case ShapeKind.SH_POINT:
       return { verts: genRound(n, 0, 0), kind: POLY_CIRCLE };
     default:
-      console.error(`Error: makePoly: unknown shape type ${shapeName(n)}\n`);
+      agerrorf(`makePoly: unknown shape type ${shapeName(n)}\n`);
       return null;
   }
 }