@grayhaven/nerve 0.1.0

package/dist/index.js

@@ -0,0 +1,799 @@
+// src/dsl.ts
+var toRef = (target) => typeof target === "string" ? target : target.ref;
+var connector = (ref, part, opts) => {
+  const pins = {};
+  for (const [pin, signal] of Object.entries(opts.pins)) {
+    pins[String(pin)] = signal;
+  }
+  return {
+    kind: "connector",
+    ref,
+    part,
+    pins,
+    pin: (pin) => ({
+      kind: "pin-ref",
+      connector: ref,
+      pin: String(pin)
+    })
+  };
+};
+var toEndpoint = (input) => input.kind === "splice" ? { kind: "splice-ref", splice: input.id } : input;
+var wire = (id, from, to, props = {}) => ({
+  kind: "wire",
+  id,
+  from: toEndpoint(from),
+  to: toEndpoint(to),
+  ...props
+});
+var splice = (id, props = {}) => ({
+  kind: "splice",
+  id,
+  ...props
+});
+var cable = (id, props = {}) => ({
+  kind: "cable",
+  id,
+  ...props
+});
+var branch = (id, props) => {
+  const { path, ...rest } = props;
+  return {
+    kind: "branch",
+    id,
+    path: path.map(toRef),
+    ...rest
+  };
+};
+var label = (id, props) => {
+  const { attachTo, offsetFrom, ...rest } = props;
+  return {
+    kind: "label",
+    id,
+    attachTo: toRef(attachTo),
+    ...offsetFrom !== void 0 ? { offsetFrom: toRef(offsetFrom) } : {},
+    ...rest
+  };
+};
+var harness = (id, props) => ({
+  kind: "harness",
+  id,
+  revision: props.revision,
+  units: props.units,
+  metadata: props.metadata ?? {},
+  connectors: props.connectors,
+  wires: props.wires,
+  branches: props.branches ?? [],
+  labels: props.labels ?? [],
+  splices: props.splices ?? [],
+  cables: props.cables ?? []
+});
+
+// src/diagnostics.ts
+var DiagnosticSeverity = {
+  Error: "error",
+  Warning: "warning",
+  Info: "info"
+};
+var Codes = {
+  DuplicateConnectorRef: "HK-CONN-001",
+  UndefinedConnectorRef: "HK-CONN-002",
+  UndefinedPinRef: "HK-CONN-003",
+  DuplicateWireId: "HK-WIRE-001",
+  WireEndpointsIdentical: "HK-WIRE-002",
+  DuplicateBranchId: "HK-BRANCH-001",
+  BranchUndefinedEndpoint: "HK-BRANCH-002",
+  DuplicateLabelId: "HK-LABEL-001",
+  LabelUndefinedTarget: "HK-LABEL-002",
+  DuplicateSpliceId: "HK-SPLICE-001",
+  UndefinedSpliceRef: "HK-SPLICE-002",
+  SpliceTooFewWires: "HK-SPLICE-003",
+  SpliceUndefinedBranch: "HK-SPLICE-004",
+  DuplicateCableId: "HK-CABLE-001",
+  UndefinedCableRef: "HK-CABLE-002"
+};
+var hasErrors = (diagnostics) => diagnostics.some((d) => d.severity === DiagnosticSeverity.Error);
+
+// src/hir/schema.ts
+import { Schema } from "effect";
+var HIR_SCHEMA_VERSION = "0.1.0";
+var HirUnits = Schema.Literal("mm", "in");
+var HirPinRef = Schema.Struct({
+  connector: Schema.String,
+  pin: Schema.String
+});
+var HirSpliceRef = Schema.Struct({
+  splice: Schema.String
+});
+var HirEndpoint = Schema.Union(HirPinRef, HirSpliceRef);
+var HirPin = Schema.Struct({
+  pin: Schema.String,
+  signal: Schema.optional(Schema.String)
+});
+var HirConnector = Schema.Struct({
+  ref: Schema.String,
+  mpn: Schema.String,
+  manufacturer: Schema.optional(Schema.String),
+  family: Schema.optional(Schema.String),
+  description: Schema.optional(Schema.String),
+  gender: Schema.optional(Schema.Literal("plug", "receptacle", "hermaphroditic")),
+  pinCount: Schema.Number,
+  wireGaugeRange: Schema.optional(
+    Schema.Struct({ min: Schema.String, max: Schema.String })
+  ),
+  pins: Schema.Array(HirPin)
+});
+var HirWire = Schema.Struct({
+  id: Schema.String,
+  from: HirEndpoint,
+  to: HirEndpoint,
+  gauge: Schema.optional(Schema.String),
+  color: Schema.optional(Schema.String),
+  stripe: Schema.optional(Schema.String),
+  length: Schema.optional(Schema.Number),
+  lengthTolerance: Schema.optional(Schema.Number),
+  signal: Schema.optional(Schema.String),
+  insulation: Schema.optional(Schema.String),
+  voltageRating: Schema.optional(Schema.Number),
+  temperatureRating: Schema.optional(Schema.Number),
+  currentEstimate: Schema.optional(Schema.Number),
+  twistGroup: Schema.optional(Schema.String),
+  shieldGroup: Schema.optional(Schema.String),
+  cable: Schema.optional(Schema.String),
+  conductor: Schema.optional(Schema.String),
+  branch: Schema.optional(Schema.String),
+  notes: Schema.optional(Schema.String)
+});
+var HirSplice = Schema.Struct({
+  id: Schema.String,
+  type: Schema.optional(Schema.String),
+  part: Schema.optional(Schema.String),
+  branch: Schema.optional(Schema.String),
+  location: Schema.optional(Schema.Number),
+  notes: Schema.optional(Schema.String),
+  /** Wire IDs attached to this splice (computed by the compiler). */
+  wires: Schema.Array(Schema.String)
+});
+var HirCable = Schema.Struct({
+  id: Schema.String,
+  type: Schema.optional(Schema.String),
+  conductors: Schema.optional(Schema.Number),
+  shield: Schema.optional(Schema.String),
+  jacket: Schema.optional(Schema.String),
+  outerDiameter: Schema.optional(Schema.Number),
+  /** Longest member wire — the cable cut length (computed). */
+  cutLength: Schema.optional(Schema.Number),
+  notes: Schema.optional(Schema.String),
+  /** Member wire IDs (computed by the compiler). */
+  wires: Schema.Array(Schema.String)
+});
+var HirBranch = Schema.Struct({
+  id: Schema.String,
+  path: Schema.Array(Schema.String),
+  parent: Schema.optional(Schema.String),
+  sleeve: Schema.optional(Schema.String),
+  nominalLength: Schema.optional(Schema.Number),
+  breakoutDistance: Schema.optional(Schema.Number)
+});
+var HirLabel = Schema.Struct({
+  id: Schema.String,
+  text: Schema.String,
+  attachTo: Schema.String,
+  offsetFrom: Schema.optional(Schema.String),
+  distance: Schema.optional(Schema.Number),
+  material: Schema.optional(Schema.String),
+  quantity: Schema.optional(Schema.Number)
+});
+var HirBomItem = Schema.Struct({
+  internalPartId: Schema.optional(Schema.String),
+  mpn: Schema.String,
+  manufacturer: Schema.optional(Schema.String),
+  description: Schema.optional(Schema.String),
+  category: Schema.optional(Schema.String),
+  quantity: Schema.Number,
+  unitOfMeasure: Schema.String,
+  usedBy: Schema.Array(Schema.String),
+  notes: Schema.optional(Schema.String)
+});
+var HirDiagnostic = Schema.Struct({
+  code: Schema.String,
+  severity: Schema.Literal("error", "warning", "info"),
+  message: Schema.String,
+  target: Schema.optional(Schema.String)
+});
+var Hir = Schema.Struct({
+  schemaVersion: Schema.Literal(HIR_SCHEMA_VERSION),
+  harness: Schema.Struct({
+    id: Schema.String,
+    revision: Schema.String,
+    units: HirUnits,
+    metadata: Schema.Record({ key: Schema.String, value: Schema.String })
+  }),
+  connectors: Schema.Array(HirConnector),
+  wires: Schema.Array(HirWire),
+  cables: Schema.Array(HirCable),
+  branches: Schema.Array(HirBranch),
+  splices: Schema.Array(HirSplice),
+  labels: Schema.Array(HirLabel),
+  bom: Schema.Array(HirBomItem),
+  diagnostics: Schema.Array(HirDiagnostic),
+  layoutHints: Schema.Array(Schema.Unknown),
+  exports: Schema.Record({ key: Schema.String, value: Schema.Unknown })
+});
+var isPinEndpoint = (e) => "connector" in e;
+var endpointLabel = (e) => isPinEndpoint(e) ? `${e.connector}.${e.pin}` : e.splice;
+var decodeHir = Schema.decodeUnknownSync(Hir);
+var decodeHirEffect = Schema.decodeUnknown(Hir);
+var encodeHir = Schema.encodeSync(Hir);
+var refs = {
+  connector: (ref) => `connector:${ref}`,
+  pin: (connector2, pin) => `connector:${connector2}.pin:${pin}`,
+  wire: (id) => `wire:${id}`,
+  branch: (id) => `branch:${id}`,
+  splice: (id) => `splice:${id}`,
+  label: (id) => `label:${id}`,
+  bom: (mpn) => `bom:${mpn}`
+};
+
+// src/compile.ts
+var comparePins = (a, b) => {
+  const na = Number(a);
+  const nb = Number(b);
+  if (Number.isFinite(na) && Number.isFinite(nb)) return na - nb;
+  return a < b ? -1 : a > b ? 1 : 0;
+};
+var compareStrings = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+var compact = (obj) => {
+  const out = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (value !== void 0) out[key] = value;
+  }
+  return out;
+};
+var compileDesign = (design) => {
+  const diagnostics = [];
+  const report = (code, message, target, severity = DiagnosticSeverity.Error) => {
+    diagnostics.push(
+      target !== void 0 ? { code, severity, message, target } : { code, severity, message }
+    );
+  };
+  const connectorByRef = /* @__PURE__ */ new Map();
+  for (const c of design.connectors) {
+    if (connectorByRef.has(c.ref)) {
+      report(
+        Codes.DuplicateConnectorRef,
+        `Connector reference ${c.ref} is defined more than once.`,
+        refs.connector(c.ref)
+      );
+      continue;
+    }
+    connectorByRef.set(c.ref, c);
+  }
+  const connectors = [...connectorByRef.values()].sort((a, b) => compareStrings(a.ref, b.ref)).map(
+    (c) => compact({
+      ref: c.ref,
+      mpn: c.part.mpn,
+      manufacturer: c.part.manufacturer,
+      family: c.part.family,
+      description: c.part.description,
+      gender: c.part.gender,
+      pinCount: c.part.pinCount,
+      wireGaugeRange: c.part.wireGaugeRange ? { min: c.part.wireGaugeRange.min, max: c.part.wireGaugeRange.max } : void 0,
+      pins: Object.entries(c.pins).sort(([a], [b]) => comparePins(a, b)).map(([pin, signal]) => compact({ pin, signal }))
+    })
+  );
+  const pinExists = (connectorRef, pin) => {
+    const c = connectorByRef.get(connectorRef);
+    if (c === void 0) return false;
+    if (pin in c.pins) return true;
+    const n = Number(pin);
+    return Number.isInteger(n) && n >= 1 && n <= c.part.pinCount;
+  };
+  const spliceIds = /* @__PURE__ */ new Set();
+  for (const s of design.splices) {
+    if (spliceIds.has(s.id)) {
+      report(
+        Codes.DuplicateSpliceId,
+        `Splice ID ${s.id} is defined more than once.`,
+        refs.splice(s.id)
+      );
+    }
+    spliceIds.add(s.id);
+  }
+  const cableIds = /* @__PURE__ */ new Set();
+  for (const c of design.cables) {
+    if (cableIds.has(c.id)) {
+      report(
+        Codes.DuplicateCableId,
+        `Cable ID ${c.id} is defined more than once.`,
+        `cable:${c.id}`
+      );
+    }
+    cableIds.add(c.id);
+  }
+  const checkEndpoint = (owner, end) => {
+    if (!("connector" in end)) {
+      if (!spliceIds.has(end.splice)) {
+        report(
+          Codes.UndefinedSpliceRef,
+          `${owner} references undefined splice ${end.splice}.`,
+          refs.splice(end.splice)
+        );
+      }
+      return;
+    }
+    if (!connectorByRef.has(end.connector)) {
+      report(
+        Codes.UndefinedConnectorRef,
+        `${owner} references undefined connector ${end.connector}.`,
+        refs.connector(end.connector)
+      );
+    } else if (!pinExists(end.connector, end.pin)) {
+      report(
+        Codes.UndefinedPinRef,
+        `${owner} references pin ${end.pin} which does not exist on connector ${end.connector}.`,
+        refs.pin(end.connector, end.pin)
+      );
+    }
+  };
+  const toHirEndpoint = (e) => e.kind === "pin-ref" ? { connector: e.connector, pin: e.pin } : { splice: e.splice };
+  const wireIds = /* @__PURE__ */ new Set();
+  const wires = [];
+  for (const w of design.wires) {
+    if (wireIds.has(w.id)) {
+      report(
+        Codes.DuplicateWireId,
+        `Wire ID ${w.id} is defined more than once.`,
+        refs.wire(w.id)
+      );
+      continue;
+    }
+    wireIds.add(w.id);
+    const ownerLabel = `Wire ${w.id}`;
+    const from = toHirEndpoint(w.from);
+    const to = toHirEndpoint(w.to);
+    checkEndpoint(ownerLabel, from);
+    checkEndpoint(ownerLabel, to);
+    if (endpointLabel(from) === endpointLabel(to)) {
+      report(
+        Codes.WireEndpointsIdentical,
+        `Wire ${w.id} starts and ends on the same endpoint ${endpointLabel(from)}.`,
+        refs.wire(w.id)
+      );
+    }
+    if (w.cable !== void 0 && !cableIds.has(w.cable)) {
+      report(
+        Codes.UndefinedCableRef,
+        `Wire ${w.id} references undefined cable ${w.cable}.`,
+        refs.wire(w.id)
+      );
+    }
+    wires.push(
+      compact({
+        id: w.id,
+        from,
+        to,
+        gauge: w.gauge,
+        color: w.color,
+        stripe: w.stripe,
+        length: w.length,
+        lengthTolerance: w.lengthTolerance,
+        signal: w.signal,
+        insulation: w.insulation,
+        voltageRating: w.voltageRating,
+        temperatureRating: w.temperatureRating,
+        currentEstimate: w.currentEstimate,
+        twistGroup: w.twistGroup,
+        shieldGroup: w.shieldGroup,
+        cable: w.cable,
+        conductor: w.conductor !== void 0 ? String(w.conductor) : void 0,
+        notes: w.notes
+      })
+    );
+  }
+  wires.sort((a, b) => compareStrings(a.id, b.id));
+  const spliceWires = (id) => wires.filter(
+    (w) => !("connector" in w.from) && w.from.splice === id || !("connector" in w.to) && w.to.splice === id
+  ).map((w) => w.id);
+  const designBranchIds = new Set(design.branches.map((b) => b.id));
+  const seenSplices = /* @__PURE__ */ new Set();
+  const splices = [];
+  for (const s of design.splices) {
+    if (seenSplices.has(s.id)) continue;
+    seenSplices.add(s.id);
+    if (s.branch !== void 0 && !designBranchIds.has(s.branch)) {
+      report(
+        Codes.SpliceUndefinedBranch,
+        `Splice ${s.id} is located on undefined branch ${s.branch}.`,
+        refs.splice(s.id)
+      );
+    }
+    const attached = spliceWires(s.id);
+    if (attached.length < 2) {
+      report(
+        Codes.SpliceTooFewWires,
+        `Splice ${s.id} joins ${attached.length} wire(s); a splice needs at least 2.`,
+        refs.splice(s.id),
+        DiagnosticSeverity.Error
+      );
+    }
+    splices.push(
+      compact({
+        id: s.id,
+        type: s.type,
+        part: s.part,
+        branch: s.branch,
+        location: s.location,
+        notes: s.notes,
+        wires: attached
+      })
+    );
+  }
+  splices.sort((a, b) => compareStrings(a.id, b.id));
+  const seenCables = /* @__PURE__ */ new Set();
+  const cables = [];
+  for (const c of design.cables) {
+    if (seenCables.has(c.id)) continue;
+    seenCables.add(c.id);
+    const members = wires.filter((w) => w.cable === c.id);
+    const lengths = members.map((w) => w.length).filter((l) => l !== void 0);
+    cables.push(
+      compact({
+        id: c.id,
+        type: c.type,
+        conductors: c.conductors,
+        shield: c.shield,
+        jacket: c.jacket,
+        outerDiameter: c.outerDiameter,
+        cutLength: lengths.length > 0 ? Math.max(...lengths) : void 0,
+        notes: c.notes,
+        wires: members.map((w) => w.id)
+      })
+    );
+  }
+  cables.sort((a, b) => compareStrings(a.id, b.id));
+  const branchIds = /* @__PURE__ */ new Set();
+  const branches = [];
+  for (const b of design.branches) {
+    if (branchIds.has(b.id)) {
+      report(
+        Codes.DuplicateBranchId,
+        `Branch ID ${b.id} is defined more than once.`,
+        refs.branch(b.id)
+      );
+      continue;
+    }
+    branchIds.add(b.id);
+    for (const endpoint of b.path) {
+      if (!connectorByRef.has(endpoint)) {
+        report(
+          Codes.BranchUndefinedEndpoint,
+          `Branch ${b.id} path references undefined connector ${endpoint}.`,
+          refs.branch(b.id)
+        );
+      }
+    }
+    branches.push(
+      compact({
+        id: b.id,
+        path: [...b.path],
+        parent: b.parent,
+        sleeve: b.sleeve,
+        nominalLength: b.nominalLength,
+        breakoutDistance: b.breakoutDistance
+      })
+    );
+  }
+  branches.sort((a, b) => compareStrings(a.id, b.id));
+  const labelIds = /* @__PURE__ */ new Set();
+  const labels = [];
+  for (const l of design.labels) {
+    if (labelIds.has(l.id)) {
+      report(
+        Codes.DuplicateLabelId,
+        `Label ID ${l.id} is defined more than once.`,
+        refs.label(l.id)
+      );
+      continue;
+    }
+    labelIds.add(l.id);
+    if (!branchIds.has(l.attachTo) && !connectorByRef.has(l.attachTo)) {
+      report(
+        Codes.LabelUndefinedTarget,
+        `Label ${l.id} attaches to ${l.attachTo}, which is not a defined branch or connector.`,
+        refs.label(l.id)
+      );
+    }
+    if (l.offsetFrom !== void 0 && !connectorByRef.has(l.offsetFrom)) {
+      report(
+        Codes.LabelUndefinedTarget,
+        `Label ${l.id} is offset from ${l.offsetFrom}, which is not a defined connector.`,
+        refs.label(l.id)
+      );
+    }
+    labels.push(
+      compact({
+        id: l.id,
+        text: l.text,
+        attachTo: l.attachTo,
+        offsetFrom: l.offsetFrom,
+        distance: l.distance,
+        material: l.material,
+        quantity: l.quantity
+      })
+    );
+  }
+  labels.sort((a, b) => compareStrings(a.id, b.id));
+  const bomByMpn = /* @__PURE__ */ new Map();
+  for (const c of [...connectorByRef.values()].sort((a, b) => compareStrings(a.ref, b.ref))) {
+    const existing = bomByMpn.get(c.part.mpn);
+    if (existing) {
+      existing.usedBy.push(refs.connector(c.ref));
+    } else {
+      bomByMpn.set(c.part.mpn, {
+        item: compact({
+          mpn: c.part.mpn,
+          manufacturer: c.part.manufacturer,
+          description: c.part.description,
+          category: "connector",
+          quantity: 0,
+          unitOfMeasure: "ea"
+        }),
+        usedBy: [refs.connector(c.ref)]
+      });
+    }
+  }
+  const bom = [...bomByMpn.values()].map(({ item, usedBy }) => ({ ...item, quantity: usedBy.length, usedBy })).sort((a, b) => compareStrings(a.mpn, b.mpn));
+  diagnostics.sort(
+    (a, b) => compareStrings(a.target ?? "", b.target ?? "") || compareStrings(a.code, b.code) || compareStrings(a.message, b.message)
+  );
+  const hir = {
+    schemaVersion: HIR_SCHEMA_VERSION,
+    harness: {
+      id: design.id,
+      revision: design.revision,
+      units: design.units,
+      metadata: design.metadata
+    },
+    connectors,
+    wires,
+    cables,
+    branches,
+    splices,
+    labels,
+    bom,
+    diagnostics,
+    layoutHints: [],
+    exports: {}
+  };
+  return { hir, diagnostics };
+};
+
+// src/config.ts
+var defineConfig = (config) => config;
+
+// src/variant.ts
+var apply = (items, mods) => {
+  if (mods === void 0) return items;
+  const removed = new Set(mods.remove ?? []);
+  const out = items.filter((item) => !removed.has(item.id)).map(
+    (item) => mods.override?.[item.id] !== void 0 ? { ...item, ...mods.override[item.id] } : item
+  );
+  return [...out, ...mods.add ?? []];
+};
+var applyConnectors = (items, mods) => {
+  if (mods === void 0) return items;
+  const removed = new Set(mods.remove ?? []);
+  return [...items.filter((c) => !removed.has(c.ref)), ...mods.add ?? []];
+};
+var variant = (base, opts) => ({
+  kind: "harness",
+  id: opts.id,
+  revision: opts.revision ?? base.revision,
+  units: base.units,
+  metadata: {
+    ...base.metadata,
+    ...opts.metadata,
+    variantOf: base.id
+  },
+  connectors: applyConnectors(base.connectors, opts.connectors),
+  wires: apply(base.wires, opts.wires),
+  branches: apply(base.branches, opts.branches),
+  labels: apply(base.labels, opts.labels),
+  splices: apply(base.splices, opts.splices),
+  cables: apply(base.cables, opts.cables)
+});
+
+// src/diff.ts
+var show = (v) => v === void 0 ? "(none)" : typeof v === "string" ? v : JSON.stringify(v);
+var fieldChanges = (a, b, fields) => {
+  const changes = [];
+  for (const [field, get] of fields) {
+    const from = get(a);
+    const to = get(b);
+    if (show(from) !== show(to)) changes.push({ field, from: show(from), to: show(to) });
+  }
+  return changes;
+};
+var sectionDiff = (as, bs, key, fields) => {
+  const aMap = new Map(as.map((x) => [key(x), x]));
+  const bMap = new Map(bs.map((x) => [key(x), x]));
+  const added = [...bMap.keys()].filter((k) => !aMap.has(k));
+  const removed = [...aMap.keys()].filter((k) => !bMap.has(k));
+  const changed = [];
+  for (const [k, a] of aMap) {
+    const b = bMap.get(k);
+    if (b === void 0) continue;
+    const changes = fieldChanges(a, b, fields);
+    if (changes.length > 0) changed.push({ id: k, changes });
+  }
+  return { added, removed, changed };
+};
+var diffHir = (a, b) => {
+  const pinouts = [];
+  const bConnectors = new Map(b.connectors.map((c) => [c.ref, c]));
+  for (const ca of a.connectors) {
+    const cb = bConnectors.get(ca.ref);
+    if (cb === void 0) continue;
+    const aPins = new Map(ca.pins.map((p) => [p.pin, p.signal]));
+    const bPins = new Map(cb.pins.map((p) => [p.pin, p.signal]));
+    for (const pin of /* @__PURE__ */ new Set([...aPins.keys(), ...bPins.keys()])) {
+      const from = aPins.get(pin);
+      const to = bPins.get(pin);
+      if (from !== to) pinouts.push({ connector: ca.ref, pin, from, to });
+    }
+  }
+  return {
+    harness: fieldChanges(a.harness, b.harness, [
+      ["id", (h) => h.id],
+      ["revision", (h) => h.revision],
+      ["units", (h) => h.units]
+    ]),
+    connectors: sectionDiff(a.connectors, b.connectors, (c) => c.ref, [
+      ["mpn", (c) => c.mpn],
+      ["pinCount", (c) => c.pinCount],
+      ["gender", (c) => c.gender]
+    ]),
+    pinouts,
+    wires: sectionDiff(a.wires, b.wires, (w) => w.id, [
+      ["from", (w) => endpointLabel(w.from)],
+      ["to", (w) => endpointLabel(w.to)],
+      ["gauge", (w) => w.gauge],
+      ["color", (w) => w.color],
+      ["length", (w) => w.length],
+      ["signal", (w) => w.signal],
+      ["twistGroup", (w) => w.twistGroup],
+      ["cable", (w) => w.cable]
+    ]),
+    splices: sectionDiff(a.splices, b.splices, (s) => s.id, [
+      ["type", (s) => s.type],
+      ["part", (s) => s.part],
+      ["branch", (s) => s.branch],
+      ["location", (s) => s.location],
+      ["wires", (s) => s.wires.join(", ")]
+    ]),
+    cables: sectionDiff(a.cables, b.cables, (c) => c.id, [
+      ["type", (c) => c.type],
+      ["conductors", (c) => c.conductors],
+      ["cutLength", (c) => c.cutLength],
+      ["wires", (c) => c.wires.join(", ")]
+    ]),
+    branches: sectionDiff(a.branches, b.branches, (br) => br.id, [
+      ["path", (br) => br.path.join(" \u2192 ")],
+      ["sleeve", (br) => br.sleeve],
+      ["nominalLength", (br) => br.nominalLength],
+      ["parent", (br) => br.parent]
+    ]),
+    labels: sectionDiff(a.labels, b.labels, (l) => l.id, [
+      ["text", (l) => l.text],
+      ["attachTo", (l) => l.attachTo],
+      ["offsetFrom", (l) => l.offsetFrom],
+      ["distance", (l) => l.distance]
+    ]),
+    bom: sectionDiff(a.bom, b.bom, (i) => i.mpn, [
+      ["quantity", (i) => i.quantity],
+      ["usedBy", (i) => i.usedBy.join(", ")]
+    ])
+  };
+};
+var isEmptyDiff = (d) => d.harness.length === 0 && d.pinouts.length === 0 && [d.connectors, d.wires, d.splices, d.cables, d.branches, d.labels, d.bom].every(
+  (s) => s.added.length === 0 && s.removed.length === 0 && s.changed.length === 0
+);
+var formatDiff = (d) => {
+  const lines = [];
+  const section = (title, s, prefix) => {
+    if (s.added.length === 0 && s.removed.length === 0 && s.changed.length === 0) return;
+    lines.push(`${title}:`);
+    for (const id of s.added) lines.push(`  + ${prefix}:${id}`);
+    for (const id of s.removed) lines.push(`  - ${prefix}:${id}`);
+    for (const c of s.changed) {
+      lines.push(`  ~ ${prefix}:${c.id}`);
+      for (const f of c.changes) lines.push(`      ${f.field}: ${f.from} -> ${f.to}`);
+    }
+  };
+  if (d.harness.length > 0) {
+    lines.push("harness:");
+    for (const f of d.harness) lines.push(`  ~ ${f.field}: ${f.from} -> ${f.to}`);
+  }
+  section("connectors", d.connectors, "connector");
+  if (d.pinouts.length > 0) {
+    lines.push("pinouts:");
+    for (const p of d.pinouts) {
+      lines.push(`  ~ connector:${p.connector}.pin:${p.pin}: ${show(p.from)} -> ${show(p.to)}`);
+    }
+  }
+  section("wires", d.wires, "wire");
+  section("splices", d.splices, "splice");
+  section("cables", d.cables, "cable");
+  section("branches", d.branches, "branch");
+  section("labels", d.labels, "label");
+  section("bom", d.bom, "bom");
+  return lines.length === 0 ? "No differences.\n" : lines.join("\n") + "\n";
+};
+
+// src/rules.ts
+var rule = (name, run, options = {}) => ({
+  name,
+  code: options.code ?? `HK-RULE-${name.toUpperCase().replace(/[^A-Z0-9]+/g, "-")}`,
+  run
+});
+var runRules = (hir, rules, config = {}) => {
+  const diagnostics = [];
+  for (const r of rules) {
+    const override = config[r.name];
+    if (override === "off") continue;
+    r.run({
+      hir,
+      report: ({ severity, message, target, code }) => {
+        diagnostics.push({
+          code: code ?? r.code,
+          severity: override ?? severity,
+          message,
+          ...target !== void 0 ? { target } : {}
+        });
+      }
+    });
+  }
+  diagnostics.sort(
+    (a, b) => cmp(a.target ?? "", b.target ?? "") || cmp(a.code, b.code) || cmp(a.message, b.message)
+  );
+  return diagnostics;
+};
+var cmp = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+export {
+  Codes,
+  DiagnosticSeverity,
+  HIR_SCHEMA_VERSION,
+  Hir,
+  HirBomItem,
+  HirBranch,
+  HirCable,
+  HirConnector,
+  HirEndpoint,
+  HirLabel,
+  HirPinRef,
+  HirSplice,
+  HirSpliceRef,
+  HirWire,
+  branch,
+  cable,
+  compileDesign,
+  connector,
+  decodeHir,
+  decodeHirEffect,
+  defineConfig,
+  diffHir,
+  encodeHir,
+  endpointLabel,
+  formatDiff,
+  harness,
+  hasErrors,
+  isEmptyDiff,
+  isPinEndpoint,
+  label,
+  refs,
+  rule,
+  runRules,
+  splice,
+  variant,
+  wire
+};