@grayhaven/nerve-react 0.5.0

package/dist/chunk-IBL3BQIP.js

@@ -0,0 +1,13 @@
+// src/jsx-runtime.ts
+var jsx = (type, props) => type(props);
+var jsxs = jsx;
+var jsxDEV = (type, props) => type(props);
+var Fragment = (props) => props.children;
+
+export {
+  jsx,
+  jsxs,
+  jsxDEV,
+  Fragment
+};
+//# sourceMappingURL=chunk-IBL3BQIP.js.map

package/dist/chunk-IBL3BQIP.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/jsx-runtime.ts"],"sourcesContent":["/**\n * Custom JSX runtime (automatic mode): no React, no fiber, no VDOM —\n * `jsx(Component, props)` simply CALLS the component. JSX becomes pure\n * function application over the typed DSL, so authoring style changes\n * and nothing else does.\n */\nexport type JsxComponent<P, R> = (props: P) => R\n\nexport const jsx = <P, R>(type: JsxComponent<P, R>, props: P): R => type(props)\nexport const jsxs = jsx\nexport const jsxDEV = <P, R>(type: JsxComponent<P, R>, props: P): R => type(props)\n\nexport const Fragment = (props: { children?: unknown }): unknown => props.children\n\n// Minimal JSX namespace: components only (no intrinsic lowercase elements —\n// <Harness> not <harness>, keeping every element a typed function).\ndeclare global {\n  namespace JSX {\n    // Element is intentionally loose (each component returns its own def\n    // type); ElementType constrains elements to component FUNCTIONS.\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    type Element = any\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    type ElementType = (props: any) => unknown\n    interface ElementChildrenAttribute {\n      children: unknown\n    }\n    interface IntrinsicElements {\n      [k: string]: never\n    }\n  }\n}\n"],"mappings":";AAQO,IAAM,MAAM,CAAO,MAA0B,UAAgB,KAAK,KAAK;AACvE,IAAM,OAAO;AACb,IAAM,SAAS,CAAO,MAA0B,UAAgB,KAAK,KAAK;AAE1E,IAAM,WAAW,CAAC,UAA2C,MAAM;","names":[]}

package/dist/index.d.ts

@@ -0,0 +1,40 @@
+import * as _grayhaven_nerve from '@grayhaven/nerve';
+import { BranchProps, CableProps, connector, wire, branch, label, splice, cable, ConnectorPart, PinAssignments, PinPartAssignment, HarnessDesign, LabelProps, SpliceProps, WireProps } from '@grayhaven/nerve';
+export { Fragment, jsx, jsxs } from './jsx-runtime.js';
+
+type Def = ReturnType<typeof connector | typeof wire | typeof branch | typeof label | typeof splice | typeof cable>;
+type Children = Def | ReadonlyArray<Children> | undefined | null | false;
+declare function Connector(props: {
+    ref: string;
+    part: ConnectorPart;
+    pins: PinAssignments;
+    terminals?: PinPartAssignment;
+    seals?: PinPartAssignment;
+}): _grayhaven_nerve.ConnectorInstance;
+declare function Wire(props: {
+    id: string;
+    from: string;
+    to: string;
+} & WireProps): _grayhaven_nerve.WireDef;
+declare function Splice(props: {
+    id: string;
+} & SpliceProps): _grayhaven_nerve.SpliceDef;
+declare function Cable(props: {
+    id: string;
+} & CableProps): _grayhaven_nerve.CableDef;
+declare function Branch(props: {
+    id: string;
+} & Omit<BranchProps, "path"> & {
+    path: ReadonlyArray<string>;
+}): _grayhaven_nerve.BranchDef;
+declare function Label(props: {
+    id: string;
+} & LabelProps): _grayhaven_nerve.LabelDef;
+declare function Harness(props: {
+    id: string;
+    revision: string;
+    units: "mm" | "in";
+    children?: Children;
+}): HarnessDesign;
+
+export { Branch, Cable, type Children, Connector, Harness, Label, Splice, Wire };

package/dist/index.js

@@ -0,0 +1,77 @@
+import {
+  Fragment,
+  jsx,
+  jsxs
+} from "./chunk-IBL3BQIP.js";
+
+// src/components.ts
+import {
+  branch as branchFn,
+  cable as cableFn,
+  connector as connectorFn,
+  harness as harnessFn,
+  label as labelFn,
+  splice as spliceFn,
+  wire as wireFn
+} from "@grayhaven/nerve";
+var flatten = (children) => {
+  if (children === void 0 || children === null || children === false) return [];
+  if (Array.isArray(children)) return children.flatMap(flatten);
+  return [children];
+};
+var endpoint = (s) => {
+  const dot = s.lastIndexOf(".");
+  if (dot === -1) return { kind: "splice-ref", splice: s };
+  return { kind: "pin-ref", connector: s.slice(0, dot), pin: s.slice(dot + 1) };
+};
+function Connector(props) {
+  const { ref, part, ...rest } = props;
+  return connectorFn(ref, part, rest);
+}
+function Wire(props) {
+  const { id, from, to, ...rest } = props;
+  return wireFn(id, endpoint(from), endpoint(to), rest);
+}
+function Splice(props) {
+  const { id, ...rest } = props;
+  return spliceFn(id, rest);
+}
+function Cable(props) {
+  const { id, ...rest } = props;
+  return cableFn(id, rest);
+}
+function Branch(props) {
+  const { id, ...rest } = props;
+  return branchFn(id, rest);
+}
+function Label(props) {
+  const { id, ...rest } = props;
+  return labelFn(id, rest);
+}
+function Harness(props) {
+  const kids = flatten(props.children);
+  const byKind = (kind) => kids.filter((k) => k.kind === kind);
+  return harnessFn(props.id, {
+    revision: props.revision,
+    units: props.units,
+    connectors: byKind("connector"),
+    wires: byKind("wire"),
+    splices: byKind("splice"),
+    cables: byKind("cable"),
+    branches: byKind("branch"),
+    labels: byKind("label")
+  });
+}
+export {
+  Branch,
+  Cable,
+  Connector,
+  Fragment,
+  Harness,
+  Label,
+  Splice,
+  Wire,
+  jsx,
+  jsxs
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components.ts"],"sourcesContent":["/**\n * JSX components for harness authoring (tscircuit-inspired, experimental).\n * No React: these are plain functions invoked by the custom JSX runtime in\n * jsx-runtime.ts. The output is the SAME typed design objects the function\n * DSL produces — <Harness> compiles to byte-identical HIR (proven in\n * tests), so JSX is purely an authoring-style choice.\n *\n *   /** @jsxImportSource @grayhaven/nerve-react *​/\n *   export default (\n *     <Harness id=\"h\" revision=\"A\" units=\"mm\">\n *       <Connector ref=\"J1\" part={part(\"microfit-2x8\")} pins={{ 1: \"VBAT\" }} />\n *       <Wire id=\"W1\" from=\"J1.1\" to=\"M1.1\" gauge=\"20AWG\" color=\"red\" length={420} />\n *     </Harness>\n *   )\n *\n * Endpoints are strings: \"J1.3\" (connector.pin) or a splice id (\"S1\").\n */\nimport {\n  branch as branchFn,\n  cable as cableFn,\n  connector as connectorFn,\n  harness as harnessFn,\n  label as labelFn,\n  splice as spliceFn,\n  wire as wireFn,\n  type BranchProps,\n  type CableProps,\n  type ConnectorPart,\n  type HarnessDesign,\n  type LabelProps,\n  type PinAssignments,\n  type PinPartAssignment,\n  type SpliceProps,\n  type WireProps\n} from \"@grayhaven/nerve\"\n\ntype Def = ReturnType<\n  | typeof connectorFn\n  | typeof wireFn\n  | typeof branchFn\n  | typeof labelFn\n  | typeof spliceFn\n  | typeof cableFn\n>\n\nexport type Children = Def | ReadonlyArray<Children> | undefined | null | false\n\nexport const flatten = (children: Children): Array<Def> => {\n  if (children === undefined || children === null || children === false) return []\n  if (Array.isArray(children)) return (children as ReadonlyArray<Children>).flatMap(flatten)\n  return [children as Def]\n}\n\n/** \"J1.3\" -> pin ref; anything without a dot is a splice id. */\nconst endpoint = (s: string) => {\n  const dot = s.lastIndexOf(\".\")\n  if (dot === -1) return { kind: \"splice-ref\" as const, splice: s }\n  return { kind: \"pin-ref\" as const, connector: s.slice(0, dot), pin: s.slice(dot + 1) }\n}\n\nexport function Connector(props: {\n  ref: string\n  part: ConnectorPart\n  pins: PinAssignments\n  terminals?: PinPartAssignment\n  seals?: PinPartAssignment\n}) {\n  const { ref, part, ...rest } = props\n  return connectorFn(ref, part, rest)\n}\n\nexport function Wire(props: { id: string; from: string; to: string } & WireProps) {\n  const { id, from, to, ...rest } = props\n  return wireFn(id, endpoint(from), endpoint(to), rest)\n}\n\nexport function Splice(props: { id: string } & SpliceProps) {\n  const { id, ...rest } = props\n  return spliceFn(id, rest)\n}\n\nexport function Cable(props: { id: string } & CableProps) {\n  const { id, ...rest } = props\n  return cableFn(id, rest)\n}\n\nexport function Branch(props: { id: string } & Omit<BranchProps, \"path\"> & { path: ReadonlyArray<string> }) {\n  const { id, ...rest } = props\n  return branchFn(id, rest)\n}\n\nexport function Label(props: { id: string } & LabelProps) {\n  const { id, ...rest } = props\n  return labelFn(id, rest)\n}\n\nexport function Harness(props: {\n  id: string\n  revision: string\n  units: \"mm\" | \"in\"\n  children?: Children\n}): HarnessDesign {\n  const kids = flatten(props.children)\n  const byKind = (kind: Def[\"kind\"]) => kids.filter((k) => k.kind === kind)\n  return harnessFn(props.id, {\n    revision: props.revision,\n    units: props.units,\n    connectors: byKind(\"connector\") as never,\n    wires: byKind(\"wire\") as never,\n    splices: byKind(\"splice\") as never,\n    cables: byKind(\"cable\") as never,\n    branches: byKind(\"branch\") as never,\n    labels: byKind(\"label\") as never\n  })\n}\n"],"mappings":";;;;;;;AAiBA;AAAA,EACE,UAAU;AAAA,EACV,SAAS;AAAA,EACT,aAAa;AAAA,EACb,WAAW;AAAA,EACX,SAAS;AAAA,EACT,UAAU;AAAA,EACV,QAAQ;AAAA,OAUH;AAaA,IAAM,UAAU,CAAC,aAAmC;AACzD,MAAI,aAAa,UAAa,aAAa,QAAQ,aAAa,MAAO,QAAO,CAAC;AAC/E,MAAI,MAAM,QAAQ,QAAQ,EAAG,QAAQ,SAAqC,QAAQ,OAAO;AACzF,SAAO,CAAC,QAAe;AACzB;AAGA,IAAM,WAAW,CAAC,MAAc;AAC9B,QAAM,MAAM,EAAE,YAAY,GAAG;AAC7B,MAAI,QAAQ,GAAI,QAAO,EAAE,MAAM,cAAuB,QAAQ,EAAE;AAChE,SAAO,EAAE,MAAM,WAAoB,WAAW,EAAE,MAAM,GAAG,GAAG,GAAG,KAAK,EAAE,MAAM,MAAM,CAAC,EAAE;AACvF;AAEO,SAAS,UAAU,OAMvB;AACD,QAAM,EAAE,KAAK,MAAM,GAAG,KAAK,IAAI;AAC/B,SAAO,YAAY,KAAK,MAAM,IAAI;AACpC;AAEO,SAAS,KAAK,OAA6D;AAChF,QAAM,EAAE,IAAI,MAAM,IAAI,GAAG,KAAK,IAAI;AAClC,SAAO,OAAO,IAAI,SAAS,IAAI,GAAG,SAAS,EAAE,GAAG,IAAI;AACtD;AAEO,SAAS,OAAO,OAAqC;AAC1D,QAAM,EAAE,IAAI,GAAG,KAAK,IAAI;AACxB,SAAO,SAAS,IAAI,IAAI;AAC1B;AAEO,SAAS,MAAM,OAAoC;AACxD,QAAM,EAAE,IAAI,GAAG,KAAK,IAAI;AACxB,SAAO,QAAQ,IAAI,IAAI;AACzB;AAEO,SAAS,OAAO,OAAqF;AAC1G,QAAM,EAAE,IAAI,GAAG,KAAK,IAAI;AACxB,SAAO,SAAS,IAAI,IAAI;AAC1B;AAEO,SAAS,MAAM,OAAoC;AACxD,QAAM,EAAE,IAAI,GAAG,KAAK,IAAI;AACxB,SAAO,QAAQ,IAAI,IAAI;AACzB;AAEO,SAAS,QAAQ,OAKN;AAChB,QAAM,OAAO,QAAQ,MAAM,QAAQ;AACnC,QAAM,SAAS,CAAC,SAAsB,KAAK,OAAO,CAAC,MAAM,EAAE,SAAS,IAAI;AACxE,SAAO,UAAU,MAAM,IAAI;AAAA,IACzB,UAAU,MAAM;AAAA,IAChB,OAAO,MAAM;AAAA,IACb,YAAY,OAAO,WAAW;AAAA,IAC9B,OAAO,OAAO,MAAM;AAAA,IACpB,SAAS,OAAO,QAAQ;AAAA,IACxB,QAAQ,OAAO,OAAO;AAAA,IACtB,UAAU,OAAO,QAAQ;AAAA,IACzB,QAAQ,OAAO,OAAO;AAAA,EACxB,CAAC;AACH;","names":[]}

package/dist/jsx-runtime.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Custom JSX runtime (automatic mode): no React, no fiber, no VDOM —
+ * `jsx(Component, props)` simply CALLS the component. JSX becomes pure
+ * function application over the typed DSL, so authoring style changes
+ * and nothing else does.
+ */
+type JsxComponent<P, R> = (props: P) => R;
+declare const jsx: <P, R>(type: JsxComponent<P, R>, props: P) => R;
+declare const jsxs: <P, R>(type: JsxComponent<P, R>, props: P) => R;
+declare const jsxDEV: <P, R>(type: JsxComponent<P, R>, props: P) => R;
+declare const Fragment: (props: {
+    children?: unknown;
+}) => unknown;
+declare global {
+    namespace JSX {
+        type Element = any;
+        type ElementType = (props: any) => unknown;
+        interface ElementChildrenAttribute {
+            children: unknown;
+        }
+        interface IntrinsicElements {
+            [k: string]: never;
+        }
+    }
+}
+
+export { Fragment, type JsxComponent, jsx, jsxDEV, jsxs };

package/dist/jsx-runtime.js

@@ -0,0 +1,13 @@
+import {
+  Fragment,
+  jsx,
+  jsxDEV,
+  jsxs
+} from "./chunk-IBL3BQIP.js";
+export {
+  Fragment,
+  jsx,
+  jsxDEV,
+  jsxs
+};
+//# sourceMappingURL=jsx-runtime.js.map

package/dist/jsx-runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@grayhaven/nerve-react",
+  "version": "0.5.0",
+  "description": "JSX authoring for Grayhaven Nerve harnesses (experimental). No React runtime — a 2KB custom JSX factory over the same typed DSL.",
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts",
+    "./jsx-runtime": "./src/jsx-runtime.ts",
+    "./jsx-dev-runtime": "./src/jsx-runtime.ts"
+  },
+  "publishConfig": {
+    "exports": {
+      ".": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "./jsx-runtime": {
+        "types": "./dist/jsx-runtime.d.ts",
+        "default": "./dist/jsx-runtime.js"
+      },
+      "./jsx-dev-runtime": {
+        "types": "./dist/jsx-runtime.d.ts",
+        "default": "./dist/jsx-runtime.js"
+      }
+    }
+  },
+  "scripts": {
+    "build": "tsup src/index.ts src/jsx-runtime.ts --format esm --dts --sourcemap --clean",
+    "typecheck": "tsc -p . --noEmit"
+  },
+  "dependencies": {
+    "@grayhaven/nerve": "0.4.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.5.0",
+    "typescript": "^5.8.3",
+    "@grayhaven/nerve-connectors": "0.4.0"
+  },
+  "license": "Apache-2.0"
+}

package/src/components.ts

@@ -0,0 +1,115 @@
+/**
+ * JSX components for harness authoring (tscircuit-inspired, experimental).
+ * No React: these are plain functions invoked by the custom JSX runtime in
+ * jsx-runtime.ts. The output is the SAME typed design objects the function
+ * DSL produces — <Harness> compiles to byte-identical HIR (proven in
+ * tests), so JSX is purely an authoring-style choice.
+ *
+ *   /** @jsxImportSource @grayhaven/nerve-react *​/
+ *   export default (
+ *     <Harness id="h" revision="A" units="mm">
+ *       <Connector ref="J1" part={part("microfit-2x8")} pins={{ 1: "VBAT" }} />
+ *       <Wire id="W1" from="J1.1" to="M1.1" gauge="20AWG" color="red" length={420} />
+ *     </Harness>
+ *   )
+ *
+ * Endpoints are strings: "J1.3" (connector.pin) or a splice id ("S1").
+ */
+import {
+  branch as branchFn,
+  cable as cableFn,
+  connector as connectorFn,
+  harness as harnessFn,
+  label as labelFn,
+  splice as spliceFn,
+  wire as wireFn,
+  type BranchProps,
+  type CableProps,
+  type ConnectorPart,
+  type HarnessDesign,
+  type LabelProps,
+  type PinAssignments,
+  type PinPartAssignment,
+  type SpliceProps,
+  type WireProps
+} from "@grayhaven/nerve"
+
+type Def = ReturnType<
+  | typeof connectorFn
+  | typeof wireFn
+  | typeof branchFn
+  | typeof labelFn
+  | typeof spliceFn
+  | typeof cableFn
+>
+
+export type Children = Def | ReadonlyArray<Children> | undefined | null | false
+
+export const flatten = (children: Children): Array<Def> => {
+  if (children === undefined || children === null || children === false) return []
+  if (Array.isArray(children)) return (children as ReadonlyArray<Children>).flatMap(flatten)
+  return [children as Def]
+}
+
+/** "J1.3" -> pin ref; anything without a dot is a splice id. */
+const endpoint = (s: string) => {
+  const dot = s.lastIndexOf(".")
+  if (dot === -1) return { kind: "splice-ref" as const, splice: s }
+  return { kind: "pin-ref" as const, connector: s.slice(0, dot), pin: s.slice(dot + 1) }
+}
+
+export function Connector(props: {
+  ref: string
+  part: ConnectorPart
+  pins: PinAssignments
+  terminals?: PinPartAssignment
+  seals?: PinPartAssignment
+}) {
+  const { ref, part, ...rest } = props
+  return connectorFn(ref, part, rest)
+}
+
+export function Wire(props: { id: string; from: string; to: string } & WireProps) {
+  const { id, from, to, ...rest } = props
+  return wireFn(id, endpoint(from), endpoint(to), rest)
+}
+
+export function Splice(props: { id: string } & SpliceProps) {
+  const { id, ...rest } = props
+  return spliceFn(id, rest)
+}
+
+export function Cable(props: { id: string } & CableProps) {
+  const { id, ...rest } = props
+  return cableFn(id, rest)
+}
+
+export function Branch(props: { id: string } & Omit<BranchProps, "path"> & { path: ReadonlyArray<string> }) {
+  const { id, ...rest } = props
+  return branchFn(id, rest)
+}
+
+export function Label(props: { id: string } & LabelProps) {
+  const { id, ...rest } = props
+  return labelFn(id, rest)
+}
+
+export function Harness(props: {
+  id: string
+  revision: string
+  units: "mm" | "in"
+  children?: Children
+}): HarnessDesign {
+  const kids = flatten(props.children)
+  const byKind = (kind: Def["kind"]) => kids.filter((k) => k.kind === kind)
+  return harnessFn(props.id, {
+    revision: props.revision,
+    units: props.units,
+    connectors: byKind("connector") as never,
+    wires: byKind("wire") as never,
+    splices: byKind("splice") as never,
+    cables: byKind("cable") as never,
+    branches: byKind("branch") as never,
+    labels: byKind("label") as never
+  })
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export { Branch, Cable, Connector, Harness, Label, Splice, Wire } from "./components.js"
+export type { Children } from "./components.js"
+export { Fragment, jsx, jsxs } from "./jsx-runtime.js"

package/src/jsx-runtime.ts

@@ -0,0 +1,32 @@
+/**
+ * Custom JSX runtime (automatic mode): no React, no fiber, no VDOM —
+ * `jsx(Component, props)` simply CALLS the component. JSX becomes pure
+ * function application over the typed DSL, so authoring style changes
+ * and nothing else does.
+ */
+export type JsxComponent<P, R> = (props: P) => R
+
+export const jsx = <P, R>(type: JsxComponent<P, R>, props: P): R => type(props)
+export const jsxs = jsx
+export const jsxDEV = <P, R>(type: JsxComponent<P, R>, props: P): R => type(props)
+
+export const Fragment = (props: { children?: unknown }): unknown => props.children
+
+// Minimal JSX namespace: components only (no intrinsic lowercase elements —
+// <Harness> not <harness>, keeping every element a typed function).
+declare global {
+  namespace JSX {
+    // Element is intentionally loose (each component returns its own def
+    // type); ElementType constrains elements to component FUNCTIONS.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    type Element = any
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    type ElementType = (props: any) => unknown
+    interface ElementChildrenAttribute {
+      children: unknown
+    }
+    interface IntrinsicElements {
+      [k: string]: never
+    }
+  }
+}

package/test/jsx.test.tsx

@@ -0,0 +1,59 @@
+/** @jsxImportSource @grayhaven/nerve-react */
+/**
+ * The JSX layer is authoring sugar ONLY: the same harness written as JSX
+ * and as function calls must compile to byte-identical HIR.
+ */
+import { describe, expect, it } from "vitest"
+import { compileDesign } from "@grayhaven/nerve"
+import { Branch, Connector, Harness, Label, Wire } from "@grayhaven/nerve-react"
+import functionStyle from "../../../examples/motor-controller/src/main.harness.js"
+import { MolexMicroFit } from "@grayhaven/nerve-connectors"
+
+const PINS = {
+  1: "VBAT_24V", 2: "GND", 3: "CAN_H", 4: "CAN_L",
+  5: "ENC_A", 6: "ENC_B", 7: "MOTOR_TEMP", 8: "SHIELD_DRAIN"
+} as const
+
+const jsxStyle = (
+  <Harness id="motor-controller-harness" revision="A" units="mm">
+    <Connector ref="J1" part={MolexMicroFit["43025-0800"]} pins={PINS} />
+    <Connector ref="M1" part={MolexMicroFit["43020-0800"]} pins={PINS} />
+    <Wire id="W1" from="J1.1" to="M1.1" gauge="20AWG" color="red" length={420} signal="VBAT_24V" />
+    <Wire id="W2" from="J1.2" to="M1.2" gauge="20AWG" color="black" length={420} signal="GND" />
+    <Wire id="W3" from="J1.3" to="M1.3" gauge="24AWG" color="white" twistGroup="CAN_PAIR" signal="CAN_H" />
+    <Wire id="W4" from="J1.4" to="M1.4" gauge="24AWG" color="blue" twistGroup="CAN_PAIR" signal="CAN_L" />
+    <Branch id="main" path={["J1", "M1"]} sleeve="braided-pet" nominalLength={420} />
+    <Label id="L1" text="MOTOR CTRL A" attachTo="main" offsetFrom="J1" distance={50} />
+  </Harness>
+)
+
+describe("@grayhaven/nerve-react (experimental JSX authoring)", () => {
+  it("compiles JSX to byte-identical HIR vs the function DSL", () => {
+    const a = JSON.stringify(compileDesign(jsxStyle).hir, null, 2)
+    const b = JSON.stringify(compileDesign(functionStyle).hir, null, 2)
+    expect(a).toBe(b)
+  })
+
+  it("string endpoints parse pins and splices", () => {
+    const w = <Wire id="W9" from="J1.12" to="S1" gauge="24AWG" />
+    expect(w).toMatchObject({
+      from: { kind: "pin-ref", connector: "J1", pin: "12" },
+      to: { kind: "splice-ref", splice: "S1" }
+    })
+  })
+
+  it("nested arrays and conditionals flatten like JSX children should", () => {
+    const drops = ["A", "B"].map((s, i) => (
+      <Wire id={`W${i}`} from={`J1.${i + 1}`} to={`M1.${i + 1}`} signal={s} gauge="24AWG" />
+    ))
+    const h = (
+      <Harness id="t" revision="A" units="mm">
+        <Connector ref="J1" part={MolexMicroFit["43025-0800"]} pins={{ 1: "A", 2: "B" }} />
+        <Connector ref="M1" part={MolexMicroFit["43020-0800"]} pins={{ 1: "A", 2: "B" }} />
+        {drops}
+        {false}
+      </Harness>
+    )
+    expect(compileDesign(h).hir.wires).toHaveLength(2)
+  })
+})

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "jsx": "react-jsx",
+    "jsxImportSource": "@grayhaven/nerve-react"
+  },
+  "include": [
+    "src",
+    "test"
+  ]
+}