@tscircuit/props 0.0.704 → 0.0.706

package/lib/common/ibis.ts

@@ -0,0 +1,60 @@
+import { asset } from "circuit-json"
+import { z } from "zod"
+
+/** Direction is explicit per experiment. Only outputs accept an enable state. */
+export const ibisPinRunState = z.discriminatedUnion("isOutput", [
+  z.object({ isOutput: z.literal(false) }).strict(),
+  z
+    .object({ isOutput: z.literal(true), isOutputEnabled: z.boolean() })
+    .strict(),
+])
+export type IbisPinRunState = z.input<typeof ibisPinRunState>
+
+/** Reference values are labels on the same chip, never inferred supply rails. */
+export const ibisPinReferences = z
+  .object({
+    pullup: z.string().min(1).optional(),
+    pulldown: z.string().min(1).optional(),
+    powerClamp: z.string().min(1).optional(),
+    groundClamp: z.string().min(1).optional(),
+    external: z.string().min(1).optional(),
+  })
+  .strict()
+export type IbisPinReferences = z.input<typeof ibisPinReferences>
+
+/** Same location rules as circuit-json's simulation_ibis_model asset. */
+const ibisAssetPath = z
+  .string()
+  .min(1)
+  .regex(/^(?!\s|[a-z][a-z\d+.-]*:|[/\\])[^\\\u0000-\u001f\u007f]+$/i)
+
+export const ibisModelAsset = asset.extend({
+  project_relative_path: ibisAssetPath,
+  url: z
+    .string()
+    .url()
+    .regex(/^https?:\/\//i)
+    .or(ibisAssetPath),
+})
+
+export const ibisModelDefinition = z.object({
+  ibisModelAsset,
+  ibisComponentName: z.string().min(1),
+  ibisPinNameToPortLabel: z
+    .record(z.string().min(1), z.string().min(1))
+    .refine((pins) => Object.keys(pins).length > 0),
+  ibisPinNameToModelName: z
+    .record(z.string().min(1), z.string().min(1))
+    .optional(),
+  ibisPinNameToReferencePortLabels: z
+    .record(z.string().min(1), ibisPinReferences)
+    .optional(),
+  modelValueCorner: z.union([
+    z.literal("typical"),
+    z.literal("minimum"),
+    z.literal("maximum"),
+  ]),
+  includePackageParasitics: z.boolean(),
+})
+/** Vendor [Component] and [Pin] names are bound explicitly to this chip's ports. No corner or package defaults are inferred. */
+export type IbisModelDefinition = z.input<typeof ibisModelDefinition>

package/lib/components/analogdigitalstimulus.ts

@@ -0,0 +1,60 @@
+import { ms } from "circuit-json"
+import { expectTypesMatch } from "lib/typecheck"
+import { z } from "zod"
+
+/** Matches circuit-json's simulation_digital_stimulus pattern limit. */
+const MAX_TRANSMITTED_BITS = 65536
+
+/** Binary traffic for one external transient. Numeric times are milliseconds. */
+export interface AnalogDigitalStimulusProps {
+  name: string
+  /** Selector for the external analog.transientsimulation experiment. */
+  simulationRef: string
+  /** Selector for the physical source pin driven by this stimulus. */
+  sourcePinRef: string
+  bitDuration: number | string
+  startTime: number | string
+  /** Initial bit before optional inversion. No traffic defaults are inferred. */
+  initialState: 0 | 1
+  inverted?: boolean
+  transmittedData: {
+    transmissionType: "bits"
+    bits: string | [0 | 1, ...(0 | 1)[]]
+    repeat: boolean
+  }
+}
+export const analogDigitalStimulusProps = z
+  .object({
+    name: z.string().min(1),
+    simulationRef: z.string().min(1),
+    sourcePinRef: z.string().min(1),
+    bitDuration: ms.refine(
+      (milliseconds) => Number.isFinite(milliseconds) && milliseconds > 0,
+    ),
+    startTime: ms.refine(
+      (milliseconds) => Number.isFinite(milliseconds) && milliseconds >= 0,
+    ),
+    initialState: z.union([z.literal(0), z.literal(1)]),
+    inverted: z.boolean().default(false),
+    transmittedData: z
+      .object({
+        transmissionType: z.literal("bits"),
+        bits: z.union([
+          z
+            .string()
+            .regex(/^[01]+$/)
+            .max(MAX_TRANSMITTED_BITS),
+          z
+            .array(z.union([z.literal(0), z.literal(1)]))
+            .nonempty()
+            .max(MAX_TRANSMITTED_BITS),
+        ]),
+        repeat: z.boolean(),
+      })
+      .strict(),
+  })
+  .strict()
+expectTypesMatch<
+  AnalogDigitalStimulusProps,
+  z.input<typeof analogDigitalStimulusProps>
+>(true)

package/lib/components/analogeyediagram.ts

@@ -0,0 +1,47 @@
+import { ms } from "circuit-json"
+import { expectTypesMatch } from "lib/typecheck"
+import { z } from "zod"
+
+/** Fixed-origin eye measurement. Numeric times are milliseconds; no compliance threshold is implied. */
+export interface AnalogEyeDiagramProps {
+  name: string
+  simulationRef: string
+  probeRef: string
+  unitInterval: number | string
+  timeOrigin: number | string
+  /** Omitted gate endpoints use the experiment's recorded start/end times. */
+  startTime?: number | string
+  endTime?: number | string
+}
+const finiteMilliseconds = ms.refine(Number.isFinite)
+export const analogEyeDiagramProps = z
+  .object({
+    name: z.string().min(1),
+    simulationRef: z.string().min(1),
+    probeRef: z.string().min(1),
+    unitInterval: finiteMilliseconds.refine((milliseconds) => milliseconds > 0),
+    timeOrigin: finiteMilliseconds,
+    startTime: finiteMilliseconds
+      .refine((milliseconds) => milliseconds >= 0)
+      .optional(),
+    endTime: finiteMilliseconds
+      .refine((milliseconds) => milliseconds > 0)
+      .optional(),
+  })
+  .strict()
+  .superRefine((eye, context) => {
+    if (
+      eye.startTime !== undefined &&
+      eye.endTime !== undefined &&
+      eye.startTime >= eye.endTime
+    ) {
+      context.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["endTime"],
+        message: "Eye gate end must follow its start",
+      })
+    }
+  })
+expectTypesMatch<AnalogEyeDiagramProps, z.input<typeof analogEyeDiagramProps>>(
+  true,
+)

package/lib/components/analogsimulation.ts

@@ -10,14 +10,14 @@ export interface AnalogSimulationProps {
   duration?: number | string
   startTime?: number | string
   timePerStep?: number | string
-  spiceEngine?: AutocompleteString<"spicey" | "ngspice">
+  spiceEngine?: AutocompleteString<"spicey" | "ngspice" | "pcb_spice">
   spiceOptions?: SpiceOptions
   graphIndependentAxes?: boolean
 }
 
-const spiceEngine = z.custom<AutocompleteString<"spicey" | "ngspice">>(
-  (value) => typeof value === "string",
-)
+const spiceEngine = z.custom<
+  AutocompleteString<"spicey" | "ngspice" | "pcb_spice">
+>((value) => typeof value === "string")
 
 export interface SpiceOptions {
   method?: "trap" | "gear"
@@ -37,7 +37,7 @@ export interface AnalogAnalysisSimulationBaseProps {
   /** Stable identity for the simulation experiment. */
   name?: string
   /** SPICE implementation used to run this analysis. */
-  spiceEngine?: AutocompleteString<"spicey" | "ngspice">
+  spiceEngine?: AutocompleteString<"spicey" | "ngspice" | "pcb_spice">
   /** Numerical solver settings forwarded to the selected SPICE engine. */
   spiceOptions?: SpiceOptions
   /** Render each probe with an independent vertical graph scale. */

package/lib/components/analogtransientsimulation.ts

@@ -1,6 +1,7 @@
 import { ms } from "circuit-json"
 import { expectTypesMatch } from "lib/typecheck"
 import { z } from "zod"
+import { ibisPinRunState, type IbisPinRunState } from "lib/common/ibis"
 import {
   analogAnalysisSimulationBaseProps,
   type AnalogAnalysisSimulationBaseProps,
@@ -14,6 +15,8 @@ export interface AnalogTransientSimulationProps
   startTime?: number | string
   /** Maximum simulation timestep. Raw numbers are milliseconds. Defaults to 0.01ms. */
   timePerStep?: number | string
+  /** Physical pin selectors and per-experiment direction/enable states. Requires spiceEngine="pcb_spice"; rendering only declares the experiment. */
+  ibisPinStates?: Record<string, IbisPinRunState>
 }
 
 const positiveMilliseconds = ms.refine(
@@ -27,8 +30,16 @@ export const analogTransientSimulationProps = z
     duration: positiveMilliseconds.default("10ms"),
     startTime: ms.default("0ms"),
     timePerStep: positiveMilliseconds.default("0.01ms"),
+    ibisPinStates: z.record(z.string().min(1), ibisPinRunState).optional(),
   })
   .superRefine((simulation, context) => {
+    if (simulation.ibisPinStates && simulation.spiceEngine !== "pcb_spice") {
+      context.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["ibisPinStates"],
+        message: "IBIS pin states require spiceEngine=pcb_spice",
+      })
+    }
     if (
       simulation.startTime < 0 ||
       simulation.startTime > simulation.duration

package/lib/components/ibismodel.ts

@@ -0,0 +1,13 @@
+import { ibisModelDefinition, type IbisModelDefinition } from "lib/common/ibis"
+import { expectTypesMatch } from "lib/typecheck"
+import { z } from "zod"
+
+/** Declares a model for an existing chip. Rendering never fetches or converts the source. */
+export interface IbisModelProps extends IbisModelDefinition {
+  /** Selector for exactly one source component in this subcircuit. */
+  componentRef: string
+}
+export const ibisModelProps = ibisModelDefinition
+  .extend({ componentRef: z.string().min(1) })
+  .strict()
+expectTypesMatch<IbisModelProps, z.input<typeof ibisModelProps>>(true)

package/lib/index.ts

@@ -78,6 +78,10 @@ export * from "./components/push-button"
 export * from "./components/subcircuit"
 export * from "./components/analogsimulation"
 export * from "./components/analogtransientsimulation"
+export * from "./common/ibis"
+export * from "./components/ibismodel"
+export * from "./components/analogdigitalstimulus"
+export * from "./components/analogeyediagram"
 export * from "./components/analogdcoperatingpointsimulation"
 export * from "./components/analogdcsweepsimulation"
 export * from "./components/analogacsweepsimulation"

package/lib/platformConfig.ts

@@ -81,6 +81,16 @@ export interface PlatformConfig {
 
   autorouter?: AutorouterProp
 
+  /**
+   * Requested local autorouting thread count: a positive safe integer. Hosts
+   * supporting Bun/Node routing workers may use values above 1; 1 requests
+   * inline solving. Browsers remain single-threaded and cloud routing is
+   * unaffected. Omitted leaves the host default unchanged. Parsed values are
+   * preserved; there are no aliases or conflicts with autorouter selection.
+   * Existing configurations require no migration.
+   */
+  autorouterThreads?: number
+
   autorouterMap?: Record<string, AutorouterDefinition>
 
   /** Use networked Pipeline9 node solving at effort 1. Omitted or false keeps local routing.
@@ -126,7 +136,7 @@ export interface PlatformConfig {
   includeBoardFiles?: string[]
   snapshotsDir?: string
 
-  defaultSpiceEngine?: AutocompleteString<"spicey" | "ngspice">
+  defaultSpiceEngine?: AutocompleteString<"spicey" | "ngspice" | "pcb_spice">
 
   unitPreference?: "mm" | "in" | "mil"
 
@@ -220,9 +230,9 @@ const spiceEngineZod = z.object({
     ),
 })
 
-const defaultSpiceEngine = z.custom<AutocompleteString<"spicey" | "ngspice">>(
-  (value) => typeof value === "string",
-)
+const defaultSpiceEngine = z.custom<
+  AutocompleteString<"spicey" | "ngspice" | "pcb_spice">
+>((value) => typeof value === "string")
 
 const autorouterInstance = z.object({
   run: z
@@ -291,6 +301,15 @@ export const platformConfig = z.object({
     .optional(),
   fabricatorEngine: fabricatorEngine.optional(),
   autorouter: autorouterProp.optional(),
+  autorouterThreads: z
+    .number()
+    .int()
+    .positive()
+    .safe()
+    .describe(
+      "Requested local autorouting thread count for supporting hosts. 1 requests inline solving; omission preserves the host default. Browsers stay single-threaded and cloud routing is unaffected.",
+    )
+    .optional(),
   autorouterMap: z.record(z.string(), autorouterDefinition).optional(),
   allowLegacyAutorouters: z.boolean().optional(),
   registryApiUrl: url.optional(),

package/package.json

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