@tscircuit/props 0.0.682 → 0.0.684

package/lib/assembly/board-mounting.ts

@@ -0,0 +1,56 @@
+import type { AutocompleteString } from "lib/common/autocomplete"
+import { z } from "zod"
+
+export type BoardMountRotationAnchor = AutocompleteString<
+  "topedge" | "bottomedge" | "leftedge" | "rightedge"
+>
+
+export type BoardMountOrientation =
+  | "top_layer_toward_mount_face"
+  | "bottom_layer_toward_mount_face"
+
+const identityPathPattern =
+  "[A-Za-z_][A-Za-z0-9_-]*(?:\\.[A-Za-z_][A-Za-z0-9_-]*)*"
+const referencePattern =
+  "[A-Za-z_][A-Za-z0-9_-]*(?:\\.[A-Za-z_][A-Za-z0-9_-]*)+"
+const reference = new RegExp(`^${referencePattern}$`)
+const anchor = new RegExp(`^${identityPathPattern}$`)
+const expression = new RegExp(
+  `^calc\\(\\s*(${referencePattern})\\s*(?:([+-])\\s*((?:\\d+(?:\\.\\d*)?|\\.\\d+))\\s*(degcw|degccw))?\\s*\\)$`,
+)
+
+export const boardMountRotation = z
+  .string()
+  .trim()
+  .superRefine((value, ctx) => {
+    if (reference.test(value)) return
+    const match = expression.exec(value)
+    if (!match) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message:
+          "Expected a qualified mounting reference or calc(reference +/- Ndegcw|Ndegccw)",
+      })
+      return
+    }
+    if (match[3] !== undefined && !Number.isFinite(Number(match[3]))) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "Mount rotation angle must be finite",
+      })
+    }
+  })
+
+export const boardMountRotationAnchor = z
+  .custom<BoardMountRotationAnchor>((value) => typeof value === "string", {
+    message: "Expected a board edge or component identity path",
+  })
+  .transform((value) => value.trim())
+  .refine((value) => anchor.test(value), {
+    message: "Expected a board edge or component identity path",
+  })
+
+export const boardMountOrientation = z.enum([
+  "top_layer_toward_mount_face",
+  "bottom_layer_toward_mount_face",
+])

package/lib/assembly/index.ts

@@ -4,6 +4,7 @@ import { assemblyMotorProps } from "./motor"
 import { assemblyScreenProps } from "./screen"
 import { assemblySubassemblyProps } from "./subassembly"
 
+export * from "./board-mounting"
 export * from "./device"
 export * from "./motor"
 export * from "./screen"

package/lib/assembly/motor.ts

@@ -23,6 +23,8 @@ export interface AssemblyMotorProps {
    * shaft. Defaults to "z+", the native shaft axis of the NEMA models.
    */
   shaftFacingDirection?: CadModelAxisDirection
+  /** e.g. "jst-ph-6". */
+  wireConnection?: "none" | "stubs" | "jst-ph-6"
 }
 
 export const assemblyMotorProps = z
@@ -34,8 +36,17 @@ export const assemblyMotorProps = z
     standard: z.enum(["nema8", "nema17", "nema23"]).optional(),
     model: z.string().trim().min(1).optional(),
     shaftFacingDirection: cadModelAxisDirection.default("z+"),
+    wireConnection: z.enum(["none", "stubs", "jst-ph-6"]).optional(),
   })
   .superRefine((motor, context) => {
+    if (motor.model !== undefined && motor.wireConnection !== undefined) {
+      context.addIssue({
+        code: z.ZodIssueCode.custom,
+        message:
+          "Set wireConnection in the custom model string, or use standard",
+        path: ["wireConnection"],
+      })
+    }
     if (motor.standard === undefined && motor.model === undefined) {
       context.addIssue({
         code: z.ZodIssueCode.custom,

package/lib/common/impedanceTarget.ts

@@ -0,0 +1,125 @@
+import { resistance } from "circuit-json"
+import { z } from "zod"
+import { expectTypesMatch } from "lib/typecheck"
+
+/** Scalar ohm target or a tolerance string, e.g. "50±25ohm".
+ * Input remains XML-compatible. Component parsing expands tolerance strings
+ * to the scalar target and its Min/Max sibling props, all in ohms. */
+export type ImpedanceTarget = number | string
+export const positiveImpedance = z
+  .union([
+    z.number(),
+    z
+      .string()
+      .refine(
+        (value) => !/(?:±|\+\/-)/.test(value),
+        "Use a scalar impedance for explicit bounds",
+      ),
+  ])
+  .pipe(resistance)
+  .pipe(z.number().positive().finite())
+const quantity = /^([+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?)\s*(.*?)$/i
+const tolerantImpedance = z
+  .string()
+  .regex(/(?:±|\+\/-)/)
+  .transform((value, ctx) => {
+    const parts = value.trim().split(/\s*(?:±|\+\/-)\s*/)
+    const nominal = parts.length === 2 ? parts[0]!.match(quantity) : null
+    const tolerance = parts.length === 2 ? parts[1]!.match(quantity) : null
+    if (!nominal || !tolerance) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "Use a nominal impedance ± an absolute ohm tolerance",
+      })
+      return z.NEVER
+    }
+    const ohmUnit = /^(?:[yzafpnumkKMGTPEZYµμ])?(?:ohms?|Ω)$/i
+    if (
+      (nominal[2] && !ohmUnit.test(nominal[2])) ||
+      (tolerance[2] && !ohmUnit.test(tolerance[2]))
+    ) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message:
+          "Use an absolute ohm tolerance, not a percentage or another unit",
+      })
+      return z.NEVER
+    }
+    const nominalValue = resistance.safeParse(
+      `${nominal[1]}${nominal[2] || tolerance[2] || "ohm"}`,
+    )
+    const toleranceValue = resistance.safeParse(
+      `${tolerance[1]}${tolerance[2] || nominal[2] || "ohm"}`,
+    )
+    if (
+      !nominalValue.success ||
+      !toleranceValue.success ||
+      !Number.isFinite(nominalValue.data) ||
+      !Number.isFinite(toleranceValue.data) ||
+      nominalValue.data <= 0 ||
+      toleranceValue.data < 0
+    ) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message:
+          "Nominal impedance must be positive and tolerance nonnegative, in ohms",
+      })
+      return z.NEVER
+    }
+    return {
+      nominal: nominalValue.data,
+      min: nominalValue.data - toleranceValue.data,
+      max: nominalValue.data + toleranceValue.data,
+    }
+  })
+  .pipe(
+    z.object({
+      nominal: z.number().positive().finite(),
+      min: z.number().positive().finite(),
+      max: z.number().positive().finite(),
+    }),
+  )
+const scalarImpedance = positiveImpedance
+export const impedanceTarget = z.union([tolerantImpedance, scalarImpedance])
+expectTypesMatch<ImpedanceTarget, z.input<typeof impedanceTarget>>(true)
+
+/** Explicit bounds may accompany a scalar target. When both range notations
+ * are supplied, they must agree; no conflicting bounds are silently replaced. */
+export function validateImpedanceTarget(
+  target: z.output<typeof impedanceTarget> | undefined,
+  min: number | undefined,
+  max: number | undefined,
+  ctx: z.RefinementCtx,
+  propName: string,
+) {
+  if (min !== undefined && max !== undefined && min > max)
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: [`${propName}Max`],
+      message: "Maximum impedance cannot be below minimum impedance",
+    })
+  if (typeof target === "object") {
+    for (const [suffix, explicit, derived] of [
+      ["Min", min, target.min],
+      ["Max", max, target.max],
+    ] as const)
+      if (
+        explicit !== undefined &&
+        Math.abs(explicit - derived) > 1e-9 * Math.max(1, Math.abs(derived))
+      )
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          path: [`${propName}${suffix}`],
+          message:
+            "Explicit impedance bound conflicts with the target tolerance",
+        })
+  } else if (
+    target !== undefined &&
+    ((min !== undefined && target < min) || (max !== undefined && target > max))
+  )
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: [propName],
+      message: "Target impedance must lie within its declared bounds",
+    })
+}

package/lib/common/routeLength.ts

@@ -0,0 +1,102 @@
+import { distance } from "circuit-json"
+import { z } from "zod"
+import { expectTypesMatch } from "lib/typecheck"
+
+/** A length measured from the selected signals' pad endpoints, in board-world
+ * XY mm (+X right, +Y up). of accepts trace/port/bus/pair selectors. Without
+ * of, use the current members and any lengthMatchTo members. */
+export interface RelativeRouteLength {
+  reference: "longest_manhattan"
+  of?: string[]
+  /** Offset added to the reference distance. Raw numbers are mm; may be negative. */
+  offset?: number | string
+}
+export type RouteLength = number | string | RelativeRouteLength
+export const nonnegativeRouteDistance = distance.pipe(
+  z.number().nonnegative().finite(),
+)
+export const routeLength = z.union([
+  nonnegativeRouteDistance,
+  z
+    .object({
+      reference: z.literal("longest_manhattan"),
+      of: z.array(z.string().min(1)).min(1).optional(),
+      offset: distance.pipe(z.number().finite()).optional(),
+    })
+    .strict(),
+])
+expectTypesMatch<RouteLength, z.input<typeof routeLength>>(true)
+
+/** Validate comparable bounds without resolving selectors or geometry here.
+ * Relative values with different references remain independent constraints. */
+export function validateRouteLengths(
+  props: {
+    minLength?: z.output<typeof routeLength>
+    maxLength?: z.output<typeof routeLength>
+    targetLength?: z.output<typeof routeLength>
+    lengthTolerance?: number
+    lengthMatchTo?: string | string[]
+    maxLengthSkew?: number
+  },
+  ctx: z.RefinementCtx,
+) {
+  if (
+    Boolean(props.targetLength !== undefined) !==
+    Boolean(props.lengthTolerance !== undefined)
+  )
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ["lengthTolerance"],
+      message: "targetLength and lengthTolerance must be supplied together",
+    })
+  if (props.lengthMatchTo !== undefined && props.maxLengthSkew === undefined)
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ["maxLengthSkew"],
+      message: "lengthMatchTo requires an explicit maxLengthSkew",
+    })
+  const comparable = (value: z.output<typeof routeLength>) =>
+    typeof value === "number"
+      ? { basis: "absolute", amount: value }
+      : {
+          basis: JSON.stringify([
+            value.reference,
+            value.of ? [...value.of].sort() : null,
+          ]),
+          amount: value.offset ?? 0,
+        }
+  const min =
+    props.minLength === undefined ? undefined : comparable(props.minLength)
+  const max =
+    props.maxLength === undefined ? undefined : comparable(props.maxLength)
+  const target =
+    props.targetLength === undefined
+      ? undefined
+      : comparable(props.targetLength)
+  if (min && max && min.basis === max.basis && min.amount > max.amount)
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ["maxLength"],
+      message: "maxLength cannot be below minLength for the same reference",
+    })
+  if (
+    (target &&
+      min &&
+      target.basis === min.basis &&
+      target.amount + (props.lengthTolerance ?? 0) < min.amount) ||
+    (target &&
+      max &&
+      target.basis === max.basis &&
+      target.amount - (props.lengthTolerance ?? 0) > max.amount)
+  )
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ["targetLength"],
+      message:
+        "targetLength tolerance window does not intersect the declared length bounds",
+    })
+}
+export const lengthMatchTo = z.union([
+  z.string().min(1),
+  z.array(z.string().min(1)).min(1),
+])

package/lib/common/traceSpacing.ts

@@ -0,0 +1,18 @@
+import { distance } from "circuit-json"
+import { z } from "zod"
+import { expectTypesMatch } from "lib/typecheck"
+
+/** Centreline distance in mm, or a multiple of the larger local trace width
+ * written as e.g. "3w". Parsed multiples remain {widthMultiplier: 3} so the
+ * checker can evaluate varying widths without choosing a width in props. */
+export type TraceSpacing = number | string
+const widthSpacing = z
+  .string()
+  .regex(/^\s*(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?\s*w\s*$/i)
+  .transform((value) => ({
+    widthMultiplier: Number(value.trim().replace(/w$/i, "")),
+  }))
+  .pipe(z.object({ widthMultiplier: z.number().positive().finite() }))
+const absoluteSpacing = distance.pipe(z.number().positive().finite())
+export const traceSpacing = z.union([widthSpacing, absoluteSpacing])
+expectTypesMatch<TraceSpacing, z.input<typeof traceSpacing>>(true)

package/lib/components/board.ts

@@ -5,6 +5,13 @@ import { type Point, point } from "lib/common/point"
 import { expectTypesMatch } from "lib/typecheck"
 import { z } from "zod"
 import { subcircuitGroupProps, type SubcircuitGroupProps } from "./group"
+import {
+  boardMountOrientation,
+  boardMountRotation,
+  boardMountRotationAnchor,
+  type BoardMountOrientation,
+  type BoardMountRotationAnchor,
+} from "../assembly/board-mounting"
 
 const boardColorPresets = [
   "not_specified",
@@ -78,17 +85,16 @@ export const boardOutlinePoint = z
 export interface BoardProps
   extends Omit<SubcircuitGroupProps, "subcircuit" | "connections" | "outline"> {
   title?: string
-  /**
-   * Assembly mounting target, such as "NEMA17.backface". Trimmed; omitted
-   * leaves the board unattached. The target face is resolved by the consumer.
-   */
+  /** e.g. "NEMA17.backface". */
   mountedTo?: string
-  /**
-   * Nonnegative finite clearance between the target mounting face and the
-   * nearest PCB surface, in millimeters or a unit string. Parsed to mm.
-   * Omitted leaves the gap unset; only meaningful when mountedTo is supplied.
-   */
+  /** Clearance from the mounting face, e.g. "6mm". */
   mountGap?: Distance
+  /** e.g. "J_USB" or "rightedge". */
+  mountRotationAnchor?: BoardMountRotationAnchor
+  /** e.g. "calc(NEMA17.wireside-90degcw)". */
+  mountRotation?: string
+  /** e.g. "top_layer_toward_mount_face". */
+  mountOrientation?: BoardMountOrientation
   /** Fabricator preset, preserved as supplied. Omitted leaves the preset unset. */
   fabricatorPreset?:
     | "jlcpcb_economy"
@@ -169,15 +175,20 @@ export const boardProps = subcircuitGroupProps
       .trim()
       .min(1)
       .optional()
-      .describe(
-        'Assembly mounting target, such as "NEMA17.backface". Trimmed; omitted leaves the board unattached. The target face is resolved by the consumer.',
-      ),
+      .describe('e.g. "NEMA17.backface".'),
     mountGap: distance
       .pipe(z.number().nonnegative().finite())
       .optional()
-      .describe(
-        "Nonnegative finite clearance between the target mounting face and the nearest PCB surface, in millimeters or a unit string, parsed to mm. Omitted leaves the gap unset; only meaningful when mountedTo is supplied.",
-      ),
+      .describe('Clearance from the mounting face, e.g. "6mm".'),
+    mountRotationAnchor: boardMountRotationAnchor
+      .optional()
+      .describe('e.g. "J_USB" or "rightedge".'),
+    mountRotation: boardMountRotation
+      .optional()
+      .describe('e.g. "calc(NEMA17.wireside-90degcw)".'),
+    mountOrientation: boardMountOrientation
+      .optional()
+      .describe('e.g. "top_layer_toward_mount_face".'),
     fabricatorPreset: z
       .enum([
         "jlcpcb_economy",

package/lib/components/bus.ts

@@ -1,10 +1,19 @@
-import { expectTypesMatch } from "lib/typecheck"
 import {
-  distance,
-  layer_ref,
-  resistance,
-  type LayerRefInput,
-} from "circuit-json"
+  routeLength,
+  lengthMatchTo,
+  nonnegativeRouteDistance,
+  validateRouteLengths,
+  type RouteLength,
+} from "../common/routeLength"
+import { traceSpacing, type TraceSpacing } from "../common/traceSpacing"
+import {
+  impedanceTarget,
+  positiveImpedance,
+  validateImpedanceTarget,
+  type ImpedanceTarget,
+} from "../common/impedanceTarget"
+import { expectTypesMatch } from "lib/typecheck"
+import { distance, layer_ref, type LayerRefInput } from "circuit-json"
 import { z } from "zod"
 
 export type BusName = string
@@ -15,14 +24,34 @@ export type BusName = string
  */
 export interface BusProps {
   name?: string
+  /** Match these trace/port/bus/pair selectors as well as this element's members.
+   * maxLengthSkew applies to the combined members; no tolerance is inferred. */
+  lengthMatchTo?: string | string[]
+  /** Minimum/maximum pad-to-pad planar length for each member. Raw numbers are mm. */
+  minLength?: RouteLength
+  maxLength?: RouteLength
+  /** Nominal member length, absolute or relative to selected endpoints.
+   * Requires an explicit lengthTolerance, including zero for exact matching. */
+  targetLength?: RouteLength
+  /** Allowed deviation above/below targetLength, in mm. */
+  lengthTolerance?: number | string
+  /** Minimum centreline spacing between bus members, excluding declared pair partners.
+   * Raw numbers are mm; "3w" means three times the larger local trace width. */
+  pcbTraceSpacing?: TraceSpacing
+  /** Minimum centreline spacing to traces outside this bus/pair (mm or e.g. "4w"). */
+  pcbSpacingToOtherSignals?: TraceSpacing
+
   /** One or more trace names or port selectors for the connections in the bus. */
   connections: string[]
   /** If set, every trace in this bus is assigned to this autorouting phase. */
   routingPhaseIndex?: number | null
   /** Maximum routed-length difference between bus members. Raw numbers are millimeters. */
   maxLengthSkew?: number | string
-  /** Intended single-ended characteristic impedance. Raw numbers are ohms. */
-  targetImpedance?: number | string
+  /** Intended single-ended impedance, e.g. "50±25ohm". Raw numbers are ohms. */
+  targetImpedance?: ImpedanceTarget
+  /** Inclusive minimum/maximum acceptable impedance, in ohms. May be used without a nominal target. */
+  targetImpedanceMin?: number | string
+  targetImpedanceMax?: number | string
   /** Explicit PCB trace width for every bus member. Raw numbers are millimeters. */
   pcbTraceWidth?: number | string
   /** PCB layers on which the bus may be routed. */
@@ -33,17 +62,54 @@ export interface BusProps {
   preferredLayers?: LayerRefInput[]
 }
 
-export const busProps = z.object({
-  name: z.string().optional(),
-  connections: z.array(z.string()).min(1),
-  routingPhaseIndex: z.number().nullable().optional(),
-  maxLengthSkew: distance.pipe(z.number().min(0).finite()).optional(),
-  targetImpedance: resistance.pipe(z.number().positive().finite()).optional(),
-  pcbTraceWidth: distance.pipe(z.number().positive().finite()).optional(),
-  pcbAllowedLayers: z.array(layer_ref).min(1).optional(),
-  preferredLayer: layer_ref.optional(),
-  preferredLayers: z.array(layer_ref).min(1).optional(),
-})
+export const busProps = z
+  .object({
+    name: z.string().optional(),
+    lengthMatchTo: lengthMatchTo.optional(),
+    minLength: routeLength.optional(),
+    maxLength: routeLength.optional(),
+    targetLength: routeLength.optional(),
+    lengthTolerance: nonnegativeRouteDistance.optional(),
+    pcbTraceSpacing: traceSpacing.optional(),
+    pcbSpacingToOtherSignals: traceSpacing.optional(),
+
+    connections: z.array(z.string()).min(1),
+    routingPhaseIndex: z.number().nullable().optional(),
+    maxLengthSkew: distance.pipe(z.number().min(0).finite()).optional(),
+    targetImpedance: impedanceTarget.optional(),
+    targetImpedanceMin: positiveImpedance.optional(),
+    targetImpedanceMax: positiveImpedance.optional(),
+    pcbTraceWidth: distance.pipe(z.number().positive().finite()).optional(),
+    pcbAllowedLayers: z.array(layer_ref).min(1).optional(),
+    preferredLayer: layer_ref.optional(),
+    preferredLayers: z.array(layer_ref).min(1).optional(),
+  })
+  .superRefine((props, ctx) => {
+    validateRouteLengths(props, ctx)
+    validateImpedanceTarget(
+      props.targetImpedance,
+      props.targetImpedanceMin,
+      props.targetImpedanceMax,
+      ctx,
+      "targetImpedance",
+    )
+  })
+  .transform(
+    ({
+      targetImpedance,
+      ...props
+    }): typeof props & { targetImpedance?: number } => {
+      if (targetImpedance === undefined) return props
+      if (typeof targetImpedance === "number")
+        return { ...props, targetImpedance }
+      return {
+        ...props,
+        targetImpedance: targetImpedance.nominal,
+        targetImpedanceMin: targetImpedance.min,
+        targetImpedanceMax: targetImpedance.max,
+      }
+    },
+  )
 
 type InferredBusProps = z.input<typeof busProps>
 expectTypesMatch<BusProps, InferredBusProps>(true)

package/lib/components/differentialpair.ts

@@ -1,5 +1,19 @@
+import {
+  routeLength,
+  lengthMatchTo,
+  nonnegativeRouteDistance,
+  validateRouteLengths,
+  type RouteLength,
+} from "../common/routeLength"
+import { traceSpacing, type TraceSpacing } from "../common/traceSpacing"
+import {
+  impedanceTarget,
+  positiveImpedance,
+  validateImpedanceTarget,
+  type ImpedanceTarget,
+} from "../common/impedanceTarget"
 import { expectTypesMatch } from "lib/typecheck"
-import { distance, resistance } from "circuit-json"
+import { distance } from "circuit-json"
 import { z } from "zod"
 
 /**
@@ -8,31 +22,82 @@ import { z } from "zod"
  */
 export interface DifferentialPairProps {
   name?: string
+  /** Match these trace/port/bus/pair selectors as well as this element's members.
+   * maxLengthSkew applies to the combined members; no tolerance is inferred. */
+  lengthMatchTo?: string | string[]
+  /** Minimum/maximum pad-to-pad planar length for each member. Raw numbers are mm. */
+  minLength?: RouteLength
+  maxLength?: RouteLength
+  /** Nominal member length, absolute or relative to selected endpoints.
+   * Requires an explicit lengthTolerance, including zero for exact matching. */
+  targetLength?: RouteLength
+  /** Allowed deviation above/below targetLength, in mm. */
+  lengthTolerance?: number | string
+  /** Minimum centreline spacing to traces outside this bus/pair (mm or e.g. "4w"). */
+  pcbSpacingToOtherSignals?: TraceSpacing
+
   /** Name of the trace or pin carrying the positive signal. */
   positiveConnection: string
   /** Name of the trace or pin carrying the negative signal. */
   negativeConnection: string
   /** Maximum permitted routed-length skew. Raw numbers are millimeters. */
   maxLengthSkew?: number | string
-  /** Intended differential characteristic impedance. Raw numbers are ohms. */
-  targetDifferentialImpedance?: number | string
+  /** Intended differential impedance, e.g. "100±10ohm". Raw numbers are ohms. */
+  targetDifferentialImpedance?: ImpedanceTarget
+  /** Inclusive minimum/maximum acceptable impedance, in ohms. May be used without a nominal target. */
+  targetDifferentialImpedanceMin?: number | string
+  targetDifferentialImpedanceMax?: number | string
   /** Edge-to-edge PCB copper gap between the pair. Raw numbers are millimeters. */
   pcbTraceGap?: number | string
   /** Maximum length over which the pair may be routed without coupling. Raw numbers are millimeters. */
   maxUncoupledLength?: number | string
 }
 
-export const differentialPairProps = z.object({
-  name: z.string().optional(),
-  positiveConnection: z.string(),
-  negativeConnection: z.string(),
-  maxLengthSkew: distance.pipe(z.number().min(0).finite()).optional(),
-  targetDifferentialImpedance: resistance
-    .pipe(z.number().positive().finite())
-    .optional(),
-  pcbTraceGap: distance.pipe(z.number().positive().finite()).optional(),
-  maxUncoupledLength: distance.pipe(z.number().min(0).finite()).optional(),
-})
+export const differentialPairProps = z
+  .object({
+    name: z.string().optional(),
+    lengthMatchTo: lengthMatchTo.optional(),
+    minLength: routeLength.optional(),
+    maxLength: routeLength.optional(),
+    targetLength: routeLength.optional(),
+    lengthTolerance: nonnegativeRouteDistance.optional(),
+    pcbSpacingToOtherSignals: traceSpacing.optional(),
+
+    positiveConnection: z.string(),
+    negativeConnection: z.string(),
+    maxLengthSkew: distance.pipe(z.number().min(0).finite()).optional(),
+    targetDifferentialImpedance: impedanceTarget.optional(),
+    targetDifferentialImpedanceMin: positiveImpedance.optional(),
+    targetDifferentialImpedanceMax: positiveImpedance.optional(),
+    pcbTraceGap: distance.pipe(z.number().positive().finite()).optional(),
+    maxUncoupledLength: distance.pipe(z.number().min(0).finite()).optional(),
+  })
+  .superRefine((props, ctx) => {
+    validateRouteLengths(props, ctx)
+    validateImpedanceTarget(
+      props.targetDifferentialImpedance,
+      props.targetDifferentialImpedanceMin,
+      props.targetDifferentialImpedanceMax,
+      ctx,
+      "targetDifferentialImpedance",
+    )
+  })
+  .transform(
+    ({
+      targetDifferentialImpedance,
+      ...props
+    }): typeof props & { targetDifferentialImpedance?: number } => {
+      if (targetDifferentialImpedance === undefined) return props
+      if (typeof targetDifferentialImpedance === "number")
+        return { ...props, targetDifferentialImpedance }
+      return {
+        ...props,
+        targetDifferentialImpedance: targetDifferentialImpedance.nominal,
+        targetDifferentialImpedanceMin: targetDifferentialImpedance.min,
+        targetDifferentialImpedanceMax: targetDifferentialImpedance.max,
+      }
+    },
+  )
 
 type InferredDifferentialPairProps = z.input<typeof differentialPairProps>
 expectTypesMatch<DifferentialPairProps, InferredDifferentialPairProps>(true)

package/lib/index.ts

@@ -151,3 +151,14 @@ export * from "./common/fanoutProps"
 export * from "./common/implicitBreakoutPointSolver"
 
 export * from "./common/fanoutTracePath"
+
+export {
+  routeLength,
+  type RouteLength,
+  type RelativeRouteLength,
+} from "./common/routeLength"
+export {
+  traceSpacing,
+  type TraceSpacing,
+} from "./common/traceSpacing"
+export { impedanceTarget, type ImpedanceTarget } from "./common/impedanceTarget"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tscircuit/props",
-  "version": "0.0.682",
+  "version": "0.0.684",
   "description": "Props for tscircuit builtin component types",
   "main": "dist/index.js",
   "type": "module",