@grayhaven/nerve-exporters 0.1.0

package/dist/index.js

@@ -0,0 +1,1131 @@
+// src/csv.ts
+import { isPinEndpoint } from "@grayhaven/nerve";
+var endpointCells = (e) => isPinEndpoint(e) ? [e.connector, e.pin] : [e.splice, ""];
+var escapeCell = (cell) => {
+  if (cell === void 0) return "";
+  const s = String(cell);
+  return /[",\n\r]/.test(s) ? `"${s.replace(/"/g, '""')}"` : s;
+};
+var toCsv = (rows) => rows.map((row) => row.map(escapeCell).join(",")).join("\n") + "\n";
+var tableCsv = (table) => toCsv([table.headers, ...table.rows]);
+var bomTable = (hir) => ({
+  headers: [
+    "Item number",
+    "Quantity",
+    "Unit of measure",
+    "Internal part number",
+    "Manufacturer",
+    "Manufacturer part number",
+    "Description",
+    "Category",
+    "Used by",
+    "Approved alternates",
+    "Notes"
+  ],
+  rows: hir.bom.map((item, i) => [
+    i + 1,
+    item.quantity,
+    item.unitOfMeasure,
+    item.internalPartId,
+    item.manufacturer,
+    item.mpn,
+    item.description,
+    item.category,
+    item.usedBy.join("; "),
+    "",
+    item.notes
+  ])
+});
+var bomCsv = (hir) => tableCsv(bomTable(hir));
+var cutListTable = (hir, options = {}) => ({
+  headers: [
+    "Wire ID",
+    "Signal",
+    "Gauge",
+    "Color",
+    "Stripe",
+    "Cut length",
+    "Finished length",
+    "Tolerance",
+    "From connector",
+    "From pin",
+    "To connector",
+    "To pin",
+    "Terminal A",
+    "Terminal B",
+    "Branch",
+    "Notes"
+  ],
+  rows: hir.wires.map((w) => [
+    w.id,
+    w.signal,
+    w.gauge,
+    w.color,
+    w.stripe,
+    w.length,
+    w.length,
+    w.lengthTolerance ?? options.defaultWireTolerance,
+    ...endpointCells(w.from),
+    ...endpointCells(w.to),
+    "",
+    // terminal assignment lands with process data (PRD §28)
+    "",
+    w.branch ?? w.cable,
+    w.notes
+  ])
+});
+var cutListCsv = (hir, options = {}) => tableCsv(cutListTable(hir, options));
+var labelScheduleTable = (hir) => ({
+  headers: [
+    "Label ID",
+    "Text",
+    "Quantity",
+    "Material",
+    "Printer profile",
+    "Target object",
+    "Placement offset",
+    "Orientation",
+    "Notes"
+  ],
+  rows: hir.labels.map((l) => [
+    l.id,
+    l.text,
+    l.quantity ?? 1,
+    l.material,
+    "",
+    l.attachTo,
+    l.offsetFrom !== void 0 && l.distance !== void 0 ? `${l.distance} from ${l.offsetFrom}` : l.distance,
+    "",
+    ""
+  ])
+});
+var labelScheduleCsv = (hir) => tableCsv(labelScheduleTable(hir));
+var testPlanTable = (plan) => ({
+  headers: [
+    "Test ID",
+    "Type",
+    "From connector",
+    "From pin",
+    "To connector",
+    "To pin",
+    "Expected",
+    "Net",
+    "Wire"
+  ],
+  rows: plan.tests.map((t) => [
+    t.id,
+    t.type,
+    t.from.connector,
+    t.from.pin,
+    t.to.connector,
+    t.to.pin,
+    t.expected,
+    t.net,
+    t.wire
+  ])
+});
+var testPlanCsv = (plan) => tableCsv(testPlanTable(plan));
+
+// src/test-plan.ts
+import { isPinEndpoint as isPinEndpoint2 } from "@grayhaven/nerve";
+var cmp = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+var endpointKey = (e) => isPinEndpoint2(e) ? `pin:${e.connector}:${e.pin}` : `splice:${e.splice}`;
+var computeNets = (hir) => {
+  const parent = /* @__PURE__ */ new Map();
+  const find = (k) => {
+    let root = parent.get(k) ?? k;
+    if (root !== k) {
+      root = find(root);
+      parent.set(k, root);
+    }
+    return root;
+  };
+  const union = (a, b) => {
+    const ra = find(a);
+    const rb = find(b);
+    if (ra !== rb) parent.set(ra < rb ? rb : ra, ra < rb ? ra : rb);
+  };
+  for (const w of hir.wires) {
+    union(endpointKey(w.from), endpointKey(w.to));
+  }
+  const signalsByRoot = /* @__PURE__ */ new Map();
+  for (const w of hir.wires) {
+    if (w.signal === void 0) continue;
+    const root = find(endpointKey(w.from));
+    const list = signalsByRoot.get(root) ?? [];
+    list.push(w.signal);
+    signalsByRoot.set(root, list);
+  }
+  const names = /* @__PURE__ */ new Map();
+  for (const w of hir.wires) {
+    for (const e of [w.from, w.to]) {
+      const key = endpointKey(e);
+      const root = find(key);
+      const signals = signalsByRoot.get(root);
+      names.set(key, signals !== void 0 ? [...signals].sort(cmp)[0] : root);
+    }
+  }
+  return names;
+};
+var generateTestPlan = (hir) => {
+  const netOf = computeNets(hir);
+  const tests = [];
+  let n = 0;
+  const nextId = () => `T-${String(++n).padStart(3, "0")}`;
+  for (const w of hir.wires) {
+    if (!isPinEndpoint2(w.from) || !isPinEndpoint2(w.to)) continue;
+    const net = netOf.get(endpointKey(w.from));
+    tests.push({
+      id: nextId(),
+      type: "continuity",
+      from: { connector: w.from.connector, pin: w.from.pin },
+      to: { connector: w.to.connector, pin: w.to.pin },
+      expected: "closed",
+      ...net !== void 0 ? { net } : {},
+      wire: w.id
+    });
+  }
+  for (const s of hir.splices) {
+    const pins = [];
+    for (const wireId of s.wires) {
+      const w = hir.wires.find((x) => x.id === wireId);
+      if (w === void 0) continue;
+      for (const e of [w.from, w.to]) {
+        if (isPinEndpoint2(e)) pins.push({ connector: e.connector, pin: e.pin });
+      }
+    }
+    pins.sort((a, b) => cmp(a.connector, b.connector) || cmp(a.pin, b.pin));
+    const hub = pins[0];
+    if (hub === void 0) continue;
+    const net = netOf.get(`splice:${s.id}`);
+    for (const p of pins.slice(1)) {
+      tests.push({
+        id: nextId(),
+        type: "splice",
+        from: hub,
+        to: p,
+        expected: "closed",
+        ...net !== void 0 ? { net } : {},
+        splice: s.id
+      });
+    }
+  }
+  const netToPin = /* @__PURE__ */ new Map();
+  for (const w of hir.wires) {
+    for (const end of [w.from, w.to]) {
+      if (!isPinEndpoint2(end)) continue;
+      const net = netOf.get(endpointKey(end)) ?? `wire:${w.id}`;
+      const pins = netToPin.get(end.connector) ?? /* @__PURE__ */ new Map();
+      if (!pins.has(net)) pins.set(net, end.pin);
+      netToPin.set(end.connector, pins);
+    }
+  }
+  for (const connector of [...netToPin.keys()].sort(cmp)) {
+    const pins = netToPin.get(connector);
+    const nets = [...pins.keys()].sort(cmp);
+    for (let i = 0; i < nets.length; i++) {
+      for (let j = i + 1; j < nets.length; j++) {
+        const netA = nets[i];
+        const netB = nets[j];
+        tests.push({
+          id: nextId(),
+          type: "no-short",
+          from: { connector, pin: pins.get(netA) },
+          to: { connector, pin: pins.get(netB) },
+          expected: "open",
+          net: `${netA} <-> ${netB}`
+        });
+      }
+    }
+  }
+  return {
+    harness: { id: hir.harness.id, revision: hir.harness.revision },
+    tests
+  };
+};
+var testPlanJson = (hir) => JSON.stringify(generateTestPlan(hir), null, 2) + "\n";
+var coverage = (hir, plan) => {
+  const netOf = computeNets(hir);
+  const nets = new Set(
+    hir.wires.map((w) => netOf.get(endpointKey(w.from)) ?? `wire:${w.id}`)
+  );
+  const covered = new Set(
+    plan.tests.filter((t) => t.expected === "closed").map((t) => t.net ?? (t.type === "continuity" ? `wire:${t.wire}` : ""))
+  );
+  return {
+    nets: nets.size,
+    covered: [...nets].filter((n) => covered.has(n)).length
+  };
+};
+
+// src/drawing.ts
+var esc = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+var renderSvg = (drawing) => {
+  const parts = [
+    `<svg xmlns="http://www.w3.org/2000/svg" width="${drawing.width}" height="${drawing.height}" viewBox="0 0 ${drawing.width} ${drawing.height}" font-family="ui-monospace, SFMono-Regular, Menlo, monospace" font-size="12">`
+  ];
+  if (drawing.background !== void 0) {
+    parts.push(
+      `<rect width="${drawing.width}" height="${drawing.height}" fill="${esc(drawing.background)}"/>`
+    );
+  }
+  for (const item of drawing.items) {
+    switch (item.kind) {
+      case "rect":
+        parts.push(
+          `<rect x="${item.x}" y="${item.y}" width="${item.w}" height="${item.h}"${item.rx !== void 0 ? ` rx="${item.rx}"` : ""} fill="${esc(item.fill ?? "none")}"${item.stroke !== void 0 ? ` stroke="${esc(item.stroke)}" stroke-width="${item.strokeWidth ?? 1}"` : ""}/>`
+        );
+        break;
+      case "line":
+        parts.push(
+          `<line x1="${item.x1}" y1="${item.y1}" x2="${item.x2}" y2="${item.y2}" stroke="${esc(item.stroke)}" stroke-width="${item.strokeWidth ?? 1}"${item.dash !== void 0 ? ` stroke-dasharray="${item.dash.join(" ")}"` : ""}/>`
+        );
+        break;
+      case "path":
+        parts.push(
+          `<path d="${esc(item.d)}" fill="none" stroke="${esc(item.stroke)}" stroke-width="${item.strokeWidth ?? 1}"${item.dash !== void 0 ? ` stroke-dasharray="${item.dash.join(" ")}"` : ""}/>`
+        );
+        break;
+      case "text":
+        parts.push(
+          `<text x="${item.x}" y="${item.y}"${item.size !== void 0 ? ` font-size="${item.size}"` : ""}${item.weight === "bold" ? ` font-weight="bold"` : ""} fill="${esc(item.fill ?? "#111")}"${item.anchor !== void 0 && item.anchor !== "start" ? ` text-anchor="${item.anchor}"` : ""}>${esc(item.text)}</text>`
+        );
+        break;
+      case "circle":
+        parts.push(
+          `<circle cx="${item.cx}" cy="${item.cy}" r="${item.r}" fill="${esc(item.fill)}"/>`
+        );
+        break;
+    }
+  }
+  parts.push("</svg>");
+  return parts.join("\n") + "\n";
+};
+var scaleDrawing = (drawing, s) => ({
+  width: drawing.width * s,
+  height: drawing.height * s,
+  ...drawing.background !== void 0 ? { background: drawing.background } : {},
+  items: drawing.items.map((item) => {
+    switch (item.kind) {
+      case "rect":
+        return {
+          ...item,
+          x: item.x * s,
+          y: item.y * s,
+          w: item.w * s,
+          h: item.h * s,
+          ...item.rx !== void 0 ? { rx: item.rx * s } : {},
+          ...item.strokeWidth !== void 0 ? { strokeWidth: item.strokeWidth * s } : {}
+        };
+      case "line":
+        return {
+          ...item,
+          x1: item.x1 * s,
+          y1: item.y1 * s,
+          x2: item.x2 * s,
+          y2: item.y2 * s,
+          ...item.strokeWidth !== void 0 ? { strokeWidth: item.strokeWidth * s } : {},
+          ...item.dash !== void 0 ? { dash: item.dash.map((d) => d * s) } : {}
+        };
+      case "path":
+        return {
+          ...item,
+          d: scalePathData(item.d, s),
+          ...item.strokeWidth !== void 0 ? { strokeWidth: item.strokeWidth * s } : {},
+          ...item.dash !== void 0 ? { dash: item.dash.map((d) => d * s) } : {}
+        };
+      case "text":
+        return {
+          ...item,
+          x: item.x * s,
+          y: item.y * s,
+          size: (item.size ?? 12) * s
+        };
+      case "circle":
+        return { ...item, cx: item.cx * s, cy: item.cy * s, r: item.r * s };
+    }
+  })
+});
+var scalePathData = (d, s) => d.replace(/-?\d+(\.\d+)?/g, (n) => String(round2(Number(n) * s)));
+var round2 = (n) => Math.round(n * 100) / 100;
+
+// src/svg.ts
+import { isPinEndpoint as isPinEndpoint3 } from "@grayhaven/nerve";
+var BOX_W = 180;
+var ROW_H = 20;
+var HEADER_H = 40;
+var MARGIN = 48;
+var COL_GAP = 380;
+var V_GAP = 48;
+var TITLE_H = 64;
+var strokeFor = (color) => {
+  if (color === void 0) return "#888888";
+  const map = {
+    white: "#b8b8b8",
+    yellow: "#c9a800",
+    black: "#222222"
+  };
+  return map[color.toLowerCase()] ?? color;
+};
+var schematicDrawing = (hir) => {
+  const left = [];
+  const right = [];
+  hir.connectors.forEach((c, i) => (i % 2 === 0 ? left : right).push(c));
+  const place = (column, side, x) => {
+    let y = TITLE_H + MARGIN;
+    return column.map((c) => {
+      const height2 = HEADER_H + c.pins.length * ROW_H + 8;
+      const pinY = new Map(
+        c.pins.map((p, i) => [p.pin, y + HEADER_H + (i + 0.5) * ROW_H])
+      );
+      const placed2 = { ref: c.ref, x, y, height: height2, side, pinY };
+      y += height2 + V_GAP;
+      return placed2;
+    });
+  };
+  const rightX = MARGIN + BOX_W + COL_GAP;
+  const placed = new Map(
+    [...place(left, "left", MARGIN), ...place(right, "right", rightX)].map(
+      (p) => [p.ref, p]
+    )
+  );
+  const spliceCenterX = MARGIN + BOX_W + COL_GAP / 2;
+  const splicePos = new Map(
+    hir.splices.map((s, i) => [
+      s.id,
+      { x: spliceCenterX, y: TITLE_H + MARGIN + 60 + i * 70 }
+    ])
+  );
+  const width = rightX + BOX_W + MARGIN;
+  const height = Math.max(
+    ...[...placed.values()].map((p) => p.y + p.height),
+    ...[...splicePos.values()].map((p) => p.y + 40),
+    TITLE_H + MARGIN
+  ) + MARGIN;
+  const errorWires = new Set(
+    hir.diagnostics.filter((d) => d.severity === "error" && d.target?.startsWith("wire:")).map((d) => d.target.slice("wire:".length))
+  );
+  const items = [
+    // Title block
+    {
+      kind: "text",
+      x: MARGIN,
+      y: 28,
+      text: hir.harness.id,
+      size: 18,
+      weight: "bold",
+      fill: "#111"
+    },
+    {
+      kind: "text",
+      x: MARGIN,
+      y: 48,
+      text: `rev ${hir.harness.revision} \xB7 units ${hir.harness.units} \xB7 HIR ${hir.schemaVersion}`,
+      fill: "#555"
+    }
+  ];
+  const anchorOf = (e) => {
+    if (isPinEndpoint3(e)) {
+      const p = placed.get(e.connector);
+      const y = p?.pinY.get(e.pin);
+      if (p === void 0 || y === void 0) return void 0;
+      return p.side === "left" ? { x: p.x + BOX_W, y, dir: 1 } : { x: p.x, y, dir: -1 };
+    }
+    const s = splicePos.get(e.splice);
+    return s !== void 0 ? { x: s.x, y: s.y, dir: 0 } : void 0;
+  };
+  for (const w of hir.wires) {
+    const a = anchorOf(w.from);
+    const b = anchorOf(w.to);
+    if (a === void 0 || b === void 0) {
+      continue;
+    }
+    const { x: x1, y: y1 } = a;
+    const { x: x2, y: y2 } = b;
+    const dx = Math.max(60, Math.abs(x2 - x1) / 3);
+    const dir1 = a.dir !== 0 ? a.dir : x2 > x1 ? 1 : -1;
+    const dir2 = b.dir !== 0 ? b.dir : x1 > x2 ? 1 : -1;
+    const c1 = x1 + dir1 * dx;
+    const c2 = x2 + dir2 * dx;
+    const isError = errorWires.has(w.id);
+    items.push({
+      kind: "path",
+      d: `M ${x1} ${y1} C ${c1} ${y1}, ${c2} ${y2}, ${x2} ${y2}`,
+      stroke: isError ? "#d11" : strokeFor(w.color),
+      strokeWidth: 2,
+      ...isError ? { dash: [6, 3] } : {}
+    });
+    const annotation = [w.id, w.gauge, w.twistGroup !== void 0 ? "twisted" : void 0].filter((s) => s !== void 0).join(" \xB7 ");
+    items.push({
+      kind: "text",
+      x: (x1 + x2) / 2,
+      y: (y1 + y2) / 2 - 6,
+      text: annotation,
+      fill: isError ? "#d11" : "#333",
+      anchor: "middle"
+    });
+  }
+  for (const c of hir.connectors) {
+    const p = placed.get(c.ref);
+    if (p === void 0) continue;
+    items.push(
+      {
+        kind: "rect",
+        x: p.x,
+        y: p.y,
+        w: BOX_W,
+        h: p.height,
+        rx: 6,
+        fill: "#ffffff",
+        stroke: "#333",
+        strokeWidth: 1.5
+      },
+      { kind: "text", x: p.x + 10, y: p.y + 18, text: c.ref, weight: "bold", fill: "#111" },
+      {
+        kind: "text",
+        x: p.x + 10,
+        y: p.y + 33,
+        text: `${c.mpn}${c.gender !== void 0 ? ` \xB7 ${c.gender}` : ""}`,
+        size: 10,
+        fill: "#777"
+      },
+      {
+        kind: "line",
+        x1: p.x,
+        y1: p.y + HEADER_H - 2,
+        x2: p.x + BOX_W,
+        y2: p.y + HEADER_H - 2,
+        stroke: "#ddd"
+      }
+    );
+    for (const pin of c.pins) {
+      const y = p.pinY.get(pin.pin);
+      const anchorX = p.side === "left" ? p.x + BOX_W : p.x;
+      items.push(
+        { kind: "circle", cx: anchorX, cy: y, r: 3, fill: "#333" },
+        { kind: "text", x: p.x + 10, y: y + 4, text: pin.pin, fill: "#111" },
+        { kind: "text", x: p.x + 34, y: y + 4, text: pin.signal ?? "", fill: "#555" }
+      );
+    }
+  }
+  for (const s of hir.splices) {
+    const pos = splicePos.get(s.id);
+    if (pos === void 0) continue;
+    items.push(
+      { kind: "circle", cx: pos.x, cy: pos.y, r: 6, fill: "#333" },
+      {
+        kind: "text",
+        x: pos.x,
+        y: pos.y - 12,
+        text: `${s.id}${s.type !== void 0 ? ` \xB7 ${s.type}` : ""}`,
+        size: 11,
+        fill: "#333",
+        anchor: "middle"
+      }
+    );
+  }
+  return { width, height, background: "#fafafa", items };
+};
+var schematicSvg = (hir) => renderSvg(schematicDrawing(hir));
+
+// src/board.ts
+var SCALE = 0.8;
+var MARGIN2 = 48;
+var TITLE_H2 = 64;
+var TRUNK_GAP = 150;
+var DEFAULT_LEN_PX = 240;
+var NODE_W = 64;
+var NODE_H = 26;
+var lengthPx = (mm) => mm !== void 0 ? Math.max(120, mm * SCALE) : DEFAULT_LEN_PX;
+var boardDrawing = (hir) => {
+  const items = [
+    {
+      kind: "text",
+      x: MARGIN2,
+      y: 28,
+      text: `${hir.harness.id} \u2014 harness board`,
+      size: 18,
+      weight: "bold",
+      fill: "#111"
+    },
+    {
+      kind: "text",
+      x: MARGIN2,
+      y: 48,
+      text: `rev ${hir.harness.revision} \xB7 units ${hir.harness.units} \xB7 scale ${SCALE} px/${hir.harness.units}`,
+      fill: "#555"
+    }
+  ];
+  const roots = hir.branches.filter((b) => b.parent === void 0);
+  const children = (parent) => hir.branches.filter((b) => b.parent === parent);
+  let maxX = MARGIN2 + 400;
+  let y = TITLE_H2 + MARGIN2 + NODE_H;
+  const drawEndpoint = (x, cy, ref) => {
+    items.push(
+      {
+        kind: "rect",
+        x: x - NODE_W / 2,
+        y: cy - NODE_H / 2,
+        w: NODE_W,
+        h: NODE_H,
+        rx: 4,
+        fill: "#ffffff",
+        stroke: "#333",
+        strokeWidth: 1.5
+      },
+      {
+        kind: "text",
+        x,
+        y: cy + 4,
+        text: ref,
+        weight: "bold",
+        fill: "#111",
+        anchor: "middle"
+      }
+    );
+  };
+  const drawBranch = (branch, x0, cy, depth) => {
+    const len = lengthPx(branch.nominalLength);
+    const x1 = x0 + len;
+    maxX = Math.max(maxX, x1 + NODE_W);
+    items.push({
+      kind: "line",
+      x1: x0,
+      y1: cy,
+      x2: x1,
+      y2: cy,
+      stroke: "#444",
+      strokeWidth: 5
+    });
+    const path = branch.path;
+    path.forEach((ref, i) => {
+      const t = path.length > 1 ? i / (path.length - 1) : 0;
+      drawEndpoint(x0 + t * len, cy, ref);
+    });
+    const callout = [
+      branch.id,
+      branch.sleeve !== void 0 ? `sleeve: ${branch.sleeve}` : void 0
+    ].filter((s) => s !== void 0).join(" \xB7 ");
+    items.push({
+      kind: "text",
+      x: x0 + len / 2,
+      y: cy - NODE_H / 2 - 8,
+      text: callout,
+      fill: "#333",
+      anchor: "middle"
+    });
+    if (branch.nominalLength !== void 0) {
+      const dimY = cy + NODE_H / 2 + 16;
+      items.push(
+        { kind: "line", x1: x0, y1: dimY, x2: x1, y2: dimY, stroke: "#999" },
+        { kind: "line", x1: x0, y1: dimY - 4, x2: x0, y2: dimY + 4, stroke: "#999" },
+        { kind: "line", x1, y1: dimY - 4, x2: x1, y2: dimY + 4, stroke: "#999" },
+        {
+          kind: "text",
+          x: x0 + len / 2,
+          y: dimY + 14,
+          text: `${branch.nominalLength} ${hir.harness.units} nominal`,
+          size: 11,
+          fill: "#777",
+          anchor: "middle"
+        }
+      );
+    }
+    for (const label of hir.labels.filter((l) => l.attachTo === branch.id)) {
+      const fromEnd = label.offsetFrom !== void 0 && label.offsetFrom === path[path.length - 1];
+      const off = (label.distance ?? 0) * SCALE;
+      const lx = fromEnd ? x1 - off : x0 + off;
+      const flagText = `${label.id}: ${label.text}`;
+      items.push(
+        { kind: "line", x1: lx, y1: cy, x2: lx, y2: cy - 34, stroke: "#b07a00" },
+        {
+          kind: "rect",
+          x: lx,
+          y: cy - 50,
+          w: 16 + flagText.length * 6.7,
+          h: 16,
+          fill: "#fff3d6",
+          stroke: "#b07a00",
+          strokeWidth: 1
+        },
+        {
+          kind: "text",
+          x: lx + 8,
+          y: cy - 38,
+          text: flagText,
+          size: 11,
+          fill: "#8a5a00"
+        }
+      );
+    }
+    for (const s of hir.splices.filter((sp) => sp.branch === branch.id)) {
+      const sx = x0 + Math.min((s.location ?? 0) * SCALE, len);
+      items.push(
+        { kind: "circle", cx: sx, cy, r: 6, fill: "#333" },
+        {
+          kind: "text",
+          x: sx,
+          y: cy + NODE_H / 2 + 30,
+          text: `${s.id}${s.type !== void 0 ? ` (${s.type})` : ""}`,
+          size: 11,
+          fill: "#333",
+          anchor: "middle"
+        }
+      );
+    }
+    let childY = cy;
+    for (const child of children(branch.id)) {
+      const bx = x0 + Math.min((child.breakoutDistance ?? 0) * SCALE, len);
+      childY += TRUNK_GAP * 0.7;
+      items.push({
+        kind: "line",
+        x1: bx,
+        y1: cy,
+        x2: bx + 24,
+        y2: childY,
+        stroke: "#444",
+        strokeWidth: 3
+      });
+      childY = drawBranch(child, bx + 24, childY, depth + 1);
+    }
+    return childY;
+  };
+  if (roots.length === 0) {
+    items.push({
+      kind: "text",
+      x: MARGIN2,
+      y,
+      text: "No branches defined \u2014 add branch(...) entries to lay out the board.",
+      fill: "#777"
+    });
+    y += 24;
+  }
+  for (const root of roots) {
+    y = drawBranch(root, MARGIN2 + NODE_W / 2, y + 30, 0) + TRUNK_GAP;
+  }
+  return {
+    width: maxX + MARGIN2,
+    height: y + MARGIN2,
+    background: "#fafafa",
+    items
+  };
+};
+var boardSvg = (hir) => renderSvg(boardDrawing(hir));
+
+// src/instructions.ts
+import { isPinEndpoint as isPinEndpoint4 } from "@grayhaven/nerve";
+var assemblyInstructions = (hir) => {
+  const lines = [];
+  const section = (title) => {
+    lines.push("", title, "-".repeat(title.length));
+  };
+  let step = 0;
+  const add = (text) => {
+    step += 1;
+    lines.push(`${String(step).padStart(2, " ")}. ${text}`);
+  };
+  lines.push(
+    `ASSEMBLY INSTRUCTIONS \u2014 ${hir.harness.id} rev ${hir.harness.revision}`,
+    `Units: ${hir.harness.units}. Generated from HIR ${hir.schemaVersion}; every step references design object IDs.`
+  );
+  section("Materials");
+  for (const item of hir.bom) {
+    add(`Gather ${item.quantity}x ${item.mpn}${item.description !== void 0 ? ` (${item.description})` : ""} \u2014 used by ${item.usedBy.join(", ")}.`);
+  }
+  section("Cut wires");
+  for (const w of hir.wires) {
+    const spec = [w.gauge, w.color].filter((s) => s !== void 0).join(" ");
+    const len = w.length !== void 0 ? `${w.length} ${hir.harness.units}${w.lengthTolerance !== void 0 ? ` \xB1${w.lengthTolerance}` : ""}` : "length per board";
+    add(`Cut ${w.id}: ${spec || "wire"}, ${len}${w.signal !== void 0 ? ` [${w.signal}]` : ""}.`);
+  }
+  const twistGroups = /* @__PURE__ */ new Map();
+  for (const w of hir.wires) {
+    if (w.twistGroup === void 0) continue;
+    const list = twistGroups.get(w.twistGroup) ?? [];
+    list.push(w.id);
+    twistGroups.set(w.twistGroup, list);
+  }
+  if (twistGroups.size > 0) {
+    section("Twist pairs");
+    for (const [group, wires] of [...twistGroups.entries()].sort()) {
+      add(`Twist ${wires.join(" + ")} together (${group}).`);
+    }
+  }
+  if (hir.splices.length > 0) {
+    section("Splices");
+    for (const s of hir.splices) {
+      const parts = [
+        `Splice ${s.id}: join ${s.wires.join(" + ")}`,
+        s.type !== void 0 ? `(${s.type}${s.part !== void 0 ? `, ${s.part}` : ""})` : void 0,
+        s.branch !== void 0 && s.location !== void 0 ? `at ${s.location} ${hir.harness.units} along ${s.branch}` : void 0,
+        s.notes
+      ].filter((x) => x !== void 0);
+      add(parts.join(" ") + ".");
+    }
+  }
+  section("Populate connectors");
+  for (const c of hir.connectors) {
+    const wired = hir.wires.filter(
+      (w) => [w.from, w.to].some((e) => isPinEndpoint4(e) && e.connector === c.ref)
+    );
+    add(`Populate ${c.ref} (${c.mpn}${c.gender !== void 0 ? `, ${c.gender}` : ""}):`);
+    for (const w of wired) {
+      const end = [w.from, w.to].find(
+        (e) => isPinEndpoint4(e) && e.connector === c.ref
+      );
+      if (end === void 0 || !isPinEndpoint4(end)) continue;
+      lines.push(`      cavity ${end.pin}: ${w.id}${w.signal !== void 0 ? ` (${w.signal})` : ""}`);
+    }
+  }
+  if (hir.branches.length > 0) {
+    section("Branch assembly");
+    for (const b of hir.branches) {
+      const parts = [
+        `Route branch ${b.id} (${b.path.join(" \u2192 ")})`,
+        b.nominalLength !== void 0 ? `${b.nominalLength} ${hir.harness.units} nominal` : void 0,
+        b.sleeve !== void 0 ? `sleeve with ${b.sleeve}` : void 0
+      ].filter((s) => s !== void 0);
+      add(parts.join("; ") + ".");
+    }
+  }
+  if (hir.labels.length > 0) {
+    section("Apply labels");
+    for (const l of hir.labels) {
+      const placement = l.offsetFrom !== void 0 && l.distance !== void 0 ? ` ${l.distance} ${hir.harness.units} from ${l.offsetFrom}` : "";
+      add(`Apply ${l.id} "${l.text}" on ${l.attachTo}${placement}.`);
+    }
+  }
+  section("Inspection");
+  add("Verify every cavity against the pinout table; check seating/lock engagement.");
+  add("Verify wire colors and labels against the schedule.");
+  add("Verify branch lengths and sleeve coverage against the board drawing.");
+  section("Test");
+  add("Run the continuity-test procedure (tests.csv / test-plan.json); record results per test ID.");
+  return lines.join("\n") + "\n";
+};
+
+// src/pdf.ts
+import { PDFDocument, StandardFonts, rgb } from "pdf-lib";
+import { hasErrors } from "@grayhaven/nerve";
+var PAGE_W = 792;
+var PAGE_H = 612;
+var MARGIN3 = 40;
+var NAMED_COLORS = {
+  red: [0.85, 0.1, 0.1],
+  black: [0.13, 0.13, 0.13],
+  blue: [0.1, 0.2, 0.85],
+  green: [0.1, 0.6, 0.2],
+  white: [0.72, 0.72, 0.72],
+  yellow: [0.79, 0.66, 0],
+  orange: [0.9, 0.5, 0.1],
+  gray: [0.5, 0.5, 0.5],
+  grey: [0.5, 0.5, 0.5],
+  brown: [0.5, 0.33, 0.2],
+  purple: [0.5, 0.2, 0.7],
+  pink: [0.9, 0.4, 0.6]
+};
+var parseColor = (color) => {
+  if (color === void 0) return rgb(0.4, 0.4, 0.4);
+  const named = NAMED_COLORS[color.toLowerCase()];
+  if (named !== void 0) return rgb(...named);
+  const hex = /^#([0-9a-f]{3}|[0-9a-f]{6})$/i.exec(color)?.[1];
+  if (hex !== void 0) {
+    const full = hex.length === 3 ? hex.split("").map((c) => c + c).join("") : hex;
+    return rgb(
+      parseInt(full.slice(0, 2), 16) / 255,
+      parseInt(full.slice(2, 4), 16) / 255,
+      parseInt(full.slice(4, 6), 16) / 255
+    );
+  }
+  return rgb(0.4, 0.4, 0.4);
+};
+var safe = (s) => s.replace(/→/g, "->").replace(/[^\x20-\x7E\xA0-\xFF·±—–]/g, "?");
+var drawDrawing = (page, drawing, fonts) => {
+  const availW = PAGE_W - 2 * MARGIN3;
+  const availH = PAGE_H - 2 * MARGIN3;
+  const s = Math.min(availW / drawing.width, availH / drawing.height, 1);
+  const d = scaleDrawing(drawing, s);
+  const ox = MARGIN3 + (availW - d.width) / 2;
+  const oyTop = MARGIN3 + (availH - d.height) / 2;
+  const flip = (y) => PAGE_H - oyTop - y;
+  for (const item of d.items) {
+    switch (item.kind) {
+      case "rect":
+        page.drawRectangle({
+          x: ox + item.x,
+          y: flip(item.y + item.h),
+          width: item.w,
+          height: item.h,
+          ...item.fill !== void 0 && item.fill !== "none" ? { color: parseColor(item.fill) } : {},
+          ...item.stroke !== void 0 ? {
+            borderColor: parseColor(item.stroke),
+            borderWidth: item.strokeWidth ?? 1
+          } : {}
+        });
+        break;
+      case "line":
+        page.drawLine({
+          start: { x: ox + item.x1, y: flip(item.y1) },
+          end: { x: ox + item.x2, y: flip(item.y2) },
+          thickness: item.strokeWidth ?? 1,
+          color: parseColor(item.stroke),
+          ...item.dash !== void 0 ? { dashArray: [...item.dash] } : {}
+        });
+        break;
+      case "path":
+        page.drawSvgPath(item.d, {
+          x: ox,
+          y: PAGE_H - oyTop,
+          borderColor: parseColor(item.stroke),
+          borderWidth: item.strokeWidth ?? 1,
+          ...item.dash !== void 0 ? { borderDashArray: [...item.dash] } : {}
+        });
+        break;
+      case "text": {
+        const font = item.weight === "bold" ? fonts.bold : fonts.mono;
+        const size = item.size ?? 12;
+        const text = safe(item.text);
+        const width = font.widthOfTextAtSize(text, size);
+        const x = item.anchor === "middle" ? ox + item.x - width / 2 : item.anchor === "end" ? ox + item.x - width : ox + item.x;
+        page.drawText(text, {
+          x,
+          y: flip(item.y),
+          size,
+          font,
+          color: parseColor(item.fill ?? "#111")
+        });
+        break;
+      }
+      case "circle":
+        page.drawCircle({
+          x: ox + item.cx,
+          y: flip(item.cy),
+          size: item.r,
+          color: parseColor(item.fill)
+        });
+        break;
+    }
+  }
+};
+var pageHeader = (page, fonts, hir, title) => {
+  page.drawText(safe(title), {
+    x: MARGIN3,
+    y: PAGE_H - MARGIN3,
+    size: 14,
+    font: fonts.bold,
+    color: rgb(0.07, 0.07, 0.07)
+  });
+  page.drawText(safe(`${hir.harness.id} \xB7 rev ${hir.harness.revision}`), {
+    x: PAGE_W - MARGIN3 - fonts.mono.widthOfTextAtSize(`${hir.harness.id} \xB7 rev ${hir.harness.revision}`, 9),
+    y: PAGE_H - MARGIN3,
+    size: 9,
+    font: fonts.mono,
+    color: rgb(0.45, 0.45, 0.45)
+  });
+  page.drawLine({
+    start: { x: MARGIN3, y: PAGE_H - MARGIN3 - 8 },
+    end: { x: PAGE_W - MARGIN3, y: PAGE_H - MARGIN3 - 8 },
+    thickness: 0.7,
+    color: rgb(0.8, 0.8, 0.8)
+  });
+  return PAGE_H - MARGIN3 - 26;
+};
+var drawTablePages = (doc, fonts, hir, title, table) => {
+  const usable = PAGE_W - 2 * MARGIN3;
+  const colW = usable / table.headers.length;
+  const rowH = 14;
+  const size = Math.min(8, colW / 6);
+  const maxChars = Math.floor(colW / (size * 0.62));
+  let page = doc.addPage([PAGE_W, PAGE_H]);
+  let y = pageHeader(page, fonts, hir, title);
+  const drawRow = (cells, bold) => {
+    cells.forEach((cell, i) => {
+      const text = safe(String(cell ?? ""));
+      page.drawText(text.length > maxChars ? text.slice(0, maxChars - 1) + "\u2026" : text, {
+        x: MARGIN3 + i * colW,
+        y,
+        size,
+        font: bold ? fonts.bold : fonts.mono,
+        color: rgb(0.1, 0.1, 0.1)
+      });
+    });
+    y -= rowH;
+  };
+  drawRow(table.headers, true);
+  for (const row of table.rows) {
+    if (y < MARGIN3 + rowH) {
+      page = doc.addPage([PAGE_W, PAGE_H]);
+      y = pageHeader(page, fonts, hir, `${title} (cont.)`);
+      drawRow(table.headers, true);
+    }
+    drawRow(row, false);
+  }
+};
+var drawTextPages = (doc, fonts, hir, title, body) => {
+  let page = doc.addPage([PAGE_W, PAGE_H]);
+  let y = pageHeader(page, fonts, hir, title);
+  for (const line of body.split("\n")) {
+    if (y < MARGIN3 + 12) {
+      page = doc.addPage([PAGE_W, PAGE_H]);
+      y = pageHeader(page, fonts, hir, `${title} (cont.)`);
+    }
+    page.drawText(safe(line), {
+      x: MARGIN3,
+      y,
+      size: 9,
+      font: fonts.mono,
+      color: rgb(0.1, 0.1, 0.1)
+    });
+    y -= 12;
+  }
+};
+var manufacturingPacketPdf = async (hir, options = {}) => {
+  const doc = await PDFDocument.create();
+  const epoch = /* @__PURE__ */ new Date("2000-01-01T00:00:00Z");
+  doc.setCreationDate(epoch);
+  doc.setModificationDate(epoch);
+  doc.setProducer("Grayhaven Nerve");
+  doc.setCreator("Grayhaven Nerve");
+  doc.setTitle(`${hir.harness.id} rev ${hir.harness.revision} \u2014 manufacturing packet`);
+  const fonts = {
+    regular: await doc.embedFont(StandardFonts.Helvetica),
+    bold: await doc.embedFont(StandardFonts.HelveticaBold),
+    mono: await doc.embedFont(StandardFonts.Courier)
+  };
+  const cover = doc.addPage([PAGE_W, PAGE_H]);
+  const errors = hir.diagnostics.filter((d) => d.severity === "error").length;
+  const warnings = hir.diagnostics.filter((d) => d.severity === "warning").length;
+  cover.drawText("GRAYHAVEN NERVE", {
+    x: MARGIN3,
+    y: PAGE_H - 80,
+    size: 12,
+    font: fonts.bold,
+    color: rgb(0.45, 0.45, 0.45)
+  });
+  cover.drawText("MANUFACTURING PACKET", {
+    x: MARGIN3,
+    y: PAGE_H - 110,
+    size: 26,
+    font: fonts.bold,
+    color: rgb(0.07, 0.07, 0.07)
+  });
+  const fields = [
+    ["Harness", hir.harness.id],
+    ["Revision", hir.harness.revision],
+    ["Units", hir.harness.units],
+    ["HIR schema", hir.schemaVersion],
+    ["Connectors", String(hir.connectors.length)],
+    ["Wires", String(hir.wires.length)],
+    ["Branches", String(hir.branches.length)],
+    ["Labels", String(hir.labels.length)],
+    [
+      "Validation",
+      hasErrors(hir.diagnostics) ? `FAILED \u2014 ${errors} error(s)` : `PASSED \u2014 0 errors, ${warnings} warning(s)`
+    ]
+  ];
+  let fy = PAGE_H - 160;
+  for (const [key, value] of fields) {
+    cover.drawText(safe(key), { x: MARGIN3, y: fy, size: 11, font: fonts.bold });
+    cover.drawText(safe(value), { x: MARGIN3 + 130, y: fy, size: 11, font: fonts.mono });
+    fy -= 20;
+  }
+  cover.drawText("Revision history", { x: MARGIN3, y: fy - 16, size: 11, font: fonts.bold });
+  cover.drawText(safe(`rev ${hir.harness.revision} \u2014 this release`), {
+    x: MARGIN3 + 130,
+    y: fy - 16,
+    size: 11,
+    font: fonts.mono
+  });
+  const schematicPage = doc.addPage([PAGE_W, PAGE_H]);
+  drawDrawing(schematicPage, schematicDrawing(hir), fonts);
+  const boardPage = doc.addPage([PAGE_W, PAGE_H]);
+  drawDrawing(boardPage, boardDrawing(hir), fonts);
+  drawTablePages(doc, fonts, hir, "Bill of Materials", bomTable(hir));
+  drawTablePages(doc, fonts, hir, "Wire Cut List", cutListTable(hir, options));
+  drawTablePages(doc, fonts, hir, "Label Schedule", labelScheduleTable(hir));
+  drawTablePages(doc, fonts, hir, "Continuity Test Procedure", testPlanTable(generateTestPlan(hir)));
+  drawTextPages(doc, fonts, hir, "Assembly Instructions", assemblyInstructions(hir));
+  return doc.save();
+};
+
+// src/packet.ts
+import { zipSync, strToU8 } from "fflate";
+import { hasErrors as hasErrors2 } from "@grayhaven/nerve";
+var coverSheet = (hir) => {
+  const errors = hir.diagnostics.filter((d) => d.severity === "error").length;
+  const warnings = hir.diagnostics.filter((d) => d.severity === "warning").length;
+  return [
+    "GRAYHAVEN NERVE \u2014 MANUFACTURING PACKET",
+    "",
+    `Harness:      ${hir.harness.id}`,
+    `Revision:     ${hir.harness.revision}`,
+    `Units:        ${hir.harness.units}`,
+    `HIR schema:   ${hir.schemaVersion}`,
+    `Connectors:   ${hir.connectors.length}`,
+    `Wires:        ${hir.wires.length}`,
+    `Validation:   ${errors} error(s), ${warnings} warning(s)`,
+    "",
+    "Contents:",
+    "  manufacturing-packet.pdf    printable packet (readable without the app)",
+    "  harness.json                machine-readable HIR",
+    "  schematic.svg               wiring diagram",
+    "  board.svg                   harness board / nailboard view",
+    "  bom.csv                     bill of materials",
+    "  cut-list.csv                wire cut list",
+    "  labels.csv                  label schedule",
+    "  tests.csv                   continuity-test procedure",
+    "  test-plan.json              machine-readable test plan",
+    "  assembly-instructions.txt   build steps",
+    ""
+  ].join("\n");
+};
+var buildPacket = async (hir, options = {}) => {
+  const plan = generateTestPlan(hir);
+  const files = /* @__PURE__ */ new Map([
+    ["COVER.txt", coverSheet(hir)],
+    ["manufacturing-packet.pdf", await manufacturingPacketPdf(hir, options)],
+    ["harness.json", JSON.stringify(hir, null, 2) + "\n"],
+    ["schematic.svg", schematicSvg(hir)],
+    ["board.svg", boardSvg(hir)],
+    ["bom.csv", bomCsv(hir)],
+    ["cut-list.csv", cutListCsv(hir, options)],
+    ["labels.csv", labelScheduleCsv(hir)],
+    ["tests.csv", testPlanCsv(plan)],
+    ["test-plan.json", testPlanJson(hir)],
+    ["assembly-instructions.txt", assemblyInstructions(hir)]
+  ]);
+  const ZIP_EPOCH = new Date(1980, 5, 1);
+  const zipInput = {};
+  for (const [name, contents] of files) {
+    zipInput[name] = [
+      typeof contents === "string" ? strToU8(contents) : contents,
+      { level: 6, mtime: ZIP_EPOCH }
+    ];
+  }
+  return { files, zip: zipSync(zipInput) };
+};
+var canRelease = (hir) => !hasErrors2(hir.diagnostics);
+export {
+  assemblyInstructions,
+  boardDrawing,
+  boardSvg,
+  bomCsv,
+  bomTable,
+  buildPacket,
+  canRelease,
+  coverage,
+  cutListCsv,
+  cutListTable,
+  generateTestPlan,
+  labelScheduleCsv,
+  labelScheduleTable,
+  manufacturingPacketPdf,
+  renderSvg,
+  scaleDrawing,
+  schematicDrawing,
+  schematicSvg,
+  testPlanCsv,
+  testPlanJson,
+  testPlanTable,
+  toCsv
+};