@tscircuit/core 0.0.2180 → 0.0.2181

package/dist/index.js

@@ -18,6 +18,8 @@ __export(components_exports, {
   AnalogAnalysisSimulation: () => AnalogAnalysisSimulation,
   AnalogDcOperatingPointSimulation: () => AnalogDcOperatingPointSimulation,
   AnalogDcSweepSimulation: () => AnalogDcSweepSimulation,
+  AnalogDigitalStimulus: () => AnalogDigitalStimulus,
+  AnalogEyeDiagram: () => AnalogEyeDiagram,
   AnalogSimulation: () => AnalogSimulation,
   AnalogSweepParameter: () => AnalogSweepParameter,
   AnalogTransientSimulation: () => AnalogTransientSimulation,
@@ -66,6 +68,7 @@ __export(components_exports, {
   Fuse: () => Fuse,
   Group: () => Group5,
   Hole: () => Hole,
+  IbisModel: () => IbisModel,
   Inductor: () => Inductor,
   Interconnect: () => Interconnect,
   Jumper: () => Jumper,
@@ -1751,6 +1754,11 @@ var renderPhaseIndexMap = new Map(
 var asyncPhaseDependencies = {
   InflateSubcircuitCircuitJson: ["RenderIsolatedSubcircuits"],
   ResolveFootprintPinLabels: ["PcbFootprintStringRender", "FetchPartFootprint"],
+  SimulationRender: ["PcbFootprintStringRender", "FetchPartFootprint"],
+  SimulationSpiceEngineRender: [
+    "PcbFootprintStringRender",
+    "FetchPartFootprint"
+  ],
   SchematicComponentRender: ["PcbFootprintStringRender", "FetchPartFootprint"],
   SchematicPortRender: ["PcbFootprintStringRender", "FetchPartFootprint"],
   SymbolContainerRender: ["PcbFootprintStringRender", "FetchPartFootprint"],
@@ -20450,6 +20458,139 @@ function inflatePcbBoard(pcbBoard, inflatorContext) {
   return board;
 }
 
+// lib/components/primitive-components/Group/Subcircuit/inflators/inflateSimulation.ts
+import { getElementId } from "@tscircuit/circuit-json-util";
+var ibisSimulationTypes = [
+  "simulation_ibis_model",
+  "simulation_ibis_pin_state",
+  "simulation_digital_stimulus",
+  "simulation_eye_diagram"
+];
+var simulationTypes = [
+  "simulation_experiment",
+  "simulation_voltage_probe",
+  ...ibisSimulationTypes
+];
+var InflatedSimulation = class extends PrimitiveComponent2 {
+  constructor(inflationCtx) {
+    super({});
+    this.inflationCtx = inflationCtx;
+  }
+  inflationCtx;
+  get config() {
+    return { ...super.config, componentName: "InflatedSimulation" };
+  }
+  doInitialSimulationRender() {
+    if (this.getInheritedProperty("analogSimulationDisabled")) return;
+    restoreSimulationRecords(this.inflationCtx);
+  }
+};
+function restoreSimulationRecords({
+  injectionDb,
+  subcircuit,
+  groupsMap
+}) {
+  const { db: db2 } = subcircuit.root;
+  const eyes = injectionDb.simulation_eye_diagram.list();
+  const experimentIds = new Set(
+    [
+      ...injectionDb.simulation_ibis_pin_state.list(),
+      ...injectionDb.simulation_digital_stimulus.list(),
+      ...eyes
+    ].map((record) => record.simulation_experiment_id)
+  );
+  const probeIds = new Set(eyes.map((eye) => eye.simulation_voltage_probe_id));
+  const restoredIds = /* @__PURE__ */ new Map();
+  const remapId = (originalId, field) => {
+    const restoredId = restoredIds.get(originalId);
+    if (restoredId) return restoredId;
+    let matchedId;
+    if (field === "subcircuit_id") {
+      const sourceGroup = injectionDb.source_group.list().find((group2) => group2.subcircuit_id === originalId);
+      const group = sourceGroup && groupsMap?.get(sourceGroup.source_group_id);
+      matchedId = group?.getSubcircuit().subcircuit_id ?? void 0;
+    } else if (field === "source_component_id") {
+      const original = injectionDb.source_component.get(originalId);
+      const group = original?.source_group_id ? groupsMap?.get(original.source_group_id) : subcircuit;
+      if (original && group?.source_group_id) {
+        const components = db2.source_component.list({
+          source_group_id: group.source_group_id,
+          name: original.name
+        });
+        if (components.length === 1)
+          matchedId = components[0].source_component_id;
+      }
+    } else if (field.endsWith("source_port_id")) {
+      const original = injectionDb.source_port.get(originalId);
+      if (original?.source_component_id) {
+        const componentId = remapId(
+          original.source_component_id,
+          "source_component_id"
+        );
+        const ports = db2.source_port.list({ source_component_id: componentId }).filter(
+          (port) => original.pin_number !== void 0 ? port.pin_number === original.pin_number : port.name === original.name
+        );
+        if (ports.length === 1) matchedId = ports[0].source_port_id;
+      }
+    } else if (field.endsWith("source_net_id")) {
+      const original = injectionDb.source_net.get(originalId);
+      if (original) {
+        const nets = db2.source_net.list({
+          name: original.name,
+          subcircuit_id: original.subcircuit_id ? remapId(original.subcircuit_id, "subcircuit_id") : subcircuit.subcircuit_id
+        });
+        if (nets.length === 1) matchedId = nets[0].source_net_id;
+      }
+    }
+    if (!matchedId) {
+      throw new Error(
+        `Cannot restore simulation records: unable to remap ${field} safely.`
+      );
+    }
+    restoredIds.set(originalId, matchedId);
+    return matchedId;
+  };
+  const remapReferences = (value, field) => {
+    if (typeof value === "string" && field.endsWith("_id"))
+      return remapId(value, field);
+    if (Array.isArray(value))
+      return value.map((entry) => remapReferences(entry, field));
+    if (value && typeof value === "object") {
+      return Object.fromEntries(
+        Object.entries(value).map(([key, entry]) => [
+          key,
+          remapReferences(
+            entry,
+            field === "ibis_pin_name_to_source_port_id" ? "source_port_id" : key
+          )
+        ])
+      );
+    }
+    return value;
+  };
+  for (const type of simulationTypes) {
+    for (const record of injectionDb[type].list()) {
+      if (record.type === "simulation_experiment" && !experimentIds.has(record.simulation_experiment_id) || record.type === "simulation_voltage_probe" && !probeIds.has(record.simulation_voltage_probe_id))
+        continue;
+      const primaryIdField = `${type}_id`;
+      const fields = Object.fromEntries(
+        Object.entries(record).filter(([key]) => key !== primaryIdField)
+      );
+      const restored = db2.insert(
+        remapReferences(fields, "")
+      );
+      restoredIds.set(getElementId(record), getElementId(restored));
+    }
+  }
+}
+function inflateSimulation(inflationCtx) {
+  if (!ibisSimulationTypes.some(
+    (type) => inflationCtx.injectionDb[type].list().length > 0
+  ))
+    return;
+  inflationCtx.subcircuit.add(new InflatedSimulation(inflationCtx));
+}
+
 // lib/components/normal-components/Capacitor.ts
 import { capacitorProps, resolveManufacturerPartNumber as resolveManufacturerPartNumber4 } from "@tscircuit/props";
 import { formatSiUnit } from "format-si-unit";
@@ -85433,7 +85574,7 @@ var buildPowerPourPolygons = (problem) => {
 var getLayerColor = (layer) => layer === "top" ? "#c2453a" : layer === "bottom" ? "#5b7fd8" : "#c58b43";
 
 // node_modules/@tscircuit/implicit-copper-pour-solver/lib/prepare-circuit-json.ts
-import { getElementId } from "@tscircuit/circuit-json-util";
+import { getElementId as getElementId2 } from "@tscircuit/circuit-json-util";
 import {
   getBoundFromCenteredRect,
   getBoundsFromPoints as getBoundsFromPoints8
@@ -85756,7 +85897,7 @@ var prepareCircuitJson = (input) => {
   );
   const netIndexByConnectivityNetwork = /* @__PURE__ */ new Map();
   const getConnectivityNetIndex = (element) => {
-    const elementId = getElementId(element);
+    const elementId = getElementId2(element);
     const connectivityNetworkId = connectivityMap.getNetConnectedToId(elementId);
     if (connectivityNetworkId) {
       const connectedSourceNetIndexes = sourceNets.flatMap(
@@ -85797,7 +85938,7 @@ var prepareCircuitJson = (input) => {
     }
     const connectivityNetIndex = getConnectivityNetIndex(element);
     if (connectivityNetIndex !== void 0) return connectivityNetIndex;
-    const elementId = getElementId(element);
+    const elementId = getElementId2(element);
     return getOrCreateImplicitNetIndex(
       `${element.type}:${elementId}`,
       elementId
@@ -118479,6 +118620,10 @@ function Group_doInitialSimulationSpiceEngineRender(group) {
       debug12("No simulation experiment found, skipping simulation");
       continue;
     }
+    if (simulationExperiment.spice_engine === "pcb_spice" && (!spiceEngineMap.pcb_spice || isExternalIbisExperiment(root.db, simulationExperimentId))) {
+      debug12("Skipping external pcb_spice experiment during rendering");
+      continue;
+    }
     const simulationScope = analogSimulation.getGroup() ?? group;
     const voltageProbes = simulationScope.selectAll("voltageprobe");
     const ammeters = simulationScope.selectAll("ammeter");
@@ -118687,6 +118832,10 @@ ${simulationRuns.map((simulationRun) => simulationRun.spiceString).join("\n")}`
     });
   }
 }
+function isExternalIbisExperiment(db2, simulationExperimentId) {
+  const belongsToExperiment = (record) => record.simulation_experiment_id === simulationExperimentId;
+  return db2.simulation_ibis_pin_state.list().some(belongsToExperiment) || db2.simulation_digital_stimulus.list().some(belongsToExperiment) || db2.simulation_eye_diagram.list().some(belongsToExperiment);
+}
 
 // lib/components/primitive-components/Group/Group_doInitialSourceAddConnectivityMapKey.ts
 import { ConnectivityMap as ConnectivityMap5 } from "circuit-json-to-connectivity-map";
@@ -119560,7 +119709,7 @@ var RoutingPhasePreparationError = class extends Error {
 var package_default = {
   name: "@tscircuit/core",
   type: "module",
-  version: "0.0.2179",
+  version: "0.0.2180",
   types: "dist/index.d.ts",
   main: "dist/index.js",
   module: "dist/index.js",
@@ -119619,7 +119768,7 @@ var package_default = {
     "@tscircuit/miniflex": "^0.0.4",
     "@tscircuit/modelprinter": "^0.0.18",
     "@tscircuit/ngspice-spice-engine": "^0.0.20",
-    "@tscircuit/props": "^0.0.704",
+    "@tscircuit/props": "^0.0.705",
     "@tscircuit/schematic-match-adapt": "^0.0.18",
     "@tscircuit/schematic-trace-solver": "https://jscdn.tscircuit.com/@tscircuit/schematic-trace-solver/0.0.230.tgz",
     "@tscircuit/solver-utils": "^0.0.16",
@@ -119635,7 +119784,7 @@ var package_default = {
     "bun-match-svg": "0.0.12",
     "calculate-elbow": "^0.0.12",
     "chokidar-cli": "^3.0.0",
-    "circuit-json": "^0.0.528",
+    "circuit-json": "^0.0.529",
     "circuit-json-to-bpc": "^0.0.13",
     "circuit-json-to-connectivity-map": "^0.0.33",
     "circuit-json-to-gltf": "^0.0.151",
@@ -119702,8 +119851,8 @@ var package_default = {
     "jscad-fiber": "^0.0.88"
   },
   overrides: {
-    "@tscircuit/props": "^0.0.704",
-    "circuit-json": "^0.0.528",
+    "@tscircuit/props": "^0.0.705",
+    "circuit-json": "^0.0.529",
     "@tscircuit/cableprinter": "^0.0.6"
   }
 };
@@ -124079,6 +124228,7 @@ var inflateCircuitJson = (target, circuitJson, children) => {
     inflateSourceTrace(sourceTrace, inflationCtx);
   }
   inflateStandalonePcbPrimitives(inflationCtx);
+  inflateSimulation(inflationCtx);
 };
 
 // lib/components/primitive-components/resolve-board-motor-mount.ts
@@ -134097,6 +134247,80 @@ var AnalogAnalysisSimulation = class extends PrimitiveComponent2 {
 
 // lib/components/primitive-components/AnalogTransientSimulation.ts
 import { analogTransientSimulationProps } from "@tscircuit/props";
+
+// lib/utils/simulation/resolveExternalSimulation.ts
+function resolveExternalSimulationPort({
+  declaration,
+  selector
+}) {
+  const ports = declaration.getSubcircuit().selectAll(selector).filter((port2) => port2.componentName === "Port");
+  if (ports.length !== 1 || !ports[0].source_port_id) {
+    throw new Error(
+      `Simulation pin selector "${selector}" must identify exactly one physical source pin.`
+    );
+  }
+  const port = ports[0];
+  if (port.getSubcircuit() !== declaration.getSubcircuit()) {
+    throw new Error(
+      `Simulation pin "${selector}" must belong to the same subcircuit as its declaration.`
+    );
+  }
+  return port;
+}
+function resolveExternalTransientSimulation({
+  declaration,
+  selector
+}) {
+  const simulations = declaration.getSubcircuit().selectAll(selector).filter(
+    (simulation3) => simulation3.componentName === "AnalogTransientSimulation"
+  );
+  if (simulations.length !== 1 || simulations[0].getSubcircuit() !== declaration.getSubcircuit()) {
+    throw new Error(
+      `Simulation selector "${selector}" must identify one transient in the same subcircuit.`
+    );
+  }
+  const simulation2 = simulations[0];
+  if (simulation2.getSpiceEngineName() !== "pcb_spice") {
+    throw new Error(
+      `Simulation "${selector}" requires spiceEngine="pcb_spice" for IBIS declarations.`
+    );
+  }
+  simulation2.getOrCreateSimulationExperiment();
+  return simulation2;
+}
+
+// lib/components/primitive-components/AnalogTransientSimulation_validateIbisBindings.ts
+function AnalogTransientSimulation_validateIbisBindings(simulation2) {
+  if (simulation2.getSpiceEngineName() !== "pcb_spice") return;
+  const subcircuit = simulation2.getSubcircuit();
+  const models = subcircuit.selectAll("ibismodel").filter(
+    (model) => !model.shouldBeRemoved && model.getSubcircuit() === subcircuit
+  ).map(
+    (model) => simulation2.root.db.simulation_ibis_model.get(
+      model.simulation_ibis_model_id
+    )
+  );
+  for (const selector of Object.keys(
+    simulation2._parsedProps.ibisPinStates ?? {}
+  )) {
+    const port = resolveExternalSimulationPort({
+      declaration: simulation2,
+      selector
+    });
+    const bindings = models.filter(
+      (model) => Object.values(model.ibis_pin_name_to_source_port_id).includes(
+        port.source_port_id
+      )
+    );
+    if (bindings.length !== 1) {
+      throw new Error(
+        `Simulation "${simulation2._parsedProps.name ?? "transient"}" pin "${selector}" requires exactly one IBIS model binding in this subcircuit.`
+      );
+    }
+  }
+}
+
+// lib/components/primitive-components/AnalogTransientSimulation.ts
 var AnalogTransientSimulation = class extends AnalogAnalysisSimulation {
   get config() {
     return {
@@ -134104,17 +134328,389 @@ var AnalogTransientSimulation = class extends AnalogAnalysisSimulation {
       zodProps: analogTransientSimulationProps
     };
   }
+  doInitialSimulationSpiceEngineRender() {
+    if (this.getInheritedProperty("analogSimulationDisabled")) return;
+    AnalogTransientSimulation_validateIbisBindings(this);
+  }
+  updateSimulationSpiceEngineRender() {
+    this.doInitialSimulationSpiceEngineRender();
+  }
+  onPropsChange() {
+    this._markDirty("SimulationRender");
+    if (!this.simulation_experiment_id) return;
+    const subcircuit = this.getSubcircuit();
+    for (const declaration of [
+      ...subcircuit.selectAll("analogdigitalstimulus"),
+      ...subcircuit.selectAll("analogeyediagram")
+    ]) {
+      if (declaration.getSubcircuit() === subcircuit)
+        declaration._markDirty("SimulationSpiceEngineRender");
+    }
+  }
+  updateSimulationRender() {
+    this.insertSimulationExperiment();
+  }
+  removeIbisPinStates() {
+    for (const state of this.root.db.simulation_ibis_pin_state.list({
+      simulation_experiment_id: this.simulation_experiment_id
+    })) {
+      this.root.db.simulation_ibis_pin_state.delete(
+        state.simulation_ibis_pin_state_id
+      );
+    }
+  }
+  removeSimulationRender() {
+    if (!this.simulation_experiment_id) return;
+    this.removeIbisPinStates();
+    this.root.db.simulation_experiment.delete(this.simulation_experiment_id);
+    this.simulation_experiment_id = null;
+  }
   insertSimulationExperiment() {
     const { db: db2 } = this.root;
     const { duration, name, startTime, timePerStep, spiceOptions } = this._parsedProps;
-    return db2.simulation_experiment.insert({
+    const ibisPinStates = this.getInheritedProperty("analogSimulationDisabled") ? {} : this._parsedProps.ibisPinStates;
+    const pins = Object.entries(ibisPinStates ?? {}).map(
+      ([selector, state]) => {
+        const pin = {
+          source_port_id: resolveExternalSimulationPort({
+            declaration: this,
+            selector
+          }).source_port_id,
+          is_output: state.isOutput
+        };
+        if (state.isOutput)
+          return { ...pin, is_output_enabled: state.isOutputEnabled };
+        return pin;
+      }
+    );
+    if (new Set(pins.map((pin) => pin.source_port_id)).size !== pins.length) {
+      throw new Error(
+        `Simulation "${name ?? "transient"}" assigns multiple states to the same physical pin.`
+      );
+    }
+    const experimentProps = {
       name: name ?? "spice_transient_analysis",
       experiment_type: "spice_transient_analysis",
       end_time_ms: duration,
       start_time_ms: startTime,
       time_per_step: timePerStep,
-      spice_options: spiceOptions
-    });
+      spice_options: spiceOptions,
+      spice_engine: this.getSpiceEngineName(),
+      subcircuit_id: this.getSubcircuit().subcircuit_id
+    };
+    const experiment = this.simulation_experiment_id ? db2.simulation_experiment.update(
+      this.simulation_experiment_id,
+      experimentProps
+    ) : db2.simulation_experiment.insert(experimentProps);
+    if (this.simulation_experiment_id) this.removeIbisPinStates();
+    for (const pin of pins) {
+      db2.simulation_ibis_pin_state.insert({
+        simulation_experiment_id: experiment.simulation_experiment_id,
+        ...pin
+      });
+    }
+    return experiment;
+  }
+};
+
+// lib/components/primitive-components/AnalogDigitalStimulus.ts
+import { analogDigitalStimulusProps } from "@tscircuit/props";
+
+// lib/components/primitive-components/AnalogDigitalStimulus_getSimulationDigitalStimulus.ts
+function AnalogDigitalStimulus_getSimulationDigitalStimulus(declaration) {
+  const props = declaration._parsedProps;
+  const simulation2 = resolveExternalTransientSimulation({
+    declaration,
+    selector: props.simulationRef
+  });
+  const port = resolveExternalSimulationPort({
+    declaration,
+    selector: props.sourcePinRef
+  });
+  const experiment = simulation2.getOrCreateSimulationExperiment();
+  if (props.startTime >= experiment.end_time_ms)
+    throw new Error(`Stimulus "${props.name}" starts outside its simulation.`);
+  const pinState = declaration.root.db.simulation_ibis_pin_state.list({
+    simulation_experiment_id: experiment.simulation_experiment_id
+  }).find((state) => state.source_port_id === port.source_port_id);
+  if (pinState?.is_output !== true || pinState.is_output_enabled !== true) {
+    throw new Error(
+      `Stimulus "${props.name}" must drive a pin declared as an enabled output in its simulation.`
+    );
+  }
+  if (declaration.root.db.simulation_digital_stimulus.list({
+    simulation_experiment_id: experiment.simulation_experiment_id
+  }).some(
+    (stimulus) => stimulus.simulation_digital_stimulus_id !== declaration.simulation_digital_stimulus_id && (stimulus.source_port_id === port.source_port_id || stimulus.name === props.name)
+  )) {
+    throw new Error(
+      `Stimulus "${props.name}" duplicates a driven pin or stimulus name in this simulation.`
+    );
+  }
+  return {
+    type: "simulation_digital_stimulus",
+    name: props.name,
+    simulation_experiment_id: experiment.simulation_experiment_id,
+    source_port_id: port.source_port_id,
+    bit_duration_ms: props.bitDuration,
+    start_time_ms: props.startTime,
+    initial_state: props.initialState,
+    inverted: props.inverted,
+    transmission_pattern: {
+      transmission_type: props.transmittedData.transmissionType,
+      bits: props.transmittedData.bits,
+      repeat: props.transmittedData.repeat
+    }
+  };
+}
+
+// lib/components/primitive-components/AnalogDigitalStimulus.ts
+var AnalogDigitalStimulus = class extends PrimitiveComponent2 {
+  simulation_digital_stimulus_id = null;
+  get config() {
+    return {
+      componentName: "AnalogDigitalStimulus",
+      zodProps: analogDigitalStimulusProps
+    };
+  }
+  doInitialSimulationRender() {
+    if (this.getInheritedProperty("analogSimulationDisabled")) return;
+    const stimulus = AnalogDigitalStimulus_getSimulationDigitalStimulus(this);
+    if (this.simulation_digital_stimulus_id)
+      this.root.db.simulation_digital_stimulus.update(
+        this.simulation_digital_stimulus_id,
+        stimulus
+      );
+    else
+      this.simulation_digital_stimulus_id = this.root.db.simulation_digital_stimulus.insert(
+        stimulus
+      ).simulation_digital_stimulus_id;
+  }
+  onPropsChange() {
+    this._markDirty("SimulationSpiceEngineRender");
+  }
+  // Refresh traffic after every experiment has updated its pin states.
+  updateSimulationSpiceEngineRender() {
+    this.doInitialSimulationRender();
+  }
+  removeSimulationRender() {
+    if (this.simulation_digital_stimulus_id)
+      this.root.db.simulation_digital_stimulus.delete(
+        this.simulation_digital_stimulus_id
+      );
+    this.simulation_digital_stimulus_id = null;
+  }
+};
+
+// lib/components/primitive-components/AnalogEyeDiagram.ts
+import { analogEyeDiagramProps } from "@tscircuit/props";
+
+// lib/components/primitive-components/AnalogEyeDiagram_getSimulationEyeDiagram.ts
+function AnalogEyeDiagram_getSimulationEyeDiagram(declaration) {
+  const props = declaration._parsedProps;
+  const simulation2 = resolveExternalTransientSimulation({
+    declaration,
+    selector: props.simulationRef
+  });
+  const experiment = simulation2.getOrCreateSimulationExperiment();
+  const probes = declaration.getSubcircuit().selectAll(props.probeRef).filter((probe2) => probe2.componentName === "VoltageProbe");
+  if (probes.length !== 1 || probes[0].getSubcircuit() !== declaration.getSubcircuit()) {
+    throw new Error(
+      `Eye probe selector "${props.probeRef}" must identify one voltage probe in this subcircuit.`
+    );
+  }
+  const probe = probes[0];
+  if (!probe.simulation_voltage_probe_id) {
+    throw new Error(
+      `Eye probe "${props.probeRef}" did not render a voltage probe.`
+    );
+  }
+  const start = props.startTime ?? experiment.start_time_ms ?? 0, end = props.endTime ?? experiment.end_time_ms;
+  const firstBoundary = (start - props.timeOrigin) / props.unitInterval + 0.5;
+  const lastBoundary = (end - props.timeOrigin) / props.unitInterval - 1.5;
+  const roundingTolerance = 8 * Number.EPSILON * Math.max(1, Math.abs(firstBoundary), Math.abs(lastBoundary));
+  if (start < (experiment.start_time_ms ?? 0) || end > experiment.end_time_ms || end <= start || Math.ceil(firstBoundary - roundingTolerance) > Math.floor(lastBoundary + roundingTolerance)) {
+    throw new Error(
+      `Eye "${props.name}" needs a gate within its simulation containing at least two bit intervals forming a complete two-UI eye window aligned to timeOrigin after recording starts.`
+    );
+  }
+  return {
+    type: "simulation_eye_diagram",
+    name: props.name,
+    simulation_experiment_id: experiment.simulation_experiment_id,
+    simulation_voltage_probe_id: probe.simulation_voltage_probe_id,
+    unit_interval_ms: props.unitInterval,
+    time_origin_ms: props.timeOrigin,
+    start_time_ms: start,
+    end_time_ms: end
+  };
+}
+
+// lib/components/primitive-components/AnalogEyeDiagram.ts
+var AnalogEyeDiagram = class extends PrimitiveComponent2 {
+  simulation_eye_diagram_id = null;
+  get config() {
+    return {
+      componentName: "AnalogEyeDiagram",
+      zodProps: analogEyeDiagramProps
+    };
+  }
+  // Probes have finished SimulationRender before this phase, independent of JSX order.
+  doInitialSimulationSpiceEngineRender() {
+    if (this.getInheritedProperty("analogSimulationDisabled")) return;
+    const eye = AnalogEyeDiagram_getSimulationEyeDiagram(this);
+    if (this.simulation_eye_diagram_id)
+      this.root.db.simulation_eye_diagram.update(
+        this.simulation_eye_diagram_id,
+        eye
+      );
+    else
+      this.simulation_eye_diagram_id = this.root.db.simulation_eye_diagram.insert(
+        eye
+      ).simulation_eye_diagram_id;
+  }
+  onPropsChange() {
+    this._markDirty("SimulationSpiceEngineRender");
+  }
+  updateSimulationSpiceEngineRender() {
+    this.doInitialSimulationSpiceEngineRender();
+  }
+  removeSimulationSpiceEngineRender() {
+    if (this.simulation_eye_diagram_id)
+      this.root.db.simulation_eye_diagram.delete(
+        this.simulation_eye_diagram_id
+      );
+    this.simulation_eye_diagram_id = null;
+  }
+};
+
+// lib/components/primitive-components/IbisModel.ts
+import { ibisModelProps } from "@tscircuit/props";
+
+// lib/components/primitive-components/IbisModel_getSimulationIbisModel.ts
+function IbisModel_getSimulationIbisModel(declaration) {
+  const props = declaration._parsedProps;
+  const chips = declaration.getSubcircuit().selectAll(props.componentRef).filter((chip2) => chip2.source_component_id);
+  if (chips.length !== 1 || chips[0].getSubcircuit() !== declaration.getSubcircuit()) {
+    throw new Error(
+      `IBIS component selector "${props.componentRef}" must identify one component in this subcircuit.`
+    );
+  }
+  const chip = chips[0];
+  if (declaration.root.db.simulation_ibis_model.list({
+    source_component_id: chip.source_component_id
+  }).some(
+    (model) => model.simulation_ibis_model_id !== declaration.simulation_ibis_model_id
+  )) {
+    throw new Error(
+      `Component "${props.componentRef}" already has an IBIS model.`
+    );
+  }
+  const pinMap = Object.fromEntries(
+    Object.entries(props.ibisPinNameToPortLabel).map(([pin, label]) => [
+      pin,
+      resolveExternalSimulationPort({
+        declaration,
+        selector: `${props.componentRef} > .${label}`
+      }).source_port_id
+    ])
+  );
+  const ibisPinNameBySourcePortId = /* @__PURE__ */ new Map();
+  for (const [pin, sourcePortId] of Object.entries(pinMap)) {
+    const previousPin = ibisPinNameBySourcePortId.get(sourcePortId);
+    if (previousPin !== void 0) {
+      throw new Error(
+        `IBIS pins "${previousPin}" and "${pin}" on "${props.componentRef}" resolve to the same physical pin.`
+      );
+    }
+    ibisPinNameBySourcePortId.set(sourcePortId, pin);
+  }
+  for (const pin of [
+    ...Object.keys(props.ibisPinNameToReferencePortLabels ?? {}),
+    ...Object.keys(props.ibisPinNameToModelName ?? {})
+  ]) {
+    if (!Object.hasOwn(props.ibisPinNameToPortLabel, pin)) {
+      throw new Error(
+        `IBIS pin "${pin}" is referenced but not present in ibisPinNameToPortLabel.`
+      );
+    }
+  }
+  let references;
+  if (props.ibisPinNameToReferencePortLabels) {
+    references = {};
+    for (const [pin, pinReferences] of Object.entries(
+      props.ibisPinNameToReferencePortLabels
+    )) {
+      references[pin] = {};
+      for (const [role, sourcePortIdField] of [
+        ["pullup", "pullup_reference_source_port_id"],
+        ["pulldown", "pulldown_reference_source_port_id"],
+        ["powerClamp", "power_clamp_reference_source_port_id"],
+        ["groundClamp", "ground_clamp_reference_source_port_id"],
+        ["external", "external_reference_source_port_id"]
+      ]) {
+        const label = pinReferences[role];
+        if (label === void 0) continue;
+        references[pin][sourcePortIdField] = resolveExternalSimulationPort({
+          declaration,
+          selector: `${props.componentRef} > .${label}`
+        }).source_port_id;
+      }
+    }
+  }
+  return {
+    type: "simulation_ibis_model",
+    source_component_id: chip.source_component_id,
+    ibis_model_asset: props.ibisModelAsset,
+    ibis_component_name: props.ibisComponentName,
+    model_value_corner: props.modelValueCorner,
+    include_package_parasitics: props.includePackageParasitics,
+    ibis_pin_name_to_model_name: props.ibisPinNameToModelName,
+    ibis_pin_name_to_source_port_id: pinMap,
+    ibis_pin_name_to_reference_source_port_ids: references
+  };
+}
+
+// lib/components/primitive-components/IbisModel.ts
+var IbisModel = class extends PrimitiveComponent2 {
+  simulation_ibis_model_id = null;
+  get config() {
+    return { componentName: "IbisModel", zodProps: ibisModelProps };
+  }
+  onPropsChange() {
+    this._markDirty("SimulationRender");
+  }
+  markIbisBindingsDirty() {
+    const subcircuit = this.getSubcircuit();
+    for (const simulation2 of subcircuit.selectAll(
+      "analogtransientsimulation"
+    )) {
+      if (simulation2.getSubcircuit() === subcircuit)
+        simulation2._markDirty("SimulationSpiceEngineRender");
+    }
+  }
+  doInitialSimulationRender() {
+    if (this.getInheritedProperty("analogSimulationDisabled")) return;
+    const model = IbisModel_getSimulationIbisModel(this);
+    if (this.simulation_ibis_model_id)
+      this.root.db.simulation_ibis_model.update(
+        this.simulation_ibis_model_id,
+        model
+      );
+    else
+      this.simulation_ibis_model_id = this.root.db.simulation_ibis_model.insert(
+        model
+      ).simulation_ibis_model_id;
+    this.markIbisBindingsDirty();
+  }
+  updateSimulationRender() {
+    this.doInitialSimulationRender();
+  }
+  removeSimulationRender() {
+    if (this.simulation_ibis_model_id)
+      this.root.db.simulation_ibis_model.delete(this.simulation_ibis_model_id);
+    this.simulation_ibis_model_id = null;
+    this.markIbisBindingsDirty();
   }
 };
 
@@ -136050,6 +136646,10 @@ var createNamespacedElement = (hostType) => {
 
 // lib/namespaced-elements/analog.ts
 var analog = {
+  digitalstimulus: createNamespacedElement(
+    "analogdigitalstimulus"
+  ),
+  eyediagram: createNamespacedElement("analogeyediagram"),
   transientsimulation: createNamespacedElement(
     "analogtransientsimulation"
   ),
@@ -136359,6 +136959,8 @@ export {
   AnalogAnalysisSimulation,
   AnalogDcOperatingPointSimulation,
   AnalogDcSweepSimulation,
+  AnalogDigitalStimulus,
+  AnalogEyeDiagram,
   AnalogSimulation,
   AnalogSweepParameter,
   AnalogTransientSimulation,
@@ -136408,6 +137010,7 @@ export {
   Fuse,
   Group5 as Group,
   Hole,
+  IbisModel,
   Inductor,
   Interconnect,
   IsolatedCircuit,