@grayhaven/nerve 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1149 @@
+import * as effect_Effect from 'effect/Effect';
+import * as effect_ParseResult from 'effect/ParseResult';
+import * as effect_SchemaAST from 'effect/SchemaAST';
+import { Schema } from 'effect';
+
+/**
+ * Core domain model for Grayhaven Nerve.
+ *
+ * These are the user-facing design types produced by the DSL builders.
+ * The compiler normalizes a `HarnessDesign` into the HIR (see ./hir/schema.ts),
+ * which is what renderers, validators, and exporters consume.
+ */
+type Units = "mm" | "in";
+type ConnectorGender = "plug" | "receptacle" | "hermaphroditic";
+/**
+ * Component master data for a connector housing (PRD §9.2, §30).
+ * Instances reference a part; parts live in libraries such as
+ * `@grayhaven/nerve-connectors`.
+ */
+interface ConnectorPart {
+    readonly mpn: string;
+    readonly manufacturer?: string;
+    readonly family?: string;
+    readonly description?: string;
+    readonly gender?: ConnectorGender;
+    readonly pinCount: number;
+    readonly pinNumbering?: string;
+    readonly cavityLayout?: {
+        readonly rows: number;
+        readonly columns: number;
+    };
+    readonly matingMpn?: string;
+    readonly compatibleTerminals?: ReadonlyArray<string>;
+    readonly compatibleSeals?: ReadonlyArray<string>;
+    readonly wireGaugeRange?: {
+        readonly min: string;
+        readonly max: string;
+    };
+}
+/** A reference to a specific pin/cavity on a connector instance. */
+interface PinRef {
+    readonly kind: "pin-ref";
+    readonly connector: string;
+    readonly pin: string;
+}
+/** A reference to a splice node. */
+interface SpliceRef {
+    readonly kind: "splice-ref";
+    readonly splice: string;
+}
+/** Where a wire terminates: a connector pin or a splice. */
+type WireEndpoint = PinRef | SpliceRef;
+/** Map of pin number/name to assigned signal name. */
+type PinAssignments = Readonly<Record<string | number, string>>;
+/** A connector instance placed in a harness, e.g. `connector("J1", part, {...})`. */
+interface ConnectorInstance {
+    readonly kind: "connector";
+    readonly ref: string;
+    readonly part: ConnectorPart;
+    readonly pins: Readonly<Record<string, string>>;
+    /** Build a `PinRef` for a pin on this connector. */
+    pin(pin: string | number): PinRef;
+}
+interface WireProps {
+    readonly gauge?: string;
+    readonly color?: string;
+    readonly stripe?: string;
+    readonly length?: number;
+    readonly lengthTolerance?: number;
+    readonly signal?: string;
+    readonly insulation?: string;
+    readonly voltageRating?: number;
+    readonly temperatureRating?: number;
+    readonly currentEstimate?: number;
+    readonly twistGroup?: string;
+    readonly shieldGroup?: string;
+    /** Cable this wire is a conductor of (see `cable()`). */
+    readonly cable?: string;
+    /** Conductor number/name within the cable. */
+    readonly conductor?: string | number;
+    readonly notes?: string;
+}
+interface WireDef extends WireProps {
+    readonly kind: "wire";
+    readonly id: string;
+    readonly from: WireEndpoint;
+    readonly to: WireEndpoint;
+}
+interface SpliceProps {
+    /** crimp, solder-sleeve, ultrasonic-weld, ... */
+    readonly type?: string;
+    /** Crimp or solder-sleeve part number. */
+    readonly part?: string;
+    /** Branch the splice sits on. */
+    readonly branch?: string;
+    /** Distance along the branch from its start, in harness units. */
+    readonly location?: number;
+    /** Seal / heat-shrink / inspection notes (PRD §9.2). */
+    readonly notes?: string;
+}
+interface SpliceDef extends SpliceProps {
+    readonly kind: "splice";
+    readonly id: string;
+}
+interface CableProps {
+    /** Catalog type, e.g. "2x24AWG twisted shielded". */
+    readonly type?: string;
+    readonly conductors?: number;
+    readonly shield?: string;
+    readonly jacket?: string;
+    readonly outerDiameter?: number;
+    readonly notes?: string;
+}
+interface CableDef extends CableProps {
+    readonly kind: "cable";
+    readonly id: string;
+}
+interface BranchProps {
+    readonly path: ReadonlyArray<ConnectorInstance | string>;
+    readonly parent?: string;
+    readonly sleeve?: string;
+    readonly nominalLength?: number;
+    readonly breakoutDistance?: number;
+}
+interface BranchDef {
+    readonly kind: "branch";
+    readonly id: string;
+    readonly path: ReadonlyArray<string>;
+    readonly parent?: string;
+    readonly sleeve?: string;
+    readonly nominalLength?: number;
+    readonly breakoutDistance?: number;
+}
+interface LabelProps {
+    readonly text: string;
+    readonly attachTo: ConnectorInstance | string;
+    readonly offsetFrom?: ConnectorInstance | string;
+    readonly distance?: number;
+    readonly material?: string;
+    readonly quantity?: number;
+}
+interface LabelDef {
+    readonly kind: "label";
+    readonly id: string;
+    readonly text: string;
+    readonly attachTo: string;
+    readonly offsetFrom?: string;
+    readonly distance?: number;
+    readonly material?: string;
+    readonly quantity?: number;
+}
+interface HarnessProps {
+    readonly revision: string;
+    readonly units: Units;
+    readonly metadata?: Readonly<Record<string, string>>;
+    readonly connectors: ReadonlyArray<ConnectorInstance>;
+    readonly wires: ReadonlyArray<WireDef>;
+    readonly branches?: ReadonlyArray<BranchDef>;
+    readonly labels?: ReadonlyArray<LabelDef>;
+    readonly splices?: ReadonlyArray<SpliceDef>;
+    readonly cables?: ReadonlyArray<CableDef>;
+}
+/** The root design object returned by `harness(...)` — the unit of compilation. */
+interface HarnessDesign {
+    readonly kind: "harness";
+    readonly id: string;
+    readonly revision: string;
+    readonly units: Units;
+    readonly metadata: Readonly<Record<string, string>>;
+    readonly connectors: ReadonlyArray<ConnectorInstance>;
+    readonly wires: ReadonlyArray<WireDef>;
+    readonly branches: ReadonlyArray<BranchDef>;
+    readonly labels: ReadonlyArray<LabelDef>;
+    readonly splices: ReadonlyArray<SpliceDef>;
+    readonly cables: ReadonlyArray<CableDef>;
+}
+
+/**
+ * TypeScript authoring DSL (PRD §9.1).
+ *
+ * Builders are cheap and permissive: they capture intent as plain data.
+ * Correctness lives in the compiler/validator, which reports precise
+ * diagnostics instead of throwing mid-definition.
+ */
+
+/** Place a connector in the harness: `connector("J1", MolexMicroFit["43025-0800"], { pins: {...} })`. */
+declare const connector: (ref: string, part: ConnectorPart, opts: {
+    readonly pins: PinAssignments;
+}) => ConnectorInstance;
+/** Anything a wire can terminate on: a pin ref, a splice (def or ref). */
+type EndpointInput = PinRef | SpliceDef | {
+    kind: "splice-ref";
+    splice: string;
+};
+/**
+ * Define a wire between two endpoints:
+ * `wire("W1", j1.pin(1), m1.pin(1), { gauge: "18AWG", ... })` or
+ * `wire("W5", j1.pin(2), s1, {...})` where `s1` is a splice.
+ */
+declare const wire: (id: string, from: EndpointInput, to: EndpointInput, props?: WireProps) => WireDef;
+/** Define a splice node: `splice("S1", { type: "crimp", branch: "main", location: 120 })`. */
+declare const splice: (id: string, props?: SpliceProps) => SpliceDef;
+/** Define a multi-conductor cable that wires can belong to via `cable`/`conductor` props. */
+declare const cable: (id: string, props?: CableProps) => CableDef;
+/** Define a physical branch through the harness: `branch("main", { path: [j1, m1], ... })`. */
+declare const branch: (id: string, props: BranchProps) => BranchDef;
+/** Define a label: `label("L1", { text: "MOTOR CTRL A", attachTo: "main", ... })`. */
+declare const label: (id: string, props: LabelProps) => LabelDef;
+/** Define a harness — the root design object and default export of a `.harness.ts` file. */
+declare const harness: (id: string, props: HarnessProps) => HarnessDesign;
+
+/**
+ * Diagnostics primitives (PRD §11.2).
+ *
+ * Every diagnostic carries a stable code so CI gates, docs, and suppression
+ * config can rely on it across releases.
+ */
+declare const DiagnosticSeverity: {
+    readonly Error: "error";
+    readonly Warning: "warning";
+    readonly Info: "info";
+};
+type DiagnosticSeverity = (typeof DiagnosticSeverity)[keyof typeof DiagnosticSeverity];
+interface Diagnostic {
+    /** Stable code, e.g. `HK-WIRE-001`. */
+    readonly code: string;
+    readonly severity: DiagnosticSeverity;
+    readonly message: string;
+    /** Stable HIR object reference, e.g. `wire:W12` or `connector:J1.pin:3`. */
+    readonly target?: string | undefined;
+}
+/** Structural diagnostic codes emitted by the core compiler. */
+declare const Codes: {
+    readonly DuplicateConnectorRef: "HK-CONN-001";
+    readonly UndefinedConnectorRef: "HK-CONN-002";
+    readonly UndefinedPinRef: "HK-CONN-003";
+    readonly DuplicateWireId: "HK-WIRE-001";
+    readonly WireEndpointsIdentical: "HK-WIRE-002";
+    readonly DuplicateBranchId: "HK-BRANCH-001";
+    readonly BranchUndefinedEndpoint: "HK-BRANCH-002";
+    readonly DuplicateLabelId: "HK-LABEL-001";
+    readonly LabelUndefinedTarget: "HK-LABEL-002";
+    readonly DuplicateSpliceId: "HK-SPLICE-001";
+    readonly UndefinedSpliceRef: "HK-SPLICE-002";
+    readonly SpliceTooFewWires: "HK-SPLICE-003";
+    readonly SpliceUndefinedBranch: "HK-SPLICE-004";
+    readonly DuplicateCableId: "HK-CABLE-001";
+    readonly UndefinedCableRef: "HK-CABLE-002";
+};
+declare const hasErrors: (diagnostics: ReadonlyArray<Diagnostic>) => boolean;
+
+declare const HIR_SCHEMA_VERSION: "0.1.0";
+declare const Hir: Schema.Struct<{
+    schemaVersion: Schema.Literal<["0.1.0"]>;
+    harness: Schema.Struct<{
+        id: typeof Schema.String;
+        revision: typeof Schema.String;
+        units: Schema.Literal<["mm", "in"]>;
+        metadata: Schema.Record$<typeof Schema.String, typeof Schema.String>;
+    }>;
+    connectors: Schema.Array$<Schema.Struct<{
+        ref: typeof Schema.String;
+        mpn: typeof Schema.String;
+        manufacturer: Schema.optional<typeof Schema.String>;
+        family: Schema.optional<typeof Schema.String>;
+        description: Schema.optional<typeof Schema.String>;
+        gender: Schema.optional<Schema.Literal<["plug", "receptacle", "hermaphroditic"]>>;
+        pinCount: typeof Schema.Number;
+        wireGaugeRange: Schema.optional<Schema.Struct<{
+            min: typeof Schema.String;
+            max: typeof Schema.String;
+        }>>;
+        pins: Schema.Array$<Schema.Struct<{
+            pin: typeof Schema.String;
+            signal: Schema.optional<typeof Schema.String>;
+        }>>;
+    }>>;
+    wires: Schema.Array$<Schema.Struct<{
+        id: typeof Schema.String;
+        from: Schema.Union<[Schema.Struct<{
+            connector: typeof Schema.String;
+            pin: typeof Schema.String;
+        }>, Schema.Struct<{
+            splice: typeof Schema.String;
+        }>]>;
+        to: Schema.Union<[Schema.Struct<{
+            connector: typeof Schema.String;
+            pin: typeof Schema.String;
+        }>, Schema.Struct<{
+            splice: typeof Schema.String;
+        }>]>;
+        gauge: Schema.optional<typeof Schema.String>;
+        color: Schema.optional<typeof Schema.String>;
+        stripe: Schema.optional<typeof Schema.String>;
+        length: Schema.optional<typeof Schema.Number>;
+        lengthTolerance: Schema.optional<typeof Schema.Number>;
+        signal: Schema.optional<typeof Schema.String>;
+        insulation: Schema.optional<typeof Schema.String>;
+        voltageRating: Schema.optional<typeof Schema.Number>;
+        temperatureRating: Schema.optional<typeof Schema.Number>;
+        currentEstimate: Schema.optional<typeof Schema.Number>;
+        twistGroup: Schema.optional<typeof Schema.String>;
+        shieldGroup: Schema.optional<typeof Schema.String>;
+        cable: Schema.optional<typeof Schema.String>;
+        conductor: Schema.optional<typeof Schema.String>;
+        branch: Schema.optional<typeof Schema.String>;
+        notes: Schema.optional<typeof Schema.String>;
+    }>>;
+    cables: Schema.Array$<Schema.Struct<{
+        id: typeof Schema.String;
+        type: Schema.optional<typeof Schema.String>;
+        conductors: Schema.optional<typeof Schema.Number>;
+        shield: Schema.optional<typeof Schema.String>;
+        jacket: Schema.optional<typeof Schema.String>;
+        outerDiameter: Schema.optional<typeof Schema.Number>;
+        /** Longest member wire — the cable cut length (computed). */
+        cutLength: Schema.optional<typeof Schema.Number>;
+        notes: Schema.optional<typeof Schema.String>;
+        /** Member wire IDs (computed by the compiler). */
+        wires: Schema.Array$<typeof Schema.String>;
+    }>>;
+    branches: Schema.Array$<Schema.Struct<{
+        id: typeof Schema.String;
+        path: Schema.Array$<typeof Schema.String>;
+        parent: Schema.optional<typeof Schema.String>;
+        sleeve: Schema.optional<typeof Schema.String>;
+        nominalLength: Schema.optional<typeof Schema.Number>;
+        breakoutDistance: Schema.optional<typeof Schema.Number>;
+    }>>;
+    splices: Schema.Array$<Schema.Struct<{
+        id: typeof Schema.String;
+        type: Schema.optional<typeof Schema.String>;
+        part: Schema.optional<typeof Schema.String>;
+        branch: Schema.optional<typeof Schema.String>;
+        location: Schema.optional<typeof Schema.Number>;
+        notes: Schema.optional<typeof Schema.String>;
+        /** Wire IDs attached to this splice (computed by the compiler). */
+        wires: Schema.Array$<typeof Schema.String>;
+    }>>;
+    labels: Schema.Array$<Schema.Struct<{
+        id: typeof Schema.String;
+        text: typeof Schema.String;
+        attachTo: typeof Schema.String;
+        offsetFrom: Schema.optional<typeof Schema.String>;
+        distance: Schema.optional<typeof Schema.Number>;
+        material: Schema.optional<typeof Schema.String>;
+        quantity: Schema.optional<typeof Schema.Number>;
+    }>>;
+    bom: Schema.Array$<Schema.Struct<{
+        internalPartId: Schema.optional<typeof Schema.String>;
+        mpn: typeof Schema.String;
+        manufacturer: Schema.optional<typeof Schema.String>;
+        description: Schema.optional<typeof Schema.String>;
+        category: Schema.optional<typeof Schema.String>;
+        quantity: typeof Schema.Number;
+        unitOfMeasure: typeof Schema.String;
+        usedBy: Schema.Array$<typeof Schema.String>;
+        notes: Schema.optional<typeof Schema.String>;
+    }>>;
+    diagnostics: Schema.Array$<Schema.Struct<{
+        code: typeof Schema.String;
+        severity: Schema.Literal<["error", "warning", "info"]>;
+        message: typeof Schema.String;
+        target: Schema.optional<typeof Schema.String>;
+    }>>;
+    layoutHints: Schema.Array$<typeof Schema.Unknown>;
+    exports: Schema.Record$<typeof Schema.String, typeof Schema.Unknown>;
+}>;
+type Hir = Schema.Schema.Type<typeof Hir>;
+declare const HirConnector: Schema.Struct<{
+    ref: typeof Schema.String;
+    mpn: typeof Schema.String;
+    manufacturer: Schema.optional<typeof Schema.String>;
+    family: Schema.optional<typeof Schema.String>;
+    description: Schema.optional<typeof Schema.String>;
+    gender: Schema.optional<Schema.Literal<["plug", "receptacle", "hermaphroditic"]>>;
+    pinCount: typeof Schema.Number;
+    wireGaugeRange: Schema.optional<Schema.Struct<{
+        min: typeof Schema.String;
+        max: typeof Schema.String;
+    }>>;
+    pins: Schema.Array$<Schema.Struct<{
+        pin: typeof Schema.String;
+        signal: Schema.optional<typeof Schema.String>;
+    }>>;
+}>;
+type HirConnector = Schema.Schema.Type<typeof HirConnector>;
+declare const HirWire: Schema.Struct<{
+    id: typeof Schema.String;
+    from: Schema.Union<[Schema.Struct<{
+        connector: typeof Schema.String;
+        pin: typeof Schema.String;
+    }>, Schema.Struct<{
+        splice: typeof Schema.String;
+    }>]>;
+    to: Schema.Union<[Schema.Struct<{
+        connector: typeof Schema.String;
+        pin: typeof Schema.String;
+    }>, Schema.Struct<{
+        splice: typeof Schema.String;
+    }>]>;
+    gauge: Schema.optional<typeof Schema.String>;
+    color: Schema.optional<typeof Schema.String>;
+    stripe: Schema.optional<typeof Schema.String>;
+    length: Schema.optional<typeof Schema.Number>;
+    lengthTolerance: Schema.optional<typeof Schema.Number>;
+    signal: Schema.optional<typeof Schema.String>;
+    insulation: Schema.optional<typeof Schema.String>;
+    voltageRating: Schema.optional<typeof Schema.Number>;
+    temperatureRating: Schema.optional<typeof Schema.Number>;
+    currentEstimate: Schema.optional<typeof Schema.Number>;
+    twistGroup: Schema.optional<typeof Schema.String>;
+    shieldGroup: Schema.optional<typeof Schema.String>;
+    cable: Schema.optional<typeof Schema.String>;
+    conductor: Schema.optional<typeof Schema.String>;
+    branch: Schema.optional<typeof Schema.String>;
+    notes: Schema.optional<typeof Schema.String>;
+}>;
+type HirWire = Schema.Schema.Type<typeof HirWire>;
+declare const HirBranch: Schema.Struct<{
+    id: typeof Schema.String;
+    path: Schema.Array$<typeof Schema.String>;
+    parent: Schema.optional<typeof Schema.String>;
+    sleeve: Schema.optional<typeof Schema.String>;
+    nominalLength: Schema.optional<typeof Schema.Number>;
+    breakoutDistance: Schema.optional<typeof Schema.Number>;
+}>;
+type HirBranch = Schema.Schema.Type<typeof HirBranch>;
+declare const HirLabel: Schema.Struct<{
+    id: typeof Schema.String;
+    text: typeof Schema.String;
+    attachTo: typeof Schema.String;
+    offsetFrom: Schema.optional<typeof Schema.String>;
+    distance: Schema.optional<typeof Schema.Number>;
+    material: Schema.optional<typeof Schema.String>;
+    quantity: Schema.optional<typeof Schema.Number>;
+}>;
+type HirLabel = Schema.Schema.Type<typeof HirLabel>;
+declare const HirBomItem: Schema.Struct<{
+    internalPartId: Schema.optional<typeof Schema.String>;
+    mpn: typeof Schema.String;
+    manufacturer: Schema.optional<typeof Schema.String>;
+    description: Schema.optional<typeof Schema.String>;
+    category: Schema.optional<typeof Schema.String>;
+    quantity: typeof Schema.Number;
+    unitOfMeasure: typeof Schema.String;
+    usedBy: Schema.Array$<typeof Schema.String>;
+    notes: Schema.optional<typeof Schema.String>;
+}>;
+type HirBomItem = Schema.Schema.Type<typeof HirBomItem>;
+declare const HirPinRef: Schema.Struct<{
+    connector: typeof Schema.String;
+    pin: typeof Schema.String;
+}>;
+type HirPinRef = Schema.Schema.Type<typeof HirPinRef>;
+declare const HirSpliceRef: Schema.Struct<{
+    splice: typeof Schema.String;
+}>;
+type HirSpliceRef = Schema.Schema.Type<typeof HirSpliceRef>;
+/** A wire endpoint: a connector pin or a splice node. */
+declare const HirEndpoint: Schema.Union<[Schema.Struct<{
+    connector: typeof Schema.String;
+    pin: typeof Schema.String;
+}>, Schema.Struct<{
+    splice: typeof Schema.String;
+}>]>;
+type HirEndpoint = Schema.Schema.Type<typeof HirEndpoint>;
+declare const HirSplice: Schema.Struct<{
+    id: typeof Schema.String;
+    type: Schema.optional<typeof Schema.String>;
+    part: Schema.optional<typeof Schema.String>;
+    branch: Schema.optional<typeof Schema.String>;
+    location: Schema.optional<typeof Schema.Number>;
+    notes: Schema.optional<typeof Schema.String>;
+    /** Wire IDs attached to this splice (computed by the compiler). */
+    wires: Schema.Array$<typeof Schema.String>;
+}>;
+type HirSplice = Schema.Schema.Type<typeof HirSplice>;
+declare const HirCable: Schema.Struct<{
+    id: typeof Schema.String;
+    type: Schema.optional<typeof Schema.String>;
+    conductors: Schema.optional<typeof Schema.Number>;
+    shield: Schema.optional<typeof Schema.String>;
+    jacket: Schema.optional<typeof Schema.String>;
+    outerDiameter: Schema.optional<typeof Schema.Number>;
+    /** Longest member wire — the cable cut length (computed). */
+    cutLength: Schema.optional<typeof Schema.Number>;
+    notes: Schema.optional<typeof Schema.String>;
+    /** Member wire IDs (computed by the compiler). */
+    wires: Schema.Array$<typeof Schema.String>;
+}>;
+type HirCable = Schema.Schema.Type<typeof HirCable>;
+/** Narrow an endpoint to a pin ref. */
+declare const isPinEndpoint: (e: HirEndpoint) => e is HirPinRef;
+/** Stable display form: `J1.1` or `S1`. */
+declare const endpointLabel: (e: HirEndpoint) => string;
+/** Decode an untrusted value (e.g. a cached `harness.json`) into HIR. Throws `ParseError`. */
+declare const decodeHir: (u: unknown, overrideOptions?: effect_SchemaAST.ParseOptions) => {
+    readonly harness: {
+        readonly id: string;
+        readonly revision: string;
+        readonly units: "mm" | "in";
+        readonly metadata: {
+            readonly [x: string]: string;
+        };
+    };
+    readonly wires: readonly {
+        readonly id: string;
+        readonly from: {
+            readonly connector: string;
+            readonly pin: string;
+        } | {
+            readonly splice: string;
+        };
+        readonly to: {
+            readonly connector: string;
+            readonly pin: string;
+        } | {
+            readonly splice: string;
+        };
+        readonly cable?: string | undefined;
+        readonly branch?: string | undefined;
+        readonly signal?: string | undefined;
+        readonly length?: number | undefined;
+        readonly gauge?: string | undefined;
+        readonly color?: string | undefined;
+        readonly stripe?: string | undefined;
+        readonly lengthTolerance?: number | undefined;
+        readonly insulation?: string | undefined;
+        readonly voltageRating?: number | undefined;
+        readonly temperatureRating?: number | undefined;
+        readonly currentEstimate?: number | undefined;
+        readonly twistGroup?: string | undefined;
+        readonly shieldGroup?: string | undefined;
+        readonly conductor?: string | undefined;
+        readonly notes?: string | undefined;
+    }[];
+    readonly schemaVersion: "0.1.0";
+    readonly connectors: readonly {
+        readonly ref: string;
+        readonly mpn: string;
+        readonly manufacturer?: string | undefined;
+        readonly family?: string | undefined;
+        readonly description?: string | undefined;
+        readonly gender?: "plug" | "receptacle" | "hermaphroditic" | undefined;
+        readonly pinCount: number;
+        readonly wireGaugeRange?: {
+            readonly min: string;
+            readonly max: string;
+        } | undefined;
+        readonly pins: readonly {
+            readonly pin: string;
+            readonly signal?: string | undefined;
+        }[];
+    }[];
+    readonly cables: readonly {
+        readonly id: string;
+        readonly notes?: string | undefined;
+        readonly type?: string | undefined;
+        readonly wires: readonly string[];
+        readonly conductors?: number | undefined;
+        readonly shield?: string | undefined;
+        readonly jacket?: string | undefined;
+        readonly outerDiameter?: number | undefined;
+        readonly cutLength?: number | undefined;
+    }[];
+    readonly branches: readonly {
+        readonly id: string;
+        readonly path: readonly string[];
+        readonly parent?: string | undefined;
+        readonly sleeve?: string | undefined;
+        readonly nominalLength?: number | undefined;
+        readonly breakoutDistance?: number | undefined;
+    }[];
+    readonly splices: readonly {
+        readonly id: string;
+        readonly branch?: string | undefined;
+        readonly notes?: string | undefined;
+        readonly type?: string | undefined;
+        readonly part?: string | undefined;
+        readonly location?: number | undefined;
+        readonly wires: readonly string[];
+    }[];
+    readonly labels: readonly {
+        readonly id: string;
+        readonly attachTo: string;
+        readonly offsetFrom?: string | undefined;
+        readonly text: string;
+        readonly distance?: number | undefined;
+        readonly material?: string | undefined;
+        readonly quantity?: number | undefined;
+    }[];
+    readonly bom: readonly {
+        readonly quantity: number;
+        readonly mpn: string;
+        readonly manufacturer?: string | undefined;
+        readonly description?: string | undefined;
+        readonly notes?: string | undefined;
+        readonly internalPartId?: string | undefined;
+        readonly category?: string | undefined;
+        readonly unitOfMeasure: string;
+        readonly usedBy: readonly string[];
+    }[];
+    readonly diagnostics: readonly {
+        readonly code: string;
+        readonly severity: "error" | "warning" | "info";
+        readonly message: string;
+        readonly target?: string | undefined;
+    }[];
+    readonly layoutHints: readonly unknown[];
+    readonly exports: {
+        readonly [x: string]: unknown;
+    };
+};
+/** Decode as an Effect, for use inside services. */
+declare const decodeHirEffect: (u: unknown, overrideOptions?: effect_SchemaAST.ParseOptions) => effect_Effect.Effect<{
+    readonly harness: {
+        readonly id: string;
+        readonly revision: string;
+        readonly units: "mm" | "in";
+        readonly metadata: {
+            readonly [x: string]: string;
+        };
+    };
+    readonly wires: readonly {
+        readonly id: string;
+        readonly from: {
+            readonly connector: string;
+            readonly pin: string;
+        } | {
+            readonly splice: string;
+        };
+        readonly to: {
+            readonly connector: string;
+            readonly pin: string;
+        } | {
+            readonly splice: string;
+        };
+        readonly cable?: string | undefined;
+        readonly branch?: string | undefined;
+        readonly signal?: string | undefined;
+        readonly length?: number | undefined;
+        readonly gauge?: string | undefined;
+        readonly color?: string | undefined;
+        readonly stripe?: string | undefined;
+        readonly lengthTolerance?: number | undefined;
+        readonly insulation?: string | undefined;
+        readonly voltageRating?: number | undefined;
+        readonly temperatureRating?: number | undefined;
+        readonly currentEstimate?: number | undefined;
+        readonly twistGroup?: string | undefined;
+        readonly shieldGroup?: string | undefined;
+        readonly conductor?: string | undefined;
+        readonly notes?: string | undefined;
+    }[];
+    readonly schemaVersion: "0.1.0";
+    readonly connectors: readonly {
+        readonly ref: string;
+        readonly mpn: string;
+        readonly manufacturer?: string | undefined;
+        readonly family?: string | undefined;
+        readonly description?: string | undefined;
+        readonly gender?: "plug" | "receptacle" | "hermaphroditic" | undefined;
+        readonly pinCount: number;
+        readonly wireGaugeRange?: {
+            readonly min: string;
+            readonly max: string;
+        } | undefined;
+        readonly pins: readonly {
+            readonly pin: string;
+            readonly signal?: string | undefined;
+        }[];
+    }[];
+    readonly cables: readonly {
+        readonly id: string;
+        readonly notes?: string | undefined;
+        readonly type?: string | undefined;
+        readonly wires: readonly string[];
+        readonly conductors?: number | undefined;
+        readonly shield?: string | undefined;
+        readonly jacket?: string | undefined;
+        readonly outerDiameter?: number | undefined;
+        readonly cutLength?: number | undefined;
+    }[];
+    readonly branches: readonly {
+        readonly id: string;
+        readonly path: readonly string[];
+        readonly parent?: string | undefined;
+        readonly sleeve?: string | undefined;
+        readonly nominalLength?: number | undefined;
+        readonly breakoutDistance?: number | undefined;
+    }[];
+    readonly splices: readonly {
+        readonly id: string;
+        readonly branch?: string | undefined;
+        readonly notes?: string | undefined;
+        readonly type?: string | undefined;
+        readonly part?: string | undefined;
+        readonly location?: number | undefined;
+        readonly wires: readonly string[];
+    }[];
+    readonly labels: readonly {
+        readonly id: string;
+        readonly attachTo: string;
+        readonly offsetFrom?: string | undefined;
+        readonly text: string;
+        readonly distance?: number | undefined;
+        readonly material?: string | undefined;
+        readonly quantity?: number | undefined;
+    }[];
+    readonly bom: readonly {
+        readonly quantity: number;
+        readonly mpn: string;
+        readonly manufacturer?: string | undefined;
+        readonly description?: string | undefined;
+        readonly notes?: string | undefined;
+        readonly internalPartId?: string | undefined;
+        readonly category?: string | undefined;
+        readonly unitOfMeasure: string;
+        readonly usedBy: readonly string[];
+    }[];
+    readonly diagnostics: readonly {
+        readonly code: string;
+        readonly severity: "error" | "warning" | "info";
+        readonly message: string;
+        readonly target?: string | undefined;
+    }[];
+    readonly layoutHints: readonly unknown[];
+    readonly exports: {
+        readonly [x: string]: unknown;
+    };
+}, effect_ParseResult.ParseError, never>;
+/** Encode HIR back to its JSON-ready form. */
+declare const encodeHir: (a: {
+    readonly harness: {
+        readonly id: string;
+        readonly revision: string;
+        readonly units: "mm" | "in";
+        readonly metadata: {
+            readonly [x: string]: string;
+        };
+    };
+    readonly wires: readonly {
+        readonly id: string;
+        readonly from: {
+            readonly connector: string;
+            readonly pin: string;
+        } | {
+            readonly splice: string;
+        };
+        readonly to: {
+            readonly connector: string;
+            readonly pin: string;
+        } | {
+            readonly splice: string;
+        };
+        readonly cable?: string | undefined;
+        readonly branch?: string | undefined;
+        readonly signal?: string | undefined;
+        readonly length?: number | undefined;
+        readonly gauge?: string | undefined;
+        readonly color?: string | undefined;
+        readonly stripe?: string | undefined;
+        readonly lengthTolerance?: number | undefined;
+        readonly insulation?: string | undefined;
+        readonly voltageRating?: number | undefined;
+        readonly temperatureRating?: number | undefined;
+        readonly currentEstimate?: number | undefined;
+        readonly twistGroup?: string | undefined;
+        readonly shieldGroup?: string | undefined;
+        readonly conductor?: string | undefined;
+        readonly notes?: string | undefined;
+    }[];
+    readonly schemaVersion: "0.1.0";
+    readonly connectors: readonly {
+        readonly ref: string;
+        readonly mpn: string;
+        readonly manufacturer?: string | undefined;
+        readonly family?: string | undefined;
+        readonly description?: string | undefined;
+        readonly gender?: "plug" | "receptacle" | "hermaphroditic" | undefined;
+        readonly pinCount: number;
+        readonly wireGaugeRange?: {
+            readonly min: string;
+            readonly max: string;
+        } | undefined;
+        readonly pins: readonly {
+            readonly pin: string;
+            readonly signal?: string | undefined;
+        }[];
+    }[];
+    readonly cables: readonly {
+        readonly id: string;
+        readonly notes?: string | undefined;
+        readonly type?: string | undefined;
+        readonly wires: readonly string[];
+        readonly conductors?: number | undefined;
+        readonly shield?: string | undefined;
+        readonly jacket?: string | undefined;
+        readonly outerDiameter?: number | undefined;
+        readonly cutLength?: number | undefined;
+    }[];
+    readonly branches: readonly {
+        readonly id: string;
+        readonly path: readonly string[];
+        readonly parent?: string | undefined;
+        readonly sleeve?: string | undefined;
+        readonly nominalLength?: number | undefined;
+        readonly breakoutDistance?: number | undefined;
+    }[];
+    readonly splices: readonly {
+        readonly id: string;
+        readonly branch?: string | undefined;
+        readonly notes?: string | undefined;
+        readonly type?: string | undefined;
+        readonly part?: string | undefined;
+        readonly location?: number | undefined;
+        readonly wires: readonly string[];
+    }[];
+    readonly labels: readonly {
+        readonly id: string;
+        readonly attachTo: string;
+        readonly offsetFrom?: string | undefined;
+        readonly text: string;
+        readonly distance?: number | undefined;
+        readonly material?: string | undefined;
+        readonly quantity?: number | undefined;
+    }[];
+    readonly bom: readonly {
+        readonly quantity: number;
+        readonly mpn: string;
+        readonly manufacturer?: string | undefined;
+        readonly description?: string | undefined;
+        readonly notes?: string | undefined;
+        readonly internalPartId?: string | undefined;
+        readonly category?: string | undefined;
+        readonly unitOfMeasure: string;
+        readonly usedBy: readonly string[];
+    }[];
+    readonly diagnostics: readonly {
+        readonly code: string;
+        readonly severity: "error" | "warning" | "info";
+        readonly message: string;
+        readonly target?: string | undefined;
+    }[];
+    readonly layoutHints: readonly unknown[];
+    readonly exports: {
+        readonly [x: string]: unknown;
+    };
+}, overrideOptions?: effect_SchemaAST.ParseOptions) => {
+    readonly harness: {
+        readonly id: string;
+        readonly revision: string;
+        readonly units: "mm" | "in";
+        readonly metadata: {
+            readonly [x: string]: string;
+        };
+    };
+    readonly wires: readonly {
+        readonly id: string;
+        readonly from: {
+            readonly connector: string;
+            readonly pin: string;
+        } | {
+            readonly splice: string;
+        };
+        readonly to: {
+            readonly connector: string;
+            readonly pin: string;
+        } | {
+            readonly splice: string;
+        };
+        readonly cable?: string | undefined;
+        readonly branch?: string | undefined;
+        readonly signal?: string | undefined;
+        readonly length?: number | undefined;
+        readonly gauge?: string | undefined;
+        readonly color?: string | undefined;
+        readonly stripe?: string | undefined;
+        readonly lengthTolerance?: number | undefined;
+        readonly insulation?: string | undefined;
+        readonly voltageRating?: number | undefined;
+        readonly temperatureRating?: number | undefined;
+        readonly currentEstimate?: number | undefined;
+        readonly twistGroup?: string | undefined;
+        readonly shieldGroup?: string | undefined;
+        readonly conductor?: string | undefined;
+        readonly notes?: string | undefined;
+    }[];
+    readonly schemaVersion: "0.1.0";
+    readonly connectors: readonly {
+        readonly ref: string;
+        readonly mpn: string;
+        readonly pinCount: number;
+        readonly pins: readonly {
+            readonly pin: string;
+            readonly signal?: string | undefined;
+        }[];
+        readonly manufacturer?: string | undefined;
+        readonly family?: string | undefined;
+        readonly description?: string | undefined;
+        readonly gender?: "plug" | "receptacle" | "hermaphroditic" | undefined;
+        readonly wireGaugeRange?: {
+            readonly min: string;
+            readonly max: string;
+        } | undefined;
+    }[];
+    readonly cables: readonly {
+        readonly id: string;
+        readonly wires: readonly string[];
+        readonly notes?: string | undefined;
+        readonly type?: string | undefined;
+        readonly conductors?: number | undefined;
+        readonly shield?: string | undefined;
+        readonly jacket?: string | undefined;
+        readonly outerDiameter?: number | undefined;
+        readonly cutLength?: number | undefined;
+    }[];
+    readonly branches: readonly {
+        readonly id: string;
+        readonly path: readonly string[];
+        readonly parent?: string | undefined;
+        readonly sleeve?: string | undefined;
+        readonly nominalLength?: number | undefined;
+        readonly breakoutDistance?: number | undefined;
+    }[];
+    readonly splices: readonly {
+        readonly id: string;
+        readonly wires: readonly string[];
+        readonly branch?: string | undefined;
+        readonly notes?: string | undefined;
+        readonly type?: string | undefined;
+        readonly part?: string | undefined;
+        readonly location?: number | undefined;
+    }[];
+    readonly labels: readonly {
+        readonly id: string;
+        readonly attachTo: string;
+        readonly text: string;
+        readonly offsetFrom?: string | undefined;
+        readonly distance?: number | undefined;
+        readonly material?: string | undefined;
+        readonly quantity?: number | undefined;
+    }[];
+    readonly bom: readonly {
+        readonly quantity: number;
+        readonly mpn: string;
+        readonly unitOfMeasure: string;
+        readonly usedBy: readonly string[];
+        readonly manufacturer?: string | undefined;
+        readonly description?: string | undefined;
+        readonly notes?: string | undefined;
+        readonly internalPartId?: string | undefined;
+        readonly category?: string | undefined;
+    }[];
+    readonly diagnostics: readonly {
+        readonly code: string;
+        readonly severity: "error" | "warning" | "info";
+        readonly message: string;
+        readonly target?: string | undefined;
+    }[];
+    readonly layoutHints: readonly unknown[];
+    readonly exports: {
+        readonly [x: string]: unknown;
+    };
+};
+/** Stable object references (PRD §19), e.g. `connector:J1.pin:1`. */
+declare const refs: {
+    readonly connector: (ref: string) => string;
+    readonly pin: (connector: string, pin: string) => string;
+    readonly wire: (id: string) => string;
+    readonly branch: (id: string) => string;
+    readonly splice: (id: string) => string;
+    readonly label: (id: string) => string;
+    readonly bom: (mpn: string) => string;
+};
+
+/**
+ * Design → HIR normalization (PRD §9.3).
+ *
+ * `compileDesign` is a pure, deterministic function: given the same
+ * `HarnessDesign`, it produces a byte-identical HIR regardless of the order
+ * in which connectors, wires, branches, or labels were authored. All
+ * collections are canonically sorted and optional fields are omitted (never
+ * `undefined`) so serialized output is stable and diffable.
+ *
+ * Structural integrity checks run here because a broken object graph makes
+ * downstream rules meaningless. Domain rules (gauge vs current, twisted
+ * pairs, seals, ...) belong to `@grayhaven/nerve-rules`.
+ */
+
+interface CompileResult {
+    readonly hir: Hir;
+    readonly diagnostics: ReadonlyArray<Diagnostic>;
+}
+declare const compileDesign: (design: HarnessDesign) => CompileResult;
+
+/**
+ * Validation rule primitives (PRD §9.4).
+ *
+ * Rules are plain TypeScript functions that run against HIR — never against
+ * user source. Built-in rules live in `@grayhaven/nerve-rules`; users define
+ * custom rules with `rule()` and package them like any other TypeScript.
+ */
+
+interface RuleReport {
+    readonly severity: DiagnosticSeverity;
+    readonly message: string;
+    readonly target?: string;
+    /** Override the rule's stable code for this report. Rarely needed. */
+    readonly code?: string;
+}
+interface RuleContext {
+    readonly hir: Hir;
+    report(report: RuleReport): void;
+}
+interface Rule {
+    readonly name: string;
+    /** Stable diagnostic code attached to this rule's reports. */
+    readonly code: string;
+    run(ctx: RuleContext): void;
+}
+interface RuleOptions {
+    readonly code?: string;
+}
+/** Define a validation rule: `rule("require-can-pairs-twisted", (ctx) => {...})`. */
+declare const rule: (name: string, run: (ctx: RuleContext) => void, options?: RuleOptions) => Rule;
+/**
+ * Per-rule severity configuration (PRD §10.5 config example):
+ * `{ missingWireColor: "error", missingLabel: "warning", noisyRule: "off" }`.
+ */
+type RuleConfig = Readonly<Record<string, DiagnosticSeverity | "off">>;
+/**
+ * Run rules against HIR, producing canonically ordered diagnostics.
+ * Deterministic: output depends only on (hir, rules, config).
+ */
+declare const runRules: (hir: Hir, rules: ReadonlyArray<Rule>, config?: RuleConfig) => ReadonlyArray<Diagnostic>;
+
+/**
+ * Project configuration (PRD §10.5).
+ *
+ * Lives in `nerve.config.ts` at the project root:
+ *
+ * ```ts
+ * import { defineConfig } from "@grayhaven/nerve"
+ * export default defineConfig({
+ *   units: "mm",
+ *   outputDir: "dist",
+ *   rules: { missingWireColor: "error", missingWireLength: "warning" },
+ *   exports: { csv: true, svg: true }
+ * })
+ * ```
+ */
+
+interface NerveConfig {
+    readonly units?: Units;
+    readonly defaultWireTolerance?: number;
+    readonly outputDir?: string;
+    readonly rules?: RuleConfig;
+    readonly exports?: {
+        readonly csv?: boolean;
+        readonly svg?: boolean;
+        readonly pdf?: boolean;
+    };
+}
+declare const defineConfig: (config: NerveConfig) => NerveConfig;
+
+/**
+ * Harness variants (PRD §8.4).
+ *
+ * A variant derives a new `HarnessDesign` from a base by adding, removing,
+ * and overriding entities. The base is never mutated; shared definitions
+ * stay shared. Lineage is recorded in `metadata.variantOf` so exports and
+ * diffs can trace a variant back to its base. Validation applies to
+ * variants exactly as to any harness — they compile through the same
+ * pipeline.
+ */
+
+interface SectionMods<T> {
+    readonly add?: ReadonlyArray<T>;
+    readonly remove?: ReadonlyArray<string>;
+}
+interface VariantOptions {
+    readonly id: string;
+    readonly revision?: string;
+    readonly metadata?: Readonly<Record<string, string>>;
+    readonly connectors?: SectionMods<ConnectorInstance>;
+    readonly wires?: SectionMods<WireDef> & {
+        /** Per-wire property overrides, e.g. `{ W1: { length: 800 } }`. */
+        readonly override?: Readonly<Record<string, WireProps>>;
+    };
+    readonly branches?: SectionMods<BranchDef> & {
+        readonly override?: Readonly<Record<string, Partial<Omit<BranchDef, "kind" | "id">>>>;
+    };
+    readonly labels?: SectionMods<LabelDef> & {
+        readonly override?: Readonly<Record<string, Partial<Omit<LabelDef, "kind" | "id">>>>;
+    };
+    readonly splices?: SectionMods<SpliceDef>;
+    readonly cables?: SectionMods<CableDef>;
+}
+/** Derive a variant: `variant(base, { id: "...-long", wires: { override: { W1: { length: 800 } } } })`. */
+declare const variant: (base: HarnessDesign, opts: VariantOptions) => HarnessDesign;
+
+/**
+ * Revision diff (PRD §21, DoD #9).
+ *
+ * Pure structural comparison of two HIR documents. Identifies added,
+ * removed, and changed connectors, pinouts, wires, branches, labels, and
+ * BOM rows — the categories §21 requires. Deterministic: output order
+ * follows canonical HIR ordering.
+ */
+
+interface FieldChange {
+    readonly field: string;
+    readonly from: string;
+    readonly to: string;
+}
+interface EntityChange {
+    readonly id: string;
+    readonly changes: ReadonlyArray<FieldChange>;
+}
+interface SectionDiff {
+    readonly added: ReadonlyArray<string>;
+    readonly removed: ReadonlyArray<string>;
+    readonly changed: ReadonlyArray<EntityChange>;
+}
+interface PinoutChange {
+    readonly connector: string;
+    readonly pin: string;
+    readonly from: string | undefined;
+    readonly to: string | undefined;
+}
+interface HirDiff {
+    readonly harness: ReadonlyArray<FieldChange>;
+    readonly connectors: SectionDiff;
+    readonly pinouts: ReadonlyArray<PinoutChange>;
+    readonly wires: SectionDiff;
+    readonly splices: SectionDiff;
+    readonly cables: SectionDiff;
+    readonly branches: SectionDiff;
+    readonly labels: SectionDiff;
+    readonly bom: SectionDiff;
+}
+declare const diffHir: (a: Hir, b: Hir) => HirDiff;
+declare const isEmptyDiff: (d: HirDiff) => boolean;
+/** Human-readable diff (git-diff-flavored prefixes). */
+declare const formatDiff: (d: HirDiff) => string;
+
+export { type BranchDef, type BranchProps, type CableDef, type CableProps, Codes, type CompileResult, type ConnectorGender, type ConnectorInstance, type ConnectorPart, type Diagnostic, DiagnosticSeverity, type EndpointInput, type EntityChange, type FieldChange, HIR_SCHEMA_VERSION, type HarnessDesign, type HarnessProps, Hir, HirBomItem, HirBranch, HirCable, HirConnector, type HirDiff, HirEndpoint, HirLabel, HirPinRef, HirSplice, HirSpliceRef, HirWire, type LabelDef, type LabelProps, type NerveConfig, type PinAssignments, type PinRef, type PinoutChange, type Rule, type RuleConfig, type RuleContext, type RuleOptions, type RuleReport, type SectionDiff, type SpliceDef, type SpliceProps, type SpliceRef, type Units, type VariantOptions, type WireDef, type WireEndpoint, type WireProps, branch, cable, compileDesign, connector, decodeHir, decodeHirEffect, defineConfig, diffHir, encodeHir, endpointLabel, formatDiff, harness, hasErrors, isEmptyDiff, isPinEndpoint, label, refs, rule, runRules, splice, variant, wire };