@tscircuit/core 0.0.1503 → 0.0.1505

package/dist/index.js

@@ -8,7 +8,13 @@ var __export = (target, all) => {
 var components_exports = {};
 __export(components_exports, {
   Ammeter: () => Ammeter,
+  AnalogAcSweepSimulation: () => AnalogAcSweepSimulation,
+  AnalogAnalysisSimulation: () => AnalogAnalysisSimulation,
+  AnalogDcOperatingPointSimulation: () => AnalogDcOperatingPointSimulation,
+  AnalogDcSweepSimulation: () => AnalogDcSweepSimulation,
   AnalogSimulation: () => AnalogSimulation,
+  AnalogSweepParameter: () => AnalogSweepParameter,
+  AnalogTransientSimulation: () => AnalogTransientSimulation,
   AutoroutingPhase: () => AutoroutingPhase,
   Battery: () => Battery,
   Board: () => Board,
@@ -22666,7 +22672,6 @@ var Group_doInitialSchematicTraceRender = (group) => {
 };
 
 // lib/components/primitive-components/Group/Group_doInitialSimulationSpiceEngineRender.ts
-import { circuitJsonToSpice } from "circuit-json-to-spice";
 import Debug13 from "debug";
 
 // lib/utils/simulation/get-transient-voltage-graph-names-from-spice-netlist.ts
@@ -22739,6 +22744,176 @@ var getSpiceyEngine = () => {
   };
 };
 
+// lib/components/primitive-components/Group/isCurrentGraph.ts
+var isCurrentGraph = (element) => element.type === "simulation_transient_current_graph";
+
+// lib/components/primitive-components/Group/isSimulationCurrentResult.ts
+var isSimulationCurrentResult = (circuitElement) => circuitElement.type === "simulation_dc_operating_point_current" || circuitElement.type === "simulation_dc_sweep_current_graph" || circuitElement.type === "simulation_ac_sweep_current_graph";
+
+// lib/components/primitive-components/Group/isSimulationVoltageResult.ts
+var isSimulationVoltageResult = (circuitElement) => circuitElement.type === "simulation_dc_operating_point_voltage" || circuitElement.type === "simulation_dc_sweep_voltage_graph" || circuitElement.type === "simulation_ac_sweep_voltage_graph";
+
+// lib/components/primitive-components/Group/isVoltageGraph.ts
+var isVoltageGraph = (element) => element.type === "simulation_transient_voltage_graph";
+
+// lib/components/primitive-components/Group/isSimulationAnalysisResult.ts
+var isSimulationAnalysisResult = (circuitElement) => isVoltageGraph(circuitElement) || isCurrentGraph(circuitElement) || isSimulationVoltageResult(circuitElement) || isSimulationCurrentResult(circuitElement);
+
+// lib/components/primitive-components/Group/attachSweepCoordinateToSimulationResult.ts
+var attachSweepCoordinateToSimulationResult = ({
+  simulationResult,
+  simulationParameterSweepCoordinate
+}) => {
+  if (!simulationParameterSweepCoordinate || !isSimulationAnalysisResult(simulationResult)) {
+    return simulationResult;
+  }
+  const simulationResultWithSweepCoordinate = { ...simulationResult };
+  const simulationResultIdKey = `${simulationResultWithSweepCoordinate.type}_id`;
+  Reflect.deleteProperty(
+    simulationResultWithSweepCoordinate,
+    simulationResultIdKey
+  );
+  simulationResultWithSweepCoordinate.simulation_parameter_sweep_coordinate = simulationParameterSweepCoordinate;
+  return simulationResultWithSweepCoordinate;
+};
+
+// lib/components/primitive-components/Group/createSimulationRuns.ts
+import { circuitJsonToSpice } from "circuit-json-to-spice";
+
+// lib/components/primitive-components/Group/applyParameterSweepCoordinate.ts
+var getSourceComponentOrThrow = ({
+  circuitJson,
+  sourceComponentId,
+  isMatchingSourceComponent
+}) => {
+  const sourceComponent = circuitJson.find(
+    (circuitElement) => isMatchingSourceComponent(circuitElement) && circuitElement.source_component_id === sourceComponentId
+  );
+  if (!sourceComponent) {
+    throw new Error(`Parameter sweep target ${sourceComponentId} was not found`);
+  }
+  return sourceComponent;
+};
+var applyParameterSweepCoordinate = ({
+  circuitJson,
+  parameterSweep,
+  simulationParameterSweepCoordinate
+}) => {
+  const sweptCircuitJson = structuredClone(circuitJson);
+  const parameterValue = simulationParameterSweepCoordinate.parameter_value;
+  if (parameterSweep.parameter_type === "resistance") {
+    const resistor = getSourceComponentOrThrow({
+      circuitJson: sweptCircuitJson,
+      sourceComponentId: parameterSweep.resistor_source_component_id,
+      isMatchingSourceComponent: (circuitElement) => circuitElement.type === "source_component" && circuitElement.ftype === "simple_resistor"
+    });
+    resistor.resistance = parameterValue;
+    return sweptCircuitJson;
+  }
+  if (parameterSweep.parameter_type === "capacitance") {
+    const capacitor = getSourceComponentOrThrow({
+      circuitJson: sweptCircuitJson,
+      sourceComponentId: parameterSweep.capacitor_source_component_id,
+      isMatchingSourceComponent: (circuitElement) => circuitElement.type === "source_component" && circuitElement.ftype === "simple_capacitor"
+    });
+    capacitor.capacitance = parameterValue;
+    return sweptCircuitJson;
+  }
+  if (parameterSweep.parameter_type === "inductance") {
+    const inductor = getSourceComponentOrThrow({
+      circuitJson: sweptCircuitJson,
+      sourceComponentId: parameterSweep.inductor_source_component_id,
+      isMatchingSourceComponent: (circuitElement) => circuitElement.type === "source_component" && circuitElement.ftype === "simple_inductor"
+    });
+    inductor.inductance = parameterValue;
+    return sweptCircuitJson;
+  }
+  if (parameterSweep.parameter_type === "voltage") {
+    const groundNet = sweptCircuitJson.find(
+      (circuitElement) => circuitElement.type === "source_net" && circuitElement.name.toUpperCase() === "GND"
+    );
+    if (!groundNet || groundNet.type !== "source_net") {
+      throw new Error("A voltage parameter sweep requires a GND net");
+    }
+    const sweepVoltageSource = {
+      type: "simulation_voltage_source",
+      simulation_voltage_source_id: `simulation_voltage_source_${simulationParameterSweepCoordinate.simulation_parameter_sweep_id}_${simulationParameterSweepCoordinate.sweep_index}`,
+      is_dc_source: true,
+      positive_source_net_id: parameterSweep.source_net_id,
+      negative_source_net_id: groundNet.source_net_id,
+      voltage: parameterValue
+    };
+    sweptCircuitJson.push(sweepVoltageSource);
+    return sweptCircuitJson;
+  }
+  if (parameterSweep.parameter_type === "current") {
+    const currentSourcePortIds = new Set(
+      sweptCircuitJson.filter(
+        (circuitElement) => circuitElement.type === "source_port" && circuitElement.source_component_id === parameterSweep.current_source_component_id
+      ).map((sourcePort) => sourcePort.source_port_id)
+    );
+    const currentSource = sweptCircuitJson.find(
+      (circuitElement) => circuitElement.type === "simulation_current_source" && (circuitElement.is_dc_source ? Boolean(
+        circuitElement.positive_source_port_id && currentSourcePortIds.has(
+          circuitElement.positive_source_port_id
+        )
+      ) : Boolean(
+        circuitElement.terminal1_source_port_id && currentSourcePortIds.has(
+          circuitElement.terminal1_source_port_id
+        )
+      ))
+    );
+    if (!currentSource) {
+      throw new Error(
+        `Current sweep target ${parameterSweep.current_source_component_id} has no simulation source`
+      );
+    }
+    currentSource.current = parameterValue;
+    return sweptCircuitJson;
+  }
+  throw new Error("Parameter sweep target is incomplete");
+};
+
+// lib/components/primitive-components/Group/createSimulationRuns.ts
+var createSimulationRun = ({
+  circuitJson,
+  simulationParameterSweepCoordinate
+}) => {
+  const spiceNetlist = circuitJsonToSpice(circuitJson);
+  return {
+    spiceNetlist,
+    spiceString: spiceNetlist.toSpiceString(),
+    simulationParameterSweepCoordinate
+  };
+};
+var createSimulationRuns = ({
+  circuitJson,
+  simulationExperimentId
+}) => {
+  const parameterSweep = circuitJson.find(
+    (circuitElement) => circuitElement.type === "simulation_parameter_sweep" && circuitElement.simulation_experiment_id === simulationExperimentId
+  );
+  if (!parameterSweep) {
+    return [createSimulationRun({ circuitJson })];
+  }
+  return parameterSweep.parameter_values.map((parameterValue, sweepIndex) => {
+    const simulationParameterSweepCoordinate = {
+      simulation_parameter_sweep_id: parameterSweep.simulation_parameter_sweep_id,
+      sweep_index: sweepIndex,
+      parameter_value: parameterValue,
+      parameter_unit: parameterSweep.parameter_unit
+    };
+    return createSimulationRun({
+      circuitJson: applyParameterSweepCoordinate({
+        circuitJson,
+        parameterSweep,
+        simulationParameterSweepCoordinate
+      }),
+      simulationParameterSweepCoordinate
+    });
+  });
+};
+
 // lib/utils/simulation/parseSimulationGraphValue.ts
 var SI_PREFIX_MULTIPLIERS = {
   p: 1e-12,
@@ -22905,12 +23080,6 @@ var insertIndependentAxisScopeTraces = ({
 // lib/components/primitive-components/Group/isCircuitElementInput.ts
 var isCircuitElementInput = (element) => Boolean(element && typeof element === "object" && "type" in element);
 
-// lib/components/primitive-components/Group/isCurrentGraph.ts
-var isCurrentGraph = (element) => element.type === "simulation_transient_current_graph";
-
-// lib/components/primitive-components/Group/isVoltageGraph.ts
-var isVoltageGraph = (element) => element.type === "simulation_transient_voltage_graph";
-
 // lib/components/primitive-components/Group/Group_doInitialSimulationSpiceEngineRender.ts
 var debug11 = Debug13("tscircuit:core:Group_doInitialSimulationSpiceEngineRender");
 var getCircuitJsonForAnalogSimulation = ({
@@ -22920,10 +23089,14 @@ var getCircuitJsonForAnalogSimulation = ({
   ammeters
 }) => {
   const voltageProbeIds = new Set(
-    voltageProbes.map((probe) => probe.simulation_voltage_probe_id).filter((id) => Boolean(id))
+    voltageProbes.map((voltageProbe) => voltageProbe.simulation_voltage_probe_id).filter(
+      (simulationVoltageProbeId) => Boolean(simulationVoltageProbeId)
+    )
   );
   const currentProbeIds = new Set(
-    ammeters.map((ammeter) => ammeter.simulation_current_probe_id).filter((id) => Boolean(id))
+    ammeters.map((ammeter) => ammeter.simulation_current_probe_id).filter(
+      (simulationCurrentProbeId) => Boolean(simulationCurrentProbeId)
+    )
   );
   return circuitJson.filter((element) => {
     if (element.type === "simulation_experiment") {
@@ -22935,6 +23108,9 @@ var getCircuitJsonForAnalogSimulation = ({
     if (element.type === "simulation_current_probe") {
       return currentProbeIds.has(element.simulation_current_probe_id);
     }
+    if (element.type === "simulation_parameter_sweep") {
+      return element.simulation_experiment_id === simulationExperimentId;
+    }
     if (element.type === "simulation_oscilloscope_trace") {
       if (element.simulation_voltage_probe_id) {
         return voltageProbeIds.has(element.simulation_voltage_probe_id);
@@ -22943,7 +23119,7 @@ var getCircuitJsonForAnalogSimulation = ({
         return currentProbeIds.has(element.simulation_current_probe_id);
       }
     }
-    if (element.type === "simulation_transient_voltage_graph" || element.type === "simulation_transient_current_graph" || element.type === "simulation_unknown_experiment_error") {
+    if (element.type === "simulation_transient_voltage_graph" || element.type === "simulation_transient_current_graph" || element.type === "simulation_dc_operating_point_voltage" || element.type === "simulation_dc_operating_point_current" || element.type === "simulation_dc_sweep_voltage_graph" || element.type === "simulation_dc_sweep_current_graph" || element.type === "simulation_ac_sweep_voltage_graph" || element.type === "simulation_ac_sweep_current_graph" || element.type === "simulation_unknown_experiment_error") {
       return false;
     }
     return true;
@@ -22953,15 +23129,23 @@ function Group_doInitialSimulationSpiceEngineRender(group) {
   if (!group.isSubcircuit) return;
   const { root } = group;
   if (!root) return;
-  const analogSims = group.selectAll("analogsimulation");
-  if (analogSims.length === 0) return;
+  const analogSimulations = [
+    ...group.selectAll("analogsimulation"),
+    ...group.selectAll("analogtransientsimulation"),
+    ...group.selectAll(
+      "analogdcoperatingpointsimulation"
+    ),
+    ...group.selectAll("analogdcsweepsimulation"),
+    ...group.selectAll("analogacsweepsimulation")
+  ];
+  if (analogSimulations.length === 0) return;
   resetSimulationColorState();
   const spiceEngineMap = { ...root.platform?.spiceEngineMap };
   if (!spiceEngineMap.spicey) {
     spiceEngineMap.spicey = getSpiceyEngine();
   }
-  for (const analogSim of analogSims) {
-    const simulationExperimentId = analogSim.simulation_experiment_id;
+  for (const analogSimulation of analogSimulations) {
+    const simulationExperimentId = analogSimulation.simulation_experiment_id;
     if (!simulationExperimentId) {
       debug11("No simulation experiment id found, skipping simulation");
       continue;
@@ -22973,7 +23157,7 @@ function Group_doInitialSimulationSpiceEngineRender(group) {
       debug11("No simulation experiment found, skipping simulation");
       continue;
     }
-    const simulationScope = analogSim.getGroup() ?? group;
+    const simulationScope = analogSimulation.getGroup() ?? group;
     const voltageProbes = simulationScope.selectAll("voltageprobe");
     const ammeters = simulationScope.selectAll("ammeter");
     const circuitJson = getCircuitJsonForAnalogSimulation({
@@ -22982,13 +23166,16 @@ function Group_doInitialSimulationSpiceEngineRender(group) {
       voltageProbes,
       ammeters
     });
-    let spiceString;
-    let spiceNetlist;
+    let simulationRuns;
     try {
-      spiceNetlist = circuitJsonToSpice(circuitJson);
-      spiceString = spiceNetlist.toSpiceString();
-      debug11(`Generated SPICE string:
-${spiceString}`);
+      simulationRuns = createSimulationRuns({
+        circuitJson,
+        simulationExperimentId
+      });
+      debug11(
+        `Generated ${simulationRuns.length} SPICE run(s):
+${simulationRuns.map((simulationRun) => simulationRun.spiceString).join("\n")}`
+      );
     } catch (error) {
       debug11(`Failed to convert circuit JSON to SPICE: ${error}`);
       root.db.simulation_unknown_experiment_error.insert({
@@ -22998,15 +23185,15 @@ ${spiceString}`);
       });
       continue;
     }
-    const graphNameToProbe = /* @__PURE__ */ new Map();
-    const voltageProbesById = /* @__PURE__ */ new Map();
+    const voltageProbeByGraphName = /* @__PURE__ */ new Map();
+    const voltageProbeById = /* @__PURE__ */ new Map();
     const graphDisplayOverridesByProbeId = /* @__PURE__ */ new Map();
     for (const probe of voltageProbes) {
       if (probe.finalProbeName) {
-        graphNameToProbe.set(probe.finalProbeName, probe);
+        voltageProbeByGraphName.set(probe.finalProbeName, probe);
       }
       if (probe.simulation_voltage_probe_id) {
-        voltageProbesById.set(probe.simulation_voltage_probe_id, probe);
+        voltageProbeById.set(probe.simulation_voltage_probe_id, probe);
         graphDisplayOverridesByProbeId.set(
           probe.simulation_voltage_probe_id,
           getVoltageProbeGraphDisplayOverrides(probe)
@@ -23022,33 +23209,36 @@ ${spiceString}`);
       }
     }
     const scopedCurrentProbeIds = new Set(
-      ammeters.map((ammeter) => ammeter.simulation_current_probe_id).filter((id) => Boolean(id))
+      ammeters.map((ammeter) => ammeter.simulation_current_probe_id).filter(
+        (simulationCurrentProbeId) => Boolean(simulationCurrentProbeId)
+      )
     );
-    const currentProbesById = /* @__PURE__ */ new Map();
-    const currentProbesByName = /* @__PURE__ */ new Map();
+    const currentProbeById = /* @__PURE__ */ new Map();
+    const currentProbeByName = /* @__PURE__ */ new Map();
     for (const probe of root.db.simulation_current_probe.list().filter(
       (probe2) => scopedCurrentProbeIds.has(probe2.simulation_current_probe_id)
     )) {
-      currentProbesById.set(probe.simulation_current_probe_id, probe);
+      currentProbeById.set(probe.simulation_current_probe_id, probe);
       if (probe.name !== void 0) {
-        currentProbesByName.set(probe.name, probe);
+        currentProbeByName.set(probe.name, probe);
       }
     }
     const orderedSimulationProbes = root.db.simulation_voltage_probe.list().filter(
-      (probe) => voltageProbesById.has(probe.simulation_voltage_probe_id)
+      (probe) => voltageProbeById.has(probe.simulation_voltage_probe_id)
     );
-    const graphNamesFromNetlist = getTransientVoltageGraphNamesFromSpiceNetlist(spiceNetlist);
+    const firstSpiceNetlist = simulationRuns[0]?.spiceNetlist;
+    const graphNamesFromNetlist = firstSpiceNetlist ? getTransientVoltageGraphNamesFromSpiceNetlist(firstSpiceNetlist) : [];
     if (graphNamesFromNetlist.length === orderedSimulationProbes.length) {
       for (const [
-        index,
+        simulationProbeIndex,
         simulationProbe
       ] of orderedSimulationProbes.entries()) {
-        const probe = voltageProbesById.get(
+        const probe = voltageProbeById.get(
           simulationProbe.simulation_voltage_probe_id
         );
-        const graphName = graphNamesFromNetlist[index];
+        const graphName = graphNamesFromNetlist[simulationProbeIndex];
         if (probe && graphName) {
-          graphNameToProbe.set(graphName, probe);
+          voltageProbeByGraphName.set(graphName, probe);
         }
       }
     } else {
@@ -23056,12 +23246,14 @@ ${spiceString}`);
         `Skipping probe-to-graph order mapping because counts differ: probes=${orderedSimulationProbes.length} graphNames=${graphNamesFromNetlist.length}`
       );
     }
-    const engineName = analogSim._parsedProps.spiceEngine ?? "spicey";
+    const engineName = analogSimulation.getSpiceEngineName() ?? "spicey";
     const spiceEngine = spiceEngineMap[engineName];
     if (!spiceEngine) {
       throw new Error(
         `SPICE engine "${engineName}" not found in platform config. Available engines: ${JSON.stringify(
-          Object.keys(spiceEngineMap).filter((k) => k !== "spicey")
+          Object.keys(spiceEngineMap).filter(
+            (spiceEngineName) => spiceEngineName !== "spicey"
+          )
         )}`
       );
     }
@@ -23071,51 +23263,90 @@ ${spiceString}`);
     );
     group._queueAsyncEffect(effectId, async () => {
       try {
-        debug11(`Running simulation with engine: ${engineName}`);
-        const result = await spiceEngine.simulate(spiceString);
-        debug11(
-          `Simulation completed, received ${result.simulationResultCircuitJson.length} elements`
-        );
         const insertedVoltageGraphs = [];
         const insertedCurrentGraphs = [];
-        for (const rawElement of result.simulationResultCircuitJson) {
-          if (!isCircuitElementInput(rawElement)) {
-            debug11("Skipping invalid simulation result element");
-            continue;
-          }
-          const element = rawElement;
-          if (isVoltageGraph(element)) {
-            element.simulation_experiment_id = simulationExperiment.simulation_experiment_id;
-            const probeMatch = element.name ? graphNameToProbe.get(element.name) : void 0;
-            if (probeMatch) {
-              element.color = probeMatch.color ?? void 0;
-              element.source_probe_id = probeMatch.simulation_voltage_probe_id ?? void 0;
-            }
-          }
-          if (isCurrentGraph(element)) {
-            element.simulation_experiment_id = simulationExperiment.simulation_experiment_id;
-            const probeMatch = (element.source_probe_id ? currentProbesById.get(element.source_probe_id) : void 0) ?? (element.name ? currentProbesByName.get(element.name) : void 0);
-            if (probeMatch) {
-              element.color = probeMatch.color;
-              element.source_probe_id = probeMatch.simulation_current_probe_id;
+        for (const simulationRun of simulationRuns) {
+          debug11(`Running simulation with engine: ${engineName}`);
+          const simulationResult = await spiceEngine.simulate(
+            simulationRun.spiceString
+          );
+          debug11(
+            `Simulation completed, received ${simulationResult.simulationResultCircuitJson.length} elements`
+          );
+          for (const simulationResultCircuitElement of simulationResult.simulationResultCircuitJson) {
+            if (!isCircuitElementInput(simulationResultCircuitElement)) {
+              debug11("Skipping invalid simulation result element");
+              continue;
             }
-          }
-          const insertedElement = root.db.insert(element);
-          if (isVoltageGraph(insertedElement)) {
-            insertedVoltageGraphs.push({
-              type: "voltage",
-              graph: insertedElement
-            });
-          }
-          if (isCurrentGraph(insertedElement)) {
-            insertedCurrentGraphs.push({
-              type: "current",
-              graph: insertedElement
+            const simulationResultWithSweepCoordinate = attachSweepCoordinateToSimulationResult({
+              simulationResult: simulationResultCircuitElement,
+              simulationParameterSweepCoordinate: simulationRun.simulationParameterSweepCoordinate
             });
+            if (isVoltageGraph(simulationResultWithSweepCoordinate)) {
+              simulationResultWithSweepCoordinate.simulation_experiment_id = simulationExperiment.simulation_experiment_id;
+              const probeMatch = simulationResultWithSweepCoordinate.name ? voltageProbeByGraphName.get(
+                simulationResultWithSweepCoordinate.name
+              ) : void 0;
+              if (probeMatch) {
+                simulationResultWithSweepCoordinate.color = probeMatch.color ?? void 0;
+                simulationResultWithSweepCoordinate.source_probe_id = probeMatch.simulation_voltage_probe_id ?? void 0;
+              }
+            } else if (isSimulationVoltageResult(simulationResultWithSweepCoordinate)) {
+              simulationResultWithSweepCoordinate.simulation_experiment_id = simulationExperiment.simulation_experiment_id;
+              const probeMatch = voltageProbeById.get(
+                simulationResultWithSweepCoordinate.simulation_voltage_probe_id
+              ) ?? (simulationResultWithSweepCoordinate.name ? voltageProbeByGraphName.get(
+                simulationResultWithSweepCoordinate.name
+              ) : void 0);
+              if (probeMatch?.simulation_voltage_probe_id) {
+                simulationResultWithSweepCoordinate.color = probeMatch.color ?? void 0;
+                simulationResultWithSweepCoordinate.simulation_voltage_probe_id = probeMatch.simulation_voltage_probe_id;
+              }
+            }
+            if (isCurrentGraph(simulationResultWithSweepCoordinate)) {
+              simulationResultWithSweepCoordinate.simulation_experiment_id = simulationExperiment.simulation_experiment_id;
+              const probeMatch = (simulationResultWithSweepCoordinate.source_probe_id ? currentProbeById.get(
+                simulationResultWithSweepCoordinate.source_probe_id
+              ) : void 0) ?? (simulationResultWithSweepCoordinate.name ? currentProbeByName.get(
+                simulationResultWithSweepCoordinate.name
+              ) : void 0);
+              if (probeMatch) {
+                simulationResultWithSweepCoordinate.color = probeMatch.color;
+                simulationResultWithSweepCoordinate.source_probe_id = probeMatch.simulation_current_probe_id;
+              }
+            } else if (isSimulationCurrentResult(simulationResultWithSweepCoordinate)) {
+              simulationResultWithSweepCoordinate.simulation_experiment_id = simulationExperiment.simulation_experiment_id;
+              const probeMatch = currentProbeById.get(
+                simulationResultWithSweepCoordinate.simulation_current_probe_id
+              ) ?? (simulationResultWithSweepCoordinate.name ? currentProbeByName.get(
+                simulationResultWithSweepCoordinate.name
+              ) : void 0);
+              if (probeMatch) {
+                simulationResultWithSweepCoordinate.color = probeMatch.color;
+                simulationResultWithSweepCoordinate.simulation_current_probe_id = probeMatch.simulation_current_probe_id;
+              }
+            }
+            const insertedSimulationResult = root.db.insert(
+              simulationResultWithSweepCoordinate
+            );
+            if (isVoltageGraph(insertedSimulationResult)) {
+              insertedVoltageGraphs.push({
+                type: "voltage",
+                graph: insertedSimulationResult
+              });
+            }
+            if (isCurrentGraph(insertedSimulationResult)) {
+              insertedCurrentGraphs.push({
+                type: "current",
+                graph: insertedSimulationResult
+              });
+            }
+            debug11(
+              `Inserted ${simulationResultWithSweepCoordinate.type} into database`
+            );
           }
-          debug11(`Inserted ${element.type} into database`);
         }
-        if (analogSim._parsedProps.graphIndependentAxes) {
+        if (analogSimulation.usesIndependentGraphAxes()) {
           insertIndependentAxisScopeTraces({
             db: root.db,
             graphs: [...insertedVoltageGraphs, ...insertedCurrentGraphs],
@@ -23423,7 +23654,7 @@ function Group_getRoutingPhasePlans(group) {
 var package_default = {
   name: "@tscircuit/core",
   type: "module",
-  version: "0.0.1502",
+  version: "0.0.1504",
   types: "dist/index.d.ts",
   main: "dist/index.js",
   module: "dist/index.js",
@@ -23459,11 +23690,11 @@ var package_default = {
     "@tscircuit/breakout-point-solver": "github:tscircuit/breakout-point-solver#bac9629",
     "@tscircuit/capacity-autorouter": "^0.0.710",
     "@tscircuit/checks": "0.0.145",
-    "@tscircuit/circuit-json-util": "^0.0.100",
+    "@tscircuit/circuit-json-util": "^0.0.101",
     "@tscircuit/common": "^0.0.20",
     "@tscircuit/copper-pour-solver": "0.0.39",
     "@tscircuit/create-fdm-enclosure": "0.0.3",
-    "@tscircuit/footprinter": "^0.0.386",
+    "@tscircuit/footprinter": "^0.0.387",
     "@tscircuit/image-utils": "^0.0.8",
     "@tscircuit/infer-cable-insertion-point": "^0.0.2",
     "@tscircuit/infgrid-ijump-astar": "^0.0.35",
@@ -23473,8 +23704,8 @@ var package_default = {
     "@tscircuit/matchpack": "^0.0.48",
     "@tscircuit/math-utils": "^0.0.36",
     "@tscircuit/miniflex": "^0.0.4",
-    "@tscircuit/ngspice-spice-engine": "^0.0.19",
-    "@tscircuit/props": "^0.0.591",
+    "@tscircuit/ngspice-spice-engine": "^0.0.20",
+    "@tscircuit/props": "^0.0.592",
     "@tscircuit/schematic-match-adapt": "^0.0.18",
     "@tscircuit/schematic-trace-solver": "^0.0.108",
     "@tscircuit/solver-utils": "^0.0.16",
@@ -23488,12 +23719,12 @@ var package_default = {
     "bun-match-svg": "0.0.12",
     "calculate-elbow": "^0.0.12",
     "chokidar-cli": "^3.0.0",
-    "circuit-json": "^0.0.453",
+    "circuit-json": "^0.0.454",
     "circuit-json-to-bpc": "^0.0.13",
     "circuit-json-to-connectivity-map": "^0.0.23",
     "circuit-json-to-gltf": "^0.0.107",
-    "circuit-json-to-spice": "^0.0.43",
-    "circuit-to-svg": "^0.0.391",
+    "circuit-json-to-spice": "^0.0.45",
+    "circuit-to-svg": "^0.0.393",
     concurrently: "^9.1.2",
     "connectivity-map": "^1.0.0",
     debug: "^4.3.6",
@@ -23510,7 +23741,7 @@ var package_default = {
     react: "^19.1.0",
     "react-dom": "^19.1.0",
     "schematic-symbols": "^0.0.233",
-    spicets: "^0.0.2",
+    spicets: "^0.0.4",
     spicey: "^0.0.14",
     "stack-svgs": "^0.0.1",
     "ts-expect": "^1.3.0",
@@ -23531,7 +23762,9 @@ var package_default = {
     "@tscircuit/matchpack": "*",
     "circuit-json": "*",
     "circuit-json-to-connectivity-map": "*",
+    "circuit-json-to-spice": "*",
     "schematic-symbols": "*",
+    spicets: "*",
     typescript: "^5.0.0"
   },
   dependencies: {
@@ -29543,6 +29776,7 @@ var PowerSource = class extends NormalComponent3 {
 import { voltageSourceProps } from "@tscircuit/props";
 import { formatSiUnit as formatSiUnit5 } from "format-si-unit";
 var VoltageSource = class extends NormalComponent3 {
+  simulation_voltage_source_id = null;
   get config() {
     const isSquare = this.props.waveShape === "square";
     return {
@@ -29619,11 +29853,10 @@ var VoltageSource = class extends NormalComponent3 {
     const { _parsedProps: props } = this;
     const terminal1Port = this.portMap.terminal1;
     const terminal2Port = this.portMap.terminal2;
-    db.simulation_voltage_source.insert({
-      type: "simulation_voltage_source",
+    const simulationVoltageSource = db.simulation_voltage_source.insert({
       is_dc_source: false,
-      terminal1_source_port_id: terminal1Port.source_port_id,
-      terminal2_source_port_id: terminal2Port.source_port_id,
+      terminal1_source_port_id: terminal1Port.source_port_id ?? void 0,
+      terminal2_source_port_id: terminal2Port.source_port_id ?? void 0,
       voltage: props.voltage,
       frequency: props.frequency,
       peak_to_peak_voltage: props.peakToPeakVoltage,
@@ -29634,8 +29867,11 @@ var VoltageSource = class extends NormalComponent3 {
       rise_time: props.riseTime,
       fall_time: props.fallTime,
       pulse_width: props.pulseWidth,
-      period: props.period
+      period: props.period,
+      ac_magnitude: props.acMagnitude,
+      ac_phase: props.acPhase
     });
+    this.simulation_voltage_source_id = simulationVoltageSource.simulation_voltage_source_id;
   }
   terminal1 = this.portMap.terminal1;
   terminal2 = this.portMap.terminal2;
@@ -29645,6 +29881,7 @@ var VoltageSource = class extends NormalComponent3 {
 import { currentSourceProps } from "@tscircuit/props";
 import { formatSiUnit as formatSiUnit6 } from "format-si-unit";
 var CurrentSource = class extends NormalComponent3 {
+  simulation_current_source_id = null;
   get config() {
     const symbolName = "current_source";
     return {
@@ -29717,32 +29954,36 @@ var CurrentSource = class extends NormalComponent3 {
   doInitialSimulationRender() {
     const { db } = this.root;
     const { _parsedProps: props } = this;
-    const isAc = props.frequency !== void 0 || props.peakToPeakCurrent !== void 0 || props.waveShape !== void 0;
+    const isAc = props.frequency !== void 0 || props.peakToPeakCurrent !== void 0 || props.waveShape !== void 0 || props.acMagnitude !== void 0 || props.acPhase !== void 0;
     const posPort = this.portMap.pos;
     const negPort = this.portMap.neg;
     if (isAc) {
-      db.simulation_current_source.insert({
-        type: "simulation_current_source",
+      const simulationCurrentSource = db.simulation_current_source.insert({
         is_dc_source: false,
-        terminal1_source_port_id: posPort.source_port_id,
-        terminal2_source_port_id: negPort.source_port_id,
+        terminal1_source_port_id: posPort.source_port_id ?? void 0,
+        terminal2_source_port_id: negPort.source_port_id ?? void 0,
         current: props.current,
         // DC offset
         frequency: props.frequency,
         peak_to_peak_current: props.peakToPeakCurrent,
         wave_shape: props.waveShape,
         phase: props.phase,
-        duty_cycle: props.dutyCycle
+        duty_cycle: props.dutyCycle,
+        ac_magnitude: props.acMagnitude,
+        ac_phase: props.acPhase
       });
+      this.simulation_current_source_id = simulationCurrentSource.simulation_current_source_id;
     } else {
       if (props.current === void 0) return;
-      db.simulation_current_source.insert({
-        type: "simulation_current_source",
+      const simulationCurrentSource = db.simulation_current_source.insert({
         is_dc_source: true,
-        positive_source_port_id: posPort.source_port_id,
-        negative_source_port_id: negPort.source_port_id,
-        current: props.current
+        positive_source_port_id: posPort.source_port_id ?? void 0,
+        negative_source_port_id: negPort.source_port_id ?? void 0,
+        current: props.current,
+        ac_magnitude: props.acMagnitude,
+        ac_phase: props.acPhase
       });
+      this.simulation_current_source_id = simulationCurrentSource.simulation_current_source_id;
     }
   }
   pos = this.portMap.pos;
@@ -34109,6 +34350,12 @@ var AnalogSimulation = class extends PrimitiveComponent2 {
       zodProps: analogSimulationProps
     };
   }
+  getSpiceEngineName() {
+    return this._parsedProps.spiceEngine;
+  }
+  usesIndependentGraphAxes() {
+    return this._parsedProps.graphIndependentAxes === true;
+  }
   doInitialSimulationRender() {
     const { db } = this.root;
     const { duration, name, startTime, timePerStep, spiceOptions } = this._parsedProps;
@@ -34126,6 +34373,316 @@ var AnalogSimulation = class extends PrimitiveComponent2 {
   }
 };
 
+// lib/components/primitive-components/AnalogAnalysisSimulation.ts
+var AnalogAnalysisSimulation = class extends PrimitiveComponent2 {
+  simulation_experiment_id = null;
+  getSpiceEngineName() {
+    return typeof this.props.spiceEngine === "string" ? this.props.spiceEngine : void 0;
+  }
+  usesIndependentGraphAxes() {
+    return this.props.graphIndependentAxes === true;
+  }
+  getOrCreateSimulationExperiment() {
+    if (this.simulation_experiment_id) {
+      return this.root?.db.simulation_experiment.get(
+        this.simulation_experiment_id
+      ) ?? null;
+    }
+    const sweepParameterCount = this.children.filter(
+      (child) => child.componentName === "AnalogSweepParameter"
+    ).length;
+    if (sweepParameterCount > 1) {
+      this.renderError(
+        "An analog simulation can contain at most one sweep parameter."
+      );
+      return null;
+    }
+    const simulationExperiment = this.insertSimulationExperiment();
+    this.simulation_experiment_id = simulationExperiment?.simulation_experiment_id ?? null;
+    return simulationExperiment;
+  }
+  doInitialSimulationRender() {
+    this.getOrCreateSimulationExperiment();
+  }
+};
+
+// lib/components/primitive-components/AnalogTransientSimulation.ts
+import { analogTransientSimulationProps } from "@tscircuit/props";
+var AnalogTransientSimulation = class extends AnalogAnalysisSimulation {
+  get config() {
+    return {
+      componentName: "AnalogTransientSimulation",
+      zodProps: analogTransientSimulationProps
+    };
+  }
+  insertSimulationExperiment() {
+    const { db } = this.root;
+    const { duration, name, startTime, timePerStep, spiceOptions } = this._parsedProps;
+    return db.simulation_experiment.insert({
+      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
+    });
+  }
+};
+
+// lib/components/primitive-components/AnalogDcOperatingPointSimulation.ts
+import { analogDcOperatingPointSimulationProps } from "@tscircuit/props";
+var AnalogDcOperatingPointSimulation = class extends AnalogAnalysisSimulation {
+  get config() {
+    return {
+      componentName: "AnalogDcOperatingPointSimulation",
+      zodProps: analogDcOperatingPointSimulationProps
+    };
+  }
+  insertSimulationExperiment() {
+    const { name, spiceOptions } = this._parsedProps;
+    return this.root.db.simulation_experiment.insert({
+      name: name ?? "spice_dc_operating_point",
+      experiment_type: "spice_dc_operating_point",
+      spice_options: spiceOptions
+    });
+  }
+};
+
+// lib/components/primitive-components/AnalogDcSweepSimulation.ts
+import { analogDcSweepSimulationProps } from "@tscircuit/props";
+var AnalogDcSweepSimulation = class extends AnalogAnalysisSimulation {
+  get config() {
+    return {
+      componentName: "AnalogDcSweepSimulation",
+      zodProps: analogDcSweepSimulationProps
+    };
+  }
+  insertSimulationExperiment() {
+    const {
+      name,
+      spiceOptions,
+      sweepSource,
+      sweepStart,
+      sweepStop,
+      sweepStep
+    } = this._parsedProps;
+    const simulationScope = this.getGroup() ?? this.getSubcircuit();
+    const sweepSourceComponent = simulationScope?.selectOne(sweepSource);
+    let dcSweepSourceFields;
+    if (sweepSourceComponent instanceof VoltageSource) {
+      sweepSourceComponent.runRenderPhase("SimulationRender");
+      const simulationVoltageSourceId = sweepSourceComponent.simulation_voltage_source_id;
+      if (!simulationVoltageSourceId) {
+        this.renderError(
+          `DC sweep source "${sweepSource}" must resolve to one voltage or current source.`
+        );
+        return null;
+      }
+      dcSweepSourceFields = {
+        dc_sweep_voltage_source_id: simulationVoltageSourceId,
+        dc_sweep_unit: "V"
+      };
+    } else if (sweepSourceComponent instanceof CurrentSource) {
+      sweepSourceComponent.runRenderPhase("SimulationRender");
+      const simulationCurrentSourceId = sweepSourceComponent.simulation_current_source_id;
+      if (!simulationCurrentSourceId) {
+        this.renderError(
+          `DC sweep source "${sweepSource}" must resolve to one voltage or current source.`
+        );
+        return null;
+      }
+      dcSweepSourceFields = {
+        dc_sweep_current_source_id: simulationCurrentSourceId,
+        dc_sweep_unit: "A"
+      };
+    } else {
+      this.renderError(
+        `DC sweep source "${sweepSource}" must resolve to one voltage or current source.`
+      );
+      return null;
+    }
+    return this.root.db.simulation_experiment.insert({
+      name: name ?? "spice_dc_sweep",
+      experiment_type: "spice_dc_sweep",
+      spice_options: spiceOptions,
+      ...dcSweepSourceFields,
+      dc_sweep_start: sweepStart,
+      dc_sweep_stop: sweepStop,
+      dc_sweep_step: sweepStep
+    });
+  }
+};
+
+// lib/components/primitive-components/AnalogAcSweepSimulation.ts
+import { analogAcSweepSimulationProps } from "@tscircuit/props";
+var AnalogAcSweepSimulation = class extends AnalogAnalysisSimulation {
+  get config() {
+    return {
+      componentName: "AnalogAcSweepSimulation",
+      zodProps: analogAcSweepSimulationProps
+    };
+  }
+  insertSimulationExperiment() {
+    const {
+      name,
+      spiceOptions,
+      sweepType,
+      samplesPerInterval,
+      sampleCount,
+      startFrequency,
+      stopFrequency
+    } = this._parsedProps;
+    return this.root.db.simulation_experiment.insert({
+      name: name ?? "spice_ac_analysis",
+      experiment_type: "spice_ac_analysis",
+      spice_options: spiceOptions,
+      ac_sweep_type: sweepType,
+      ac_samples_per_interval: samplesPerInterval,
+      ac_sample_count: sampleCount,
+      ac_start_frequency_hz: startFrequency,
+      ac_stop_frequency_hz: stopFrequency
+    });
+  }
+};
+
+// lib/components/primitive-components/AnalogSweepParameter.ts
+import { analogSweepParameterProps } from "@tscircuit/props";
+
+// lib/components/primitive-components/AnalogSweepParameter_doInitialSimulationRender.ts
+var parameterUnits = {
+  resistance: "\u03A9",
+  capacitance: "F",
+  inductance: "H",
+  voltage: "V",
+  current: "A"
+};
+var isParameterSweepCoordinateInRange = ({
+  parameterSweepCoordinate,
+  stop,
+  step
+}) => {
+  const tolerance = Math.abs(step) * 1e-9;
+  return step > 0 ? parameterSweepCoordinate <= stop + tolerance : parameterSweepCoordinate >= stop - tolerance;
+};
+var getGeneratedParameterSweepCoordinates = ({
+  start,
+  stop,
+  step
+}) => {
+  const parameterSweepCoordinates = [];
+  for (let parameterSweepCoordinate = start; isParameterSweepCoordinateInRange({
+    parameterSweepCoordinate,
+    stop,
+    step
+  }); parameterSweepCoordinate = start + parameterSweepCoordinates.length * step) {
+    parameterSweepCoordinates.push(parameterSweepCoordinate);
+    if (parameterSweepCoordinates.length > 1e6) {
+      throw new Error("Parameter sweep exceeds 1,000,000 points");
+    }
+  }
+  return parameterSweepCoordinates;
+};
+var getParameterSweepTargetSelector = (props) => {
+  if (props.parameterType === "resistance") return props.resistorRef;
+  if (props.parameterType === "capacitance") return props.capacitorRef;
+  if (props.parameterType === "inductance") return props.inductorRef;
+  if (props.parameterType === "voltage") return props.net;
+  return props.currentSourceRef;
+};
+var AnalogSweepParameter_doInitialSimulationRender = (analogSweepParameter) => {
+  if (!(analogSweepParameter.parent instanceof AnalogAnalysisSimulation)) {
+    analogSweepParameter.renderError(
+      "analog.sweepparameter must be nested directly in an analog simulation."
+    );
+    return;
+  }
+  const simulationExperiment = analogSweepParameter.parent.getOrCreateSimulationExperiment();
+  if (!simulationExperiment) return;
+  const props = analogSweepParameter._parsedProps;
+  const parameterSweepCoordinates = props.values ?? getGeneratedParameterSweepCoordinates({
+    start: props.start,
+    stop: props.stop,
+    step: props.step
+  });
+  const simulationScope = analogSweepParameter.parent.getGroup() ?? analogSweepParameter.parent.getSubcircuit();
+  const targetSelector = getParameterSweepTargetSelector(props);
+  const parameterUnit = parameterUnits[props.parameterType];
+  const simulationParameterSweepTable = analogSweepParameter.root.db.simulation_parameter_sweep;
+  const simulationParameterSweepFields = {
+    simulation_experiment_id: simulationExperiment.simulation_experiment_id,
+    name: props.name,
+    parameter_type: props.parameterType,
+    parameter_values: parameterSweepCoordinates,
+    parameter_unit: parameterUnit
+  };
+  let simulationParameterSweepId;
+  if (props.parameterType === "voltage") {
+    const sweepNet = simulationScope?.selectOne(targetSelector, {
+      type: "net"
+    });
+    if (!sweepNet?.source_net_id) {
+      analogSweepParameter.renderError(
+        `Voltage sweep net "${targetSelector}" could not be resolved.`
+      );
+      return;
+    }
+    simulationParameterSweepId = simulationParameterSweepTable.insert({
+      ...simulationParameterSweepFields,
+      parameter_type: "voltage",
+      source_net_id: sweepNet.source_net_id
+    }).simulation_parameter_sweep_id;
+  } else {
+    const sweepTarget = simulationScope?.selectOne(targetSelector);
+    const sourceComponentId = sweepTarget?.source_component_id;
+    if (!sourceComponentId) {
+      analogSweepParameter.renderError(
+        `Parameter sweep target "${targetSelector}" could not be resolved.`
+      );
+      return;
+    }
+    if (props.parameterType === "resistance") {
+      simulationParameterSweepId = simulationParameterSweepTable.insert({
+        ...simulationParameterSweepFields,
+        parameter_type: "resistance",
+        resistor_source_component_id: sourceComponentId
+      }).simulation_parameter_sweep_id;
+    } else if (props.parameterType === "capacitance") {
+      simulationParameterSweepId = simulationParameterSweepTable.insert({
+        ...simulationParameterSweepFields,
+        parameter_type: "capacitance",
+        capacitor_source_component_id: sourceComponentId
+      }).simulation_parameter_sweep_id;
+    } else if (props.parameterType === "inductance") {
+      simulationParameterSweepId = simulationParameterSweepTable.insert({
+        ...simulationParameterSweepFields,
+        parameter_type: "inductance",
+        inductor_source_component_id: sourceComponentId
+      }).simulation_parameter_sweep_id;
+    } else {
+      simulationParameterSweepId = simulationParameterSweepTable.insert({
+        ...simulationParameterSweepFields,
+        parameter_type: "current",
+        current_source_component_id: sourceComponentId
+      }).simulation_parameter_sweep_id;
+    }
+  }
+  analogSweepParameter.simulation_parameter_sweep_id = simulationParameterSweepId;
+};
+
+// lib/components/primitive-components/AnalogSweepParameter.ts
+var AnalogSweepParameter = class extends PrimitiveComponent2 {
+  simulation_parameter_sweep_id = null;
+  get config() {
+    return {
+      componentName: "AnalogSweepParameter",
+      zodProps: analogSweepParameterProps
+    };
+  }
+  doInitialSimulationRender() {
+    AnalogSweepParameter_doInitialSimulationRender(this);
+  }
+};
+
 // lib/components/primitive-components/VoltageProbe.ts
 import { voltageProbeProps } from "@tscircuit/props";
 
@@ -34508,6 +35065,25 @@ var createNamespacedElement = (hostType) => {
   return Component2;
 };
 
+// lib/namespaced-elements/analog.ts
+var analog = {
+  transientsimulation: createNamespacedElement(
+    "analogtransientsimulation"
+  ),
+  dcoperatingpointsimulation: createNamespacedElement(
+    "analogdcoperatingpointsimulation"
+  ),
+  dcsweepsimulation: createNamespacedElement(
+    "analogdcsweepsimulation"
+  ),
+  acsweepsimulation: createNamespacedElement(
+    "analogacsweepsimulation"
+  ),
+  sweepparameter: createNamespacedElement(
+    "analogsweepparameter"
+  )
+};
+
 // lib/namespaced-elements/enclosure.ts
 var EnclosureFdmBoxElement = createNamespacedElement("enclosure.fdm.box");
 var enclosure = {
@@ -34752,7 +35328,13 @@ extendCatalogue({
 });
 export {
   Ammeter,
+  AnalogAcSweepSimulation,
+  AnalogAnalysisSimulation,
+  AnalogDcOperatingPointSimulation,
+  AnalogDcSweepSimulation,
   AnalogSimulation,
+  AnalogSweepParameter,
+  AnalogTransientSimulation,
   AutoroutingPhase,
   Battery,
   Board,
@@ -34856,6 +35438,7 @@ export {
   Via,
   VoltageProbe,
   VoltageSource,
+  analog,
   applyEditEvents,
   applyEditEventsToManualEditsFile,
   applyPcbEditEventsToManualEditsFile,