@tscircuit/props 0.0.683 → 0.0.685

package/lib/assembly/index.ts

@@ -1,5 +1,6 @@
 import { assemblyCadAssemblyProps } from "./cadassembly"
 import { assemblyDeviceProps } from "./device"
+import { assemblyPrintedPartProps } from "./printedpart"
 import { assemblyMotorProps } from "./motor"
 import { assemblyScreenProps } from "./screen"
 import { assemblySubassemblyProps } from "./subassembly"
@@ -7,6 +8,7 @@ import { assemblySubassemblyProps } from "./subassembly"
 export * from "./board-mounting"
 export * from "./device"
 export * from "./motor"
+export * from "./printedpart"
 export * from "./screen"
 export * from "./subassembly"
 export * from "./cadassembly"
@@ -14,6 +16,7 @@ export * from "./cadassembly"
 export const assemblyProps = {
   device: assemblyDeviceProps,
   motor: assemblyMotorProps,
+  printedpart: assemblyPrintedPartProps,
   screen: assemblyScreenProps,
   subassembly: assemblySubassemblyProps,
   cadassembly: assemblyCadAssemblyProps,

package/lib/assembly/printedpart.ts

@@ -0,0 +1,86 @@
+import { type CadModelProp, cadModelProp } from "lib/common/cadModel"
+import { url } from "lib/common/url"
+import { distance, type Distance } from "lib/common/distance"
+import { expectTypesMatch } from "lib/typecheck"
+import { isValidElement, type ReactElement } from "react"
+import { z } from "zod"
+
+/** Provide exactly one of jscad, model, modelUrl, or cadModel. */
+export interface AssemblyPrintedPartProps {
+  /** Stable identity used by assembly mounting selectors. */
+  name: string
+  displayName?: string
+  /** Pure jscad-fiber JSX in right-handed local XYZ, dimensions in millimeters.
+   * Named reference rectangles define attachment faces; they add no material.
+   * Hooks, async components, and raw kernel geometry are not supported.
+   */
+  jscad?: ReactElement
+  /** Modelprinter/footprinter string or model URL. */
+  model?: string
+  modelUrl?: string
+  cadModel?: CadModelProp
+  /** Assembly mounting target. */
+  mountedTo?: string
+  /** Name of this part's reference rectangle to mate with mountedTo.
+   * Both props must be supplied together; outward normals oppose and local
+   * in-plane X directions align. Without them the part uses its local origin.
+   */
+  mountFace?: string
+  /** Nonnegative surface clearance in mm or a unit string; defaults to zero.
+   * Requires mountedTo. Positive values separate the mating faces.
+   */
+  mountGap?: Distance
+}
+
+export const assemblyPrintedPartProps = z
+  .object({
+    name: z.string().trim().min(1),
+    displayName: z.string().optional(),
+    jscad: z
+      .custom<ReactElement>(isValidElement, "Expected jscad-fiber JSX")
+      .optional(),
+    model: z.string().trim().min(1).optional(),
+    modelUrl: url
+      .refine((value) => value.trim().length > 0, "modelUrl cannot be empty")
+      .optional(),
+    cadModel: cadModelProp.optional(),
+    mountedTo: z
+      .string()
+      .trim()
+      .regex(/^.+\.[^.]+$/, "Expected part.face")
+      .optional(),
+    mountFace: z.string().trim().min(1).optional(),
+    mountGap: distance.pipe(z.number().nonnegative().finite()).optional(),
+  })
+  .superRefine((part, ctx) => {
+    if (
+      [part.jscad, part.model, part.modelUrl, part.cadModel].filter(
+        (value) => value !== undefined,
+      ).length !== 1
+    ) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["jscad"],
+        message: "Provide exactly one of jscad, model, modelUrl, or cadModel",
+      })
+    }
+    if ((part.mountedTo === undefined) !== (part.mountFace === undefined)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["mountFace"],
+        message: "Provide mountedTo and mountFace together",
+      })
+    }
+    if (part.mountGap !== undefined && part.mountedTo === undefined) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["mountGap"],
+        message: "mountGap requires mountedTo",
+      })
+    }
+  })
+
+export type AssemblyPrintedPartPropsInput = z.input<
+  typeof assemblyPrintedPartProps
+>
+expectTypesMatch<AssemblyPrintedPartProps, AssemblyPrintedPartPropsInput>(true)

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/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.683",
+  "version": "0.0.685",
   "description": "Props for tscircuit builtin component types",
   "main": "dist/index.js",
   "type": "module",