@diagrammo/dgmo 0.95.0 → 0.96.0

package/dist/chunk-6BQSDF77.js

@@ -1,734 +0,0 @@
-import {
-  SKETCH_DIAGNOSTIC_CODES
-} from "./chunk-NWSPPGIE.js";
-import {
-  makeDgmoError
-} from "./chunk-BYU54C3S.js";
-
-// src/sketch/geometry.ts
-var SKETCH_PHI = (1 + Math.sqrt(5)) / 2;
-var SKETCH_GEOMETRY = {
-  /** px per grid cell (the dot-grid pitch) */
-  cellPx: 16,
-  /** universal footprint width, in grid cells */
-  footprintCellsW: 8,
-  /**
-   * Legacy — the gap is now a derived half-unit (footprint/2 per axis), not
-   * these cell counts. Kept only so the shape of SKETCH_GEOMETRY is stable.
-   */
-  gapCellsX: 4,
-  gapCellsY: 4,
-  /** box reserved top band, px (spec decision 12) */
-  bandPx: 28,
-  /** box frame padding around the children bbox, px */
-  boxPadPx: 16,
-  /** edge-ring (connect hook) width as a fraction of footprint height */
-  ringFrac: 0.22
-};
-var SKETCH_FOOT_W = SKETCH_GEOMETRY.footprintCellsW * SKETCH_GEOMETRY.cellPx;
-var SKETCH_FOOT_H = 2 * Math.round(SKETCH_FOOT_W / SKETCH_PHI / 2);
-var SKETCH_HALF_SLOT_X = SKETCH_FOOT_W / 2;
-var SKETCH_HALF_SLOT_Y = SKETCH_FOOT_H / 2;
-var SKETCH_SEP = 3;
-var SKETCH_SLOT_X = SKETCH_HALF_SLOT_X * SKETCH_SEP;
-var SKETCH_SLOT_Y = SKETCH_HALF_SLOT_Y * SKETCH_SEP;
-function sketchSlotToPx(c, r) {
-  return { x: c * SKETCH_HALF_SLOT_X, y: r * SKETCH_HALF_SLOT_Y };
-}
-
-// src/sketch/collapse.ts
-function collapseSketch(parsed, collapsedLabels) {
-  const collapsed = collapsedLabels ?? new Set(parsed.boxes.filter((b) => b.collapsed).map((b) => b.label));
-  if (collapsed.size === 0) {
-    return {
-      nodes: parsed.nodes,
-      boxes: parsed.boxes,
-      virtualBoxes: [],
-      edges: parsed.edges,
-      collapsedChildCounts: /* @__PURE__ */ new Map()
-    };
-  }
-  const virtualBoxes = parsed.boxes.filter((b) => collapsed.has(b.label));
-  const boxes = parsed.boxes.filter((b) => !collapsed.has(b.label));
-  const nodeToVirtual = /* @__PURE__ */ new Map();
-  const collapsedChildCounts = /* @__PURE__ */ new Map();
-  for (const box of virtualBoxes) {
-    collapsedChildCounts.set(box.label, box.children.length);
-    for (const childId of box.children) nodeToVirtual.set(childId, box.id);
-  }
-  const nodes = parsed.nodes.filter((n) => !nodeToVirtual.has(n.id));
-  const edges = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const edge of parsed.edges) {
-    const sourceId = nodeToVirtual.get(edge.sourceId) ?? edge.sourceId;
-    const targetId = nodeToVirtual.get(edge.targetId) ?? edge.targetId;
-    if (sourceId === targetId) continue;
-    const key = `${sourceId}|${targetId}|${edge.label ?? ""}|${edge.heads}|${edge.dashed}`;
-    if (seen.has(key)) continue;
-    seen.add(key);
-    edges.push({ ...edge, sourceId, targetId });
-  }
-  return { nodes, boxes, virtualBoxes, edges, collapsedChildCounts };
-}
-
-// src/sketch/layout.ts
-var SKETCH_AUTO_LAYOUT_DEFAULTS = {
-  normalizeOrigin: false,
-  sortRootsBySource: false,
-  resolveOverlap: true,
-  groupCollisionAsRect: true,
-  flowPlaceUnpositioned: true,
-  avoidEdges: true
-};
-function resolveAutoFlags(f = {}) {
-  const d = SKETCH_AUTO_LAYOUT_DEFAULTS;
-  return {
-    normalizeOrigin: f.normalizeOrigin ?? d.normalizeOrigin,
-    sortRootsBySource: f.sortRootsBySource ?? d.sortRootsBySource,
-    resolveOverlap: f.resolveOverlap ?? d.resolveOverlap,
-    groupCollisionAsRect: f.groupCollisionAsRect ?? d.groupCollisionAsRect,
-    flowPlaceUnpositioned: f.flowPlaceUnpositioned ?? d.flowPlaceUnpositioned,
-    avoidEdges: f.avoidEdges ?? d.avoidEdges
-  };
-}
-function unitRect(c, r) {
-  return { c, r, w: SKETCH_SEP, h: SKETCH_SEP };
-}
-var childBoxAt = /* @__PURE__ */ new Map();
-function firstFreeOnRing(base, occupied, d) {
-  for (let quadrant = 0; quadrant < 4; quadrant++) {
-    for (let dr = -d; dr <= d; dr++) {
-      const r = base.r + dr;
-      const spread = d - Math.abs(dr);
-      for (const c of spread === 0 ? [base.c] : [base.c - spread, base.c + spread]) {
-        const cost = (r < base.r ? 2 : 0) + (c < base.c ? 1 : 0);
-        if (cost !== quadrant) continue;
-        if (!occupied.hits({ ...base, c, r })) return { c, r };
-      }
-    }
-  }
-  return null;
-}
-function nearestFreeRect(base, occupied) {
-  if (!occupied.hits(base)) return { c: base.c, r: base.r };
-  const key = `${base.c},${base.r},${base.w},${base.h}`;
-  for (let d = occupied.ringStart.get(key) ?? 1; d <= 200; d++) {
-    const found = firstFreeOnRing(base, occupied, d);
-    if (found) {
-      occupied.ringStart.set(key, d);
-      return found;
-    }
-  }
-  return { c: base.c, r: base.r };
-}
-function rectsOverlap(a, b) {
-  return a.c < b.c + b.w && b.c < a.c + a.w && a.r < b.r + b.h && b.r < a.r + a.h;
-}
-var CELL = SKETCH_SEP;
-var OVERSIZED_CELLS = 64;
-function cellRange(rect) {
-  return [
-    Math.floor(rect.c / CELL),
-    Math.floor(rect.r / CELL),
-    Math.floor((rect.c + rect.w) / CELL),
-    Math.floor((rect.r + rect.h) / CELL)
-  ];
-}
-function cellSpan(range) {
-  return (range[2] - range[0] + 1) * (range[3] - range[1] + 1);
-}
-var Occupancy = class {
-  grid = /* @__PURE__ */ new Map();
-  oversized = [];
-  /** Every rect, in insertion order — the extent and flow-origin maths want it. */
-  rects = [];
-  /**
-   * The ring a search from a given base last had to reach, keyed by that base.
-   *
-   * Slots are only ever taken here, never given back, so a ring that was full
-   * once is full for the rest of the layout. The next unit authored at the
-   * same slot can therefore start where the last one finished instead of
-   * re-walking every ring inside it — which is what made a stack of shapes on
-   * one coordinate cost more than linear even with the collision index in
-   * place (#484). Skipping proven-full rings cannot change where a unit lands.
-   */
-  ringStart = /* @__PURE__ */ new Map();
-  add(rect) {
-    this.rects.push(rect);
-    const range = cellRange(rect);
-    if (cellSpan(range) > OVERSIZED_CELLS) {
-      this.oversized.push(rect);
-      return;
-    }
-    const [c0, r0, c1, r1] = range;
-    for (let c = c0; c <= c1; c++) {
-      for (let r = r0; r <= r1; r++) {
-        const key = `${c},${r}`;
-        const bucket = this.grid.get(key);
-        if (bucket) bucket.push(rect);
-        else this.grid.set(key, [rect]);
-      }
-    }
-  }
-  hits(rect) {
-    for (const o of this.oversized) if (rectsOverlap(rect, o)) return true;
-    const range = cellRange(rect);
-    if (cellSpan(range) > OVERSIZED_CELLS) {
-      for (const o of this.rects) if (rectsOverlap(rect, o)) return true;
-      return false;
-    }
-    const [c0, r0, c1, r1] = range;
-    for (let c = c0; c <= c1; c++) {
-      for (let r = r0; r <= r1; r++) {
-        const bucket = this.grid.get(`${c},${r}`);
-        if (!bucket) continue;
-        for (const o of bucket) if (rectsOverlap(rect, o)) return true;
-      }
-    }
-    return false;
-  }
-};
-function nearestFree(base, occupied) {
-  if (!occupied.hits(base)) return { c: base.c, r: base.r };
-  const key = `${base.c},${base.r},${base.w},${base.h}`;
-  for (let d = occupied.ringStart.get(key) ?? 1; d <= 200; d++) {
-    const found = firstFreeOnRing(base, occupied, d);
-    if (found) {
-      occupied.ringStart.set(key, d);
-      return found;
-    }
-  }
-  return { c: base.c, r: base.r };
-}
-function layoutChildren(box, nodesById, warn, flags, childBoxRects = /* @__PURE__ */ new Map()) {
-  const occupied = new Occupancy();
-  const children = [];
-  const localBoxes = [];
-  const pending = [];
-  for (const boxId of box.childBoxes) {
-    const rect = childBoxRects.get(boxId);
-    if (!rect) continue;
-    const at = childBoxAt.get(boxId) ?? null;
-    const base = at ?? { c: 0, r: 0 };
-    const want = { ...rect, c: base.c, r: base.r };
-    const spot = flags.resolveOverlap ? nearestFreeRect(want, occupied) : { c: want.c, r: want.r };
-    occupied.add({ ...rect, c: spot.c, r: spot.r });
-    localBoxes.push({ boxId, c: spot.c, r: spot.r, rect });
-  }
-  for (const id of box.children) {
-    const node = nodesById.get(id);
-    if (!node) continue;
-    if (node.at === null) {
-      pending.push(node);
-      continue;
-    }
-    const target = unitRect(node.at.c, node.at.r);
-    const spot = flags.resolveOverlap ? nearestFree(target, occupied) : { c: node.at.c, r: node.at.r };
-    if (spot.c !== node.at.c || spot.r !== node.at.r) {
-      warn(node.lineNumber, node.label);
-    }
-    occupied.add(unitRect(spot.c, spot.r));
-    children.push({ node, c: spot.c, r: spot.r });
-  }
-  if (!flags.flowPlaceUnpositioned) {
-    for (const node of pending) children.push({ node, c: 0, r: 0 });
-    pending.length = 0;
-  }
-  let flowRow = occupied.rects.length > 0 ? Math.max(...occupied.rects.map((o) => o.r)) + SKETCH_SEP : 0;
-  let flowCol = 0;
-  const wrapAt = Math.max(
-    SKETCH_SEP * 3,
-    occupied.rects.length > 0 ? Math.max(...occupied.rects.map((o) => o.c)) + SKETCH_SEP : SKETCH_SEP * 3
-  );
-  for (const node of pending) {
-    let placed = false;
-    while (!placed) {
-      const rect = unitRect(flowCol, flowRow);
-      if (!occupied.hits(rect)) {
-        occupied.add(rect);
-        children.push({ node, c: flowCol, r: flowRow });
-        placed = true;
-      }
-      flowCol += SKETCH_SEP;
-      if (flowCol > wrapAt) {
-        flowCol = 0;
-        flowRow += SKETCH_SEP;
-      }
-    }
-  }
-  const footWs = SKETCH_FOOT_W / SKETCH_HALF_SLOT_X;
-  const footHs = SKETCH_FOOT_H / SKETCH_HALF_SLOT_Y;
-  const drawn = [
-    ...children.map((k) => ({ c: k.c, r: k.r, w: footWs, h: footHs })),
-    ...localBoxes.map((b) => ({ c: b.c, r: b.r, w: b.rect.w, h: b.rect.h }))
-  ];
-  let extent;
-  if (drawn.length === 0) {
-    extent = { c: 0, r: 0, w: footWs, h: footHs };
-  } else {
-    const cMin = Math.min(...drawn.map((o) => o.c));
-    const rMin = Math.min(...drawn.map((o) => o.r));
-    const cMax = Math.max(...drawn.map((o) => o.c + o.w));
-    const rMax = Math.max(...drawn.map((o) => o.r + o.h));
-    extent = { c: cMin, r: rMin, w: cMax - cMin, h: rMax - rMin };
-  }
-  return { children, boxes: localBoxes, extent };
-}
-function layoutSketch(parsed, options = {}) {
-  const diagnostics = [];
-  const overlapWarn = (line, label) => {
-    diagnostics.push(
-      makeDgmoError(
-        line,
-        `Shape "${label}" overlapped another at its authored position \u2014 moved to the nearest free slot`,
-        "warning",
-        SKETCH_DIAGNOSTIC_CODES.OVERLAP_RESOLVED
-      )
-    );
-  };
-  const flags = resolveAutoFlags(options.autoLayout);
-  const collapsed = collapseSketch(parsed, options.collapsedBoxes);
-  const nodesById = new Map(collapsed.nodes.map((n) => [n.id, n]));
-  const padHsX = SKETCH_GEOMETRY.boxPadPx / SKETCH_HALF_SLOT_X;
-  const padHsY = SKETCH_GEOMETRY.boxPadPx / SKETCH_HALF_SLOT_Y;
-  const bandHs = SKETCH_GEOMETRY.bandPx / SKETCH_HALF_SLOT_Y;
-  const boxLocal = /* @__PURE__ */ new Map();
-  const inExpandedBox = /* @__PURE__ */ new Set();
-  const boxById = new Map(collapsed.boxes.map((b) => [b.id, b]));
-  const nestedBoxIds = new Set(
-    collapsed.boxes.filter((b) => b.parentBoxId !== null).map((b) => b.id)
-  );
-  childBoxAt.clear();
-  for (const box of collapsed.boxes) {
-    if (!nestedBoxIds.has(box.id)) continue;
-    childBoxAt.set(box.id, box.at);
-    const local = layoutChildren(box, nodesById, overlapWarn, flags);
-    boxLocal.set(box.id, local);
-    for (const child of local.children) inExpandedBox.add(child.node.id);
-  }
-  const childBoxRects = /* @__PURE__ */ new Map();
-  for (const box of collapsed.boxes) {
-    if (!nestedBoxIds.has(box.id)) continue;
-    const local = boxLocal.get(box.id);
-    childBoxRects.set(box.id, {
-      c: 0,
-      r: 0,
-      w: local.extent.w + 2 * padHsX,
-      h: local.extent.h + bandHs + padHsY
-    });
-  }
-  for (const box of collapsed.boxes) {
-    if (nestedBoxIds.has(box.id)) continue;
-    const local = layoutChildren(
-      box,
-      nodesById,
-      overlapWarn,
-      flags,
-      childBoxRects
-    );
-    boxLocal.set(box.id, local);
-    for (const child of local.children) inExpandedBox.add(child.node.id);
-  }
-  const allNodesById = new Map(parsed.nodes.map((n) => [n.id, n]));
-  const noWarn = () => {
-  };
-  const virtualLocal = /* @__PURE__ */ new Map();
-  for (const box of collapsed.virtualBoxes) {
-    virtualLocal.set(box.id, layoutChildren(box, allNodesById, noWarn, flags));
-  }
-  const footWs = SKETCH_FOOT_W / SKETCH_HALF_SLOT_X;
-  const footHs = SKETCH_FOOT_H / SKETCH_HALF_SLOT_Y;
-  const virtualCardSpot = (boxId, spot) => {
-    const local = virtualLocal.get(boxId);
-    if (local.children.length === 0) return { c: spot.c, r: spot.r };
-    let minC = Infinity;
-    let minR = Infinity;
-    let maxC = -Infinity;
-    let maxR = -Infinity;
-    for (const ch of local.children) {
-      minC = Math.min(minC, ch.c);
-      minR = Math.min(minR, ch.r);
-      maxC = Math.max(maxC, ch.c + footWs);
-      maxR = Math.max(maxR, ch.r + footHs);
-    }
-    const cx = spot.c + (minC + maxC) / 2;
-    const cy = spot.r + (minR + maxR) / 2 + (padHsY - bandHs) / 2;
-    return {
-      c: Math.round(cx - footWs / 2),
-      r: Math.round(cy - footHs / 2)
-    };
-  };
-  const rootUnits = [];
-  for (const node of collapsed.nodes) {
-    if (!inExpandedBox.has(node.id)) rootUnits.push({ kind: "shape", node });
-  }
-  for (const box of collapsed.virtualBoxes) {
-    rootUnits.push({ kind: "virtual", box });
-  }
-  for (const box of collapsed.boxes) {
-    if (nestedBoxIds.has(box.id)) continue;
-    rootUnits.push({ kind: "box", box });
-  }
-  const lineOf = (u) => u.kind === "shape" ? u.node.lineNumber : u.box.lineNumber;
-  const atOf = (u) => u.kind === "shape" ? u.node.at : u.box.at;
-  if (flags.sortRootsBySource) {
-    rootUnits.sort((a, b) => lineOf(a) - lineOf(b));
-  } else {
-    rootUnits.sort((a, b) => {
-      const aa = atOf(a);
-      const ba = atOf(b);
-      if (aa && ba) {
-        return aa.r - ba.r || aa.c - ba.c || lineOf(a) - lineOf(b);
-      }
-      if (aa) return -1;
-      if (ba) return 1;
-      return lineOf(a) - lineOf(b);
-    });
-  }
-  const rectFor = (unit, c, r) => {
-    if (unit.kind !== "shape" && flags.groupCollisionAsRect) {
-      const local = (unit.kind === "box" ? boxLocal : virtualLocal).get(
-        unit.box.id
-      );
-      return {
-        c: c + local.extent.c - padHsX,
-        r: r + local.extent.r - bandHs,
-        w: local.extent.w + 2 * padHsX,
-        h: local.extent.h + bandHs + padHsY
-      };
-    }
-    return unitRect(c, r);
-  };
-  const occupied = new Occupancy();
-  const placedAt = /* @__PURE__ */ new Map();
-  const pending = [];
-  for (const unit of rootUnits) {
-    const at = atOf(unit);
-    if (at === null) {
-      pending.push(unit);
-      continue;
-    }
-    const base = rectFor(unit, at.c, at.r);
-    let spot = { c: at.c, r: at.r };
-    if (flags.resolveOverlap && unit.kind === "shape" && occupied.hits(base)) {
-      const freed = nearestFree(base, occupied);
-      spot = {
-        c: at.c + (freed.c - base.c),
-        r: at.r + (freed.r - base.r)
-      };
-      overlapWarn(unit.node.lineNumber, unit.node.label);
-    }
-    occupied.add(rectFor(unit, spot.c, spot.r));
-    placedAt.set(unit, spot);
-  }
-  if (!flags.flowPlaceUnpositioned) {
-    for (const unit of pending) {
-      occupied.add(rectFor(unit, 0, 0));
-      placedAt.set(unit, { c: 0, r: 0 });
-    }
-    pending.length = 0;
-  }
-  let flowRow = occupied.rects.length > 0 ? Math.ceil(Math.max(...occupied.rects.map((o) => o.r + o.h))) : 0;
-  let flowCol = 0;
-  const wrapAt = Math.max(
-    SKETCH_SEP * 4,
-    occupied.rects.length > 0 ? Math.ceil(Math.max(...occupied.rects.map((o) => o.c + o.w))) : SKETCH_SEP * 4
-  );
-  for (const unit of pending) {
-    let placed = false;
-    while (!placed) {
-      const rect = rectFor(unit, flowCol, flowRow);
-      if (!occupied.hits(rect)) {
-        occupied.add(rect);
-        placedAt.set(unit, { c: flowCol, r: flowRow });
-        placed = true;
-      }
-      flowCol += SKETCH_SEP;
-      if (flowCol > wrapAt) {
-        flowCol = 0;
-        flowRow += SKETCH_SEP;
-      }
-    }
-  }
-  const allRects = rootUnits.map((u) => {
-    const spot = placedAt.get(u);
-    return rectFor(u, spot.c, spot.r);
-  });
-  const liveCMin = allRects.length > 0 ? Math.min(...allRects.map((r) => r.c)) : 0;
-  const liveRMin = allRects.length > 0 ? Math.min(...allRects.map((r) => r.r)) : 0;
-  const cMin = flags.normalizeOrigin ? liveCMin : Math.min(options.frozenOrigin?.c ?? liveCMin, liveCMin);
-  const rMin = flags.normalizeOrigin ? liveRMin : Math.min(options.frozenOrigin?.r ?? liveRMin, liveRMin);
-  const toPx = (c, r) => ({
-    x: (c - cMin) * SKETCH_HALF_SLOT_X,
-    y: (r - rMin) * SKETCH_HALF_SLOT_Y
-  });
-  const nodes = [];
-  const boxes = [];
-  for (const unit of rootUnits) {
-    const spot = placedAt.get(unit);
-    if (unit.kind === "shape") {
-      const { x, y } = toPx(spot.c, spot.r);
-      nodes.push({
-        id: unit.node.id,
-        label: unit.node.label,
-        metadata: unit.node.metadata,
-        ...unit.node.description && { description: unit.node.description },
-        lineNumber: unit.node.lineNumber,
-        slot: spot,
-        x,
-        y,
-        w: SKETCH_FOOT_W,
-        h: SKETCH_FOOT_H
-      });
-    } else if (unit.kind === "virtual") {
-      const cardSpot = virtualCardSpot(unit.box.id, spot);
-      const { x, y } = toPx(cardSpot.c, cardSpot.r);
-      nodes.push({
-        id: unit.box.id,
-        label: unit.box.label,
-        metadata: unit.box.metadata,
-        lineNumber: unit.box.lineNumber,
-        slot: cardSpot,
-        x,
-        y,
-        w: SKETCH_FOOT_W,
-        h: SKETCH_FOOT_H,
-        isCollapsedBox: true,
-        childCount: collapsed.collapsedChildCounts.get(unit.box.label) ?? 0
-      });
-    } else {
-      const local = boxLocal.get(unit.box.id);
-      let minX = Infinity;
-      let minY = Infinity;
-      let maxX = -Infinity;
-      let maxY = -Infinity;
-      for (const child of local.children) {
-        const abs = toPx(spot.c + child.c, spot.r + child.r);
-        nodes.push({
-          id: child.node.id,
-          label: child.node.label,
-          metadata: child.node.metadata,
-          ...child.node.description && {
-            description: child.node.description
-          },
-          boxLabel: unit.box.label,
-          lineNumber: child.node.lineNumber,
-          slot: { c: spot.c + child.c, r: spot.r + child.r },
-          x: abs.x,
-          y: abs.y,
-          w: SKETCH_FOOT_W,
-          h: SKETCH_FOOT_H
-        });
-        minX = Math.min(minX, abs.x);
-        minY = Math.min(minY, abs.y);
-        maxX = Math.max(maxX, abs.x + SKETCH_FOOT_W);
-        maxY = Math.max(maxY, abs.y + SKETCH_FOOT_H);
-      }
-      if (minX === Infinity) {
-        const origin = toPx(spot.c, spot.r);
-        minX = origin.x;
-        minY = origin.y + SKETCH_GEOMETRY.bandPx;
-        maxX = origin.x + SKETCH_FOOT_W;
-        maxY = minY;
-      }
-      for (const inner of local.boxes) {
-        const innerBox = boxById.get(inner.boxId);
-        const innerLocal = boxLocal.get(inner.boxId);
-        if (!innerBox || !innerLocal) continue;
-        const innerRectOrigin = toPx(spot.c + inner.c, spot.r + inner.r);
-        const innerContentX = innerRectOrigin.x + SKETCH_GEOMETRY.boxPadPx - innerLocal.extent.c * SKETCH_HALF_SLOT_X;
-        const innerContentY = innerRectOrigin.y + SKETCH_GEOMETRY.bandPx - innerLocal.extent.r * SKETCH_HALF_SLOT_Y;
-        let iMinX = Infinity;
-        let iMinY = Infinity;
-        let iMaxX = -Infinity;
-        let iMaxY = -Infinity;
-        for (const gc of innerLocal.children) {
-          const gx = innerContentX + gc.c * SKETCH_HALF_SLOT_X;
-          const gy = innerContentY + gc.r * SKETCH_HALF_SLOT_Y;
-          nodes.push({
-            id: gc.node.id,
-            label: gc.node.label,
-            metadata: gc.node.metadata,
-            ...gc.node.description && { description: gc.node.description },
-            boxLabel: innerBox.label,
-            lineNumber: gc.node.lineNumber,
-            // 🔴 The child's OWN offset, or every child of an inner box
-            // reports its box's corner and they all read as one stack.
-            // `x`/`y` two lines down have always added `gc`; the slot did not,
-            // so two shapes 192px apart on screen both answered `5,-9` — and
-            // anything reading slots rather than pixels (the desktop canvas
-            // does, to adopt resolved positions on load) drew them on top of
-            // each other, then wrote that stack back to the file. The frame
-            // margins are the sub-unit difference between this and `gx`; the
-            // lattice owns the answer, so they round away, exactly as the
-            // depth-1 path above already assumes (#597).
-            slot: {
-              c: Math.round(
-                spot.c + inner.c + padHsX - innerLocal.extent.c + gc.c
-              ),
-              r: Math.round(
-                spot.r + inner.r + bandHs - innerLocal.extent.r + gc.r
-              )
-            },
-            x: gx,
-            y: gy,
-            w: SKETCH_FOOT_W,
-            h: SKETCH_FOOT_H
-          });
-          iMinX = Math.min(iMinX, gx);
-          iMinY = Math.min(iMinY, gy);
-          iMaxX = Math.max(iMaxX, gx + SKETCH_FOOT_W);
-          iMaxY = Math.max(iMaxY, gy + SKETCH_FOOT_H);
-        }
-        if (iMinX === Infinity) {
-          iMinX = innerContentX;
-          iMinY = innerContentY + SKETCH_GEOMETRY.bandPx;
-          iMaxX = innerContentX + SKETCH_FOOT_W;
-          iMaxY = iMinY;
-        }
-        const iFrame = {
-          x: iMinX - SKETCH_GEOMETRY.boxPadPx,
-          y: iMinY - SKETCH_GEOMETRY.bandPx,
-          w: iMaxX - iMinX + 2 * SKETCH_GEOMETRY.boxPadPx,
-          h: iMaxY - iMinY + SKETCH_GEOMETRY.bandPx + SKETCH_GEOMETRY.boxPadPx
-        };
-        boxes.push({
-          id: innerBox.id,
-          label: innerBox.label,
-          metadata: innerBox.metadata,
-          lineNumber: innerBox.lineNumber,
-          ...iFrame,
-          bandH: SKETCH_GEOMETRY.bandPx
-        });
-        minX = Math.min(minX, iFrame.x);
-        minY = Math.min(minY, iFrame.y);
-        maxX = Math.max(maxX, iFrame.x + iFrame.w);
-        maxY = Math.max(maxY, iFrame.y + iFrame.h);
-      }
-      boxes.push({
-        id: unit.box.id,
-        label: unit.box.label,
-        metadata: unit.box.metadata,
-        lineNumber: unit.box.lineNumber,
-        x: minX - SKETCH_GEOMETRY.boxPadPx,
-        y: minY - SKETCH_GEOMETRY.bandPx,
-        w: maxX - minX + 2 * SKETCH_GEOMETRY.boxPadPx,
-        h: maxY - minY + SKETCH_GEOMETRY.bandPx + SKETCH_GEOMETRY.boxPadPx,
-        bandH: SKETCH_GEOMETRY.bandPx
-      });
-    }
-  }
-  if (flags.avoidEdges) {
-    const authored = /* @__PURE__ */ new Set();
-    for (const unit of rootUnits) {
-      if (atOf(unit) !== null) {
-        authored.add(unit.kind === "shape" ? unit.node.id : unit.box.id);
-      }
-    }
-    const centerOf = (id) => {
-      const n = nodes.find((nd) => nd.id === id);
-      if (n) return { x: n.x + n.w / 2, y: n.y + n.h / 2 };
-      const b = boxes.find((bx) => bx.id === id);
-      if (b) return { x: b.x + b.w / 2, y: b.y + b.h / 2 };
-      return null;
-    };
-    const segHitsRect = (ax, ay, bx, by, rx0, ry0, rx1, ry1) => {
-      let t0 = 0;
-      let t1 = 1;
-      const p = [-(bx - ax), bx - ax, -(by - ay), by - ay];
-      const q = [ax - rx0, rx1 - ax, ay - ry0, ry1 - ay];
-      for (let i = 0; i < 4; i++) {
-        if (p[i] === 0) {
-          if (q[i] < 0) return false;
-        } else {
-          const t = q[i] / p[i];
-          if (p[i] < 0) {
-            if (t > t1) return false;
-            if (t > t0) t0 = t;
-          } else {
-            if (t < t0) return false;
-            if (t < t1) t1 = t;
-          }
-        }
-      }
-      return t0 <= t1;
-    };
-    const warned = /* @__PURE__ */ new Set();
-    for (let pass = 0; pass < 4; pass++) {
-      let moved = false;
-      for (const n of nodes) {
-        if (n.boxLabel) continue;
-        if (authored.has(n.id)) continue;
-        for (const e of collapsed.edges) {
-          if (e.sourceId === n.id || e.targetId === n.id) continue;
-          const a = centerOf(e.sourceId);
-          const b = centerOf(e.targetId);
-          if (!a || !b) continue;
-          if (!segHitsRect(a.x, a.y, b.x, b.y, n.x, n.y, n.x + n.w, n.y + n.h))
-            continue;
-          const ncx = n.x + n.w / 2;
-          const ncy = n.y + n.h / 2;
-          const m = n;
-          if (Math.abs(b.x - a.x) >= Math.abs(b.y - a.y)) {
-            const lineY = a.y + (b.y - a.y) * (ncx - a.x) / (b.x - a.x || 1);
-            let dir = ncy >= lineY ? 1 : -1;
-            if (n.slot.r + dir * SKETCH_SEP < 0) dir = 1;
-            m.y += dir * SKETCH_SLOT_Y;
-            m.slot = { c: n.slot.c, r: n.slot.r + dir * SKETCH_SEP };
-          } else {
-            const lineX = a.x + (b.x - a.x) * (ncy - a.y) / (b.y - a.y || 1);
-            let dir = ncx >= lineX ? 1 : -1;
-            if (n.slot.c + dir * SKETCH_SEP < 0) dir = 1;
-            m.x += dir * SKETCH_SLOT_X;
-            m.slot = { c: n.slot.c + dir * SKETCH_SEP, r: n.slot.r };
-          }
-          if (!warned.has(n.id)) {
-            overlapWarn(n.lineNumber, n.label);
-            warned.add(n.id);
-          }
-          moved = true;
-          break;
-        }
-      }
-      if (!moved) break;
-    }
-  }
-  let width = 0;
-  let height = 0;
-  for (const n of nodes) {
-    width = Math.max(width, n.x + n.w);
-    height = Math.max(height, n.y + n.h);
-  }
-  for (const b of boxes) {
-    width = Math.max(width, b.x + b.w);
-    height = Math.max(height, b.y + b.h);
-  }
-  const orderedBoxes = [
-    ...boxes.filter((b) => !nestedBoxIds.has(b.id)),
-    ...boxes.filter((b) => nestedBoxIds.has(b.id))
-  ];
-  return {
-    nodes,
-    boxes: orderedBoxes,
-    edges: collapsed.edges,
-    width,
-    height,
-    diagnostics,
-    origin: { c: cMin, r: rMin }
-  };
-}
-
-export {
-  SKETCH_GEOMETRY,
-  SKETCH_FOOT_W,
-  SKETCH_FOOT_H,
-  SKETCH_HALF_SLOT_X,
-  SKETCH_HALF_SLOT_Y,
-  SKETCH_SEP,
-  SKETCH_SLOT_X,
-  SKETCH_SLOT_Y,
-  sketchSlotToPx,
-  collapseSketch,
-  SKETCH_AUTO_LAYOUT_DEFAULTS,
-  layoutSketch
-};