@tscircuit/ngspice-spice-engine 0.0.18 → 0.0.20

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { SpiceEngine } from '@tscircuit/props';
-import { SimulationTransientVoltageGraph, SimulationTransientCurrentGraph } from 'circuit-json';
+import { SimulationAcSweepVoltageGraph, SimulationAnalysisResult } from 'circuit-json';
 
 interface TranParams {
     tstep?: number;
@@ -10,6 +10,18 @@ interface TranParams {
 }
 declare const parseTranParams: (spiceString: string) => TranParams | null;
 
+type SimulationAnalysis = {
+    type: "transient";
+} | {
+    type: "dc_operating_point";
+} | {
+    type: "dc_sweep";
+    sweepUnit: "V" | "A";
+} | {
+    type: "ac_sweep";
+};
+declare const parseSimulationAnalysis: (spiceString: string) => SimulationAnalysis | null;
+
 declare const rewritePspiceCompatibilitySyntax: (spiceString: string) => string;
 
 type ComplexNumber = {
@@ -58,6 +70,7 @@ interface CurrentProbeMetadata {
 }
 interface VoltageGraph {
     graphType: "voltage";
+    analysisType: "transient";
     netName: string;
     time: number[];
     voltage: number[];
@@ -65,18 +78,68 @@ interface VoltageGraph {
 }
 interface CurrentGraph {
     graphType: "current";
+    analysisType: "transient";
     currentName: string;
     time: number[];
     current: number[];
     probeMetadata?: CurrentProbeMetadata;
 }
-type SimulationGraph = VoltageGraph | CurrentGraph;
+interface DcOperatingPointVoltageResult {
+    graphType: "voltage";
+    analysisType: "dc_operating_point";
+    netName: string;
+    voltage: number;
+    probeMetadata?: VoltageProbeMetadata;
+}
+interface DcOperatingPointCurrentResult {
+    graphType: "current";
+    analysisType: "dc_operating_point";
+    currentName: string;
+    current: number;
+    probeMetadata?: CurrentProbeMetadata;
+}
+interface DcSweepVoltageGraph {
+    graphType: "voltage";
+    analysisType: "dc_sweep";
+    netName: string;
+    sweepValues: number[];
+    sweepUnit: "V" | "A";
+    voltage: number[];
+    probeMetadata?: VoltageProbeMetadata;
+}
+interface DcSweepCurrentGraph {
+    graphType: "current";
+    analysisType: "dc_sweep";
+    currentName: string;
+    sweepValues: number[];
+    sweepUnit: "V" | "A";
+    current: number[];
+    probeMetadata?: CurrentProbeMetadata;
+}
+type ComplexSample = SimulationAcSweepVoltageGraph["complex_voltages"][number];
+interface AcSweepVoltageGraph {
+    graphType: "voltage";
+    analysisType: "ac_sweep";
+    netName: string;
+    frequenciesHz: number[];
+    complexVoltages: ComplexSample[];
+    probeMetadata?: VoltageProbeMetadata;
+}
+interface AcSweepCurrentGraph {
+    graphType: "current";
+    analysisType: "ac_sweep";
+    currentName: string;
+    frequenciesHz: number[];
+    complexCurrents: ComplexSample[];
+    probeMetadata?: CurrentProbeMetadata;
+}
+type SimulationGraph = VoltageGraph | CurrentGraph | DcOperatingPointVoltageResult | DcOperatingPointCurrentResult | DcSweepVoltageGraph | DcSweepCurrentGraph | AcSweepVoltageGraph | AcSweepCurrentGraph;
 
 declare const eecircuitResultToSimulationGraphs: (result: ResultType, spiceString: string) => SimulationGraph[];
 declare const eecircuitResultToVGraphs: (result: ResultType, spiceString: string) => VoltageGraph[];
 
-declare const simulationGraphsToCircuitJson: (graphs: SimulationGraph[], spiceString: string) => Array<SimulationTransientVoltageGraph | SimulationTransientCurrentGraph>;
+declare const simulationGraphsToCircuitJson: (graphs: SimulationGraph[], spiceString: string) => SimulationAnalysisResult[];
 
 declare const createNgspiceSpiceEngine: () => Promise<SpiceEngine>;
 
-export { type TranParams, createNgspiceSpiceEngine, createNgspiceSpiceEngine as default, eecircuitResultToSimulationGraphs, eecircuitResultToVGraphs, parseTranParams, rewritePspiceCompatibilitySyntax, simulationGraphsToCircuitJson };
+export { type SimulationAnalysis, type TranParams, createNgspiceSpiceEngine, createNgspiceSpiceEngine as default, eecircuitResultToSimulationGraphs, eecircuitResultToVGraphs, parseSimulationAnalysis, parseTranParams, rewritePspiceCompatibilitySyntax, simulationGraphsToCircuitJson };

package/dist/index.js

@@ -1,5 +1,5 @@
 // lib/import-eecircuit-engine.ts
-var EECIRCUIT_ENGINE_URL = "https://jscdn.tscircuit.com/@tscircuit/eecircuit-engine/1.7.4/+esm";
+var EECIRCUIT_ENGINE_URL = "https://jscdn.tscircuit.com/@tscircuit/eecircuit-engine/1.7.6/+esm";
 var modulePromise = null;
 var importEecircuitEngine = async () => {
   if (!modulePromise) {
@@ -20,6 +20,7 @@ var importEecircuitEngine = async () => {
 };
 
 // lib/parse-tran-params.ts
+import { parseSpiceNetlist, Tran } from "spicets";
 var SUFFIX_MULTIPLIERS = {
   t: 1e12,
   g: 1e9,
@@ -57,51 +58,33 @@ var parseNumericToken = (token) => {
   return base * multiplier;
 };
 var parseTranParams = (spiceString) => {
-  const lines = spiceString.split(/\r?\n/);
-  for (const rawLine of lines) {
-    const line = rawLine.trim();
-    if (!line || line.startsWith("*")) {
-      continue;
-    }
-    if (!line.toLowerCase().startsWith(".tran")) {
-      continue;
-    }
-    const [withoutComments = ""] = line.split(";");
-    const tokens = withoutComments.split(/\s+/).filter(Boolean);
-    if (tokens.length <= 1) {
-      return {};
-    }
-    const values = [];
-    let uic = false;
-    for (const token of tokens.slice(1)) {
-      if (token.toLowerCase() === "uic") {
-        uic = true;
-        continue;
-      }
-      const value = parseNumericToken(token);
-      if (value !== void 0) {
-        values.push(value);
-      }
-    }
-    const params = {};
-    if (values[0] !== void 0) {
-      params.tstep = values[0];
-    }
-    if (values[1] !== void 0) {
-      params.tstop = values[1];
-    }
-    if (values[2] !== void 0) {
-      params.tstart = values[2];
-    }
-    if (values[3] !== void 0) {
-      params.tmax = values[3];
-    }
-    if (uic) {
-      params.uic = true;
-    }
-    return params;
+  const tran = parseSpiceNetlist(spiceString, {
+    dialect: "ngspice"
+  }).analyses.find((analysis) => analysis instanceof Tran);
+  if (!tran) {
+    return null;
   }
-  return null;
+  const params = {};
+  const tstep = tran.step ? parseNumericToken(tran.step.raw) : void 0;
+  const tstop = parseNumericToken(tran.stop.raw);
+  const tstart = tran.start ? parseNumericToken(tran.start.raw) : void 0;
+  const tmax = tran.maxStep ? parseNumericToken(tran.maxStep.raw) : void 0;
+  if (tstep !== void 0) {
+    params.tstep = tstep;
+  }
+  if (tstop !== void 0) {
+    params.tstop = tstop;
+  }
+  if (tstart !== void 0) {
+    params.tstart = tstart;
+  }
+  if (tmax !== void 0) {
+    params.tmax = tmax;
+  }
+  if (tran.uic) {
+    params.uic = true;
+  }
+  return params;
 };
 
 // lib/rewrite-pspice-compatibility-syntax.ts
@@ -170,149 +153,407 @@ var rewritePspiceValueBooleanCarets = (spiceString) => {
 var rewritePspiceCompatibilitySyntax = (spiceString) => rewritePspiceValueBooleanCarets(rewritePspiceResistorTcPairs(spiceString));
 
 // lib/create-graph-from-requested-plot.ts
-var getNetName = (rawName) => {
-  const diffMatch = rawName.match(/^v\(([^,]+),\s*([^)]+)\)$/i);
-  if (diffMatch?.[1] && diffMatch?.[2]) {
-    return `${diffMatch[1].trim()}-${diffMatch[2].trim()}`;
+var getNetName = (spiceVector) => {
+  const differentialVoltageMatch = spiceVector.match(
+    /^v\(([^,]+),\s*([^)]+)\)$/i
+  );
+  if (differentialVoltageMatch?.[1] && differentialVoltageMatch?.[2]) {
+    return `${differentialVoltageMatch[1].trim()}-${differentialVoltageMatch[2].trim()}`;
   }
-  const match = rawName.match(/^v\((.*)\)$/i);
+  const match = spiceVector.match(/^v\((.*)\)$/i);
   if (!match) {
-    return rawName;
+    return spiceVector;
   }
-  return match[1] ?? rawName;
+  return match[1] ?? spiceVector;
 };
-var getCurrentName = (rawName) => {
-  const match = rawName.match(/^i\((.*)\)$/i);
+var getCurrentName = (spiceVector) => {
+  const match = spiceVector.match(/^i\((.*)\)$/i);
   if (!match) {
-    return rawName;
+    return spiceVector;
   }
-  return match[1] ?? rawName;
+  return match[1] ?? spiceVector;
 };
 var createVoltageGraphFromRequestedPlot = ({
-  lowerCaseToken,
-  originalToken,
-  timeValues,
-  voltageDataMap,
-  voltageProbeMetadata
+  normalizedSpiceVector,
+  originalSpiceVector,
+  timeSeconds,
+  voltageSamplesBySpiceVector,
+  voltageProbeMetadataBySpiceVector
 }) => {
-  if (!lowerCaseToken.startsWith("v(")) return null;
-  const diffMatch = originalToken.match(/^v\(([^,]+),\s*([^)]+)\)$/i);
-  let voltage;
-  if (diffMatch?.[1] && diffMatch?.[2]) {
-    voltage = voltageDataMap.get(lowerCaseToken);
-    if (!voltage) {
-      const node1 = diffMatch[1].trim();
-      const node2 = diffMatch[2].trim();
-      const node1Data = voltageDataMap.get(`v(${node1.toLowerCase()})`);
-      const node2Data = voltageDataMap.get(`v(${node2.toLowerCase()})`);
-      if (node1Data && node2Data) {
-        voltage = node1Data.map((v, i) => v - (node2Data[i] ?? 0));
+  if (!normalizedSpiceVector.startsWith("v(")) return null;
+  const differentialVoltageMatch = originalSpiceVector.match(
+    /^v\(([^,]+),\s*([^)]+)\)$/i
+  );
+  let voltageSamples;
+  if (differentialVoltageMatch?.[1] && differentialVoltageMatch?.[2]) {
+    voltageSamples = voltageSamplesBySpiceVector.get(normalizedSpiceVector);
+    if (!voltageSamples) {
+      const positiveNodeName = differentialVoltageMatch[1].trim();
+      const referenceNodeName = differentialVoltageMatch[2].trim();
+      const positiveVoltageSamples = voltageSamplesBySpiceVector.get(
+        `v(${positiveNodeName.toLowerCase()})`
+      );
+      const referenceVoltageSamples = voltageSamplesBySpiceVector.get(
+        `v(${referenceNodeName.toLowerCase()})`
+      );
+      if (positiveVoltageSamples && referenceVoltageSamples) {
+        voltageSamples = positiveVoltageSamples.map(
+          (positiveVoltage, sampleIndex) => positiveVoltage - (referenceVoltageSamples[sampleIndex] ?? 0)
+        );
       }
     }
   } else {
-    voltage = voltageDataMap.get(lowerCaseToken);
+    voltageSamples = voltageSamplesBySpiceVector.get(normalizedSpiceVector);
   }
-  if (!voltage) return null;
-  const metadata = voltageProbeMetadata.get(lowerCaseToken);
+  if (!voltageSamples) return null;
+  const probeMetadata = voltageProbeMetadataBySpiceVector.get(
+    normalizedSpiceVector
+  );
   const voltageGraph = {
     graphType: "voltage",
-    netName: metadata?.name ?? getNetName(originalToken),
-    time: timeValues,
-    voltage,
-    probeMetadata: metadata
+    analysisType: "transient",
+    netName: probeMetadata?.name ?? getNetName(originalSpiceVector),
+    time: timeSeconds,
+    voltage: voltageSamples,
+    probeMetadata
   };
   return voltageGraph;
 };
 var createCurrentGraphFromRequestedPlot = ({
-  lowerCaseToken,
-  originalToken,
-  timeValues,
-  currentDataMap,
-  currentProbeMetadata
+  normalizedSpiceVector,
+  originalSpiceVector,
+  timeSeconds,
+  currentSamplesBySpiceVector,
+  currentProbeMetadataBySpiceVector
 }) => {
-  if (!lowerCaseToken.startsWith("i(")) return null;
-  const current = currentDataMap.get(lowerCaseToken);
-  if (!current) return null;
-  const metadata = currentProbeMetadata.get(lowerCaseToken);
+  if (!normalizedSpiceVector.startsWith("i(")) return null;
+  const currentSamples = currentSamplesBySpiceVector.get(normalizedSpiceVector);
+  if (!currentSamples) return null;
+  const probeMetadata = currentProbeMetadataBySpiceVector.get(
+    normalizedSpiceVector
+  );
   const currentGraph = {
     graphType: "current",
-    currentName: metadata?.name ?? getCurrentName(originalToken),
-    time: timeValues,
-    current,
-    probeMetadata: metadata
+    analysisType: "transient",
+    currentName: probeMetadata?.name ?? getCurrentName(originalSpiceVector),
+    time: timeSeconds,
+    current: currentSamples,
+    probeMetadata
   };
   return currentGraph;
 };
 
 // lib/extract-probe-metadata.ts
-var normalizeSpiceVector = (value) => value.toLowerCase().replace(/\s/g, "");
+var normalizeSpiceVector = (spiceVector) => spiceVector.toLowerCase().replace(/\s/g, "");
 var extractVoltageProbeMetadata = (spiceString) => {
-  const metadata = /* @__PURE__ */ new Map();
+  const voltageProbeMetadataBySpiceVector = /* @__PURE__ */ new Map();
   for (const line of spiceString.split(/\r?\n/)) {
     const match = line.match(/^\s*\*\s*tscircuit_probe\s+(.+)\s*$/);
     if (!match?.[1]) continue;
     try {
-      const parsed = JSON.parse(match[1]);
-      if (typeof parsed.simulation_voltage_probe_id !== "string" || typeof parsed.spice_vector !== "string" || typeof parsed.source_node_name !== "string") {
+      const parsedProbeMetadata = JSON.parse(match[1]);
+      if (typeof parsedProbeMetadata !== "object" || parsedProbeMetadata === null || !("simulation_voltage_probe_id" in parsedProbeMetadata) || typeof parsedProbeMetadata.simulation_voltage_probe_id !== "string" || !("spice_vector" in parsedProbeMetadata) || typeof parsedProbeMetadata.spice_vector !== "string" || !("source_node_name" in parsedProbeMetadata) || typeof parsedProbeMetadata.source_node_name !== "string") {
         continue;
       }
-      const normalizedSpiceVector = normalizeSpiceVector(parsed.spice_vector);
+      const normalizedSpiceVector = normalizeSpiceVector(
+        parsedProbeMetadata.spice_vector
+      );
       const voltageProbeMetadata = {
-        simulation_voltage_probe_id: parsed.simulation_voltage_probe_id,
-        name: typeof parsed.name === "string" ? parsed.name : void 0,
-        spice_vector: parsed.spice_vector,
-        source_node_name: parsed.source_node_name,
-        reference_node_name: typeof parsed.reference_node_name === "string" ? parsed.reference_node_name : void 0
+        simulation_voltage_probe_id: parsedProbeMetadata.simulation_voltage_probe_id,
+        name: "name" in parsedProbeMetadata && typeof parsedProbeMetadata.name === "string" ? parsedProbeMetadata.name : void 0,
+        spice_vector: parsedProbeMetadata.spice_vector,
+        source_node_name: parsedProbeMetadata.source_node_name,
+        reference_node_name: "reference_node_name" in parsedProbeMetadata && typeof parsedProbeMetadata.reference_node_name === "string" ? parsedProbeMetadata.reference_node_name : void 0
       };
-      metadata.set(normalizedSpiceVector, voltageProbeMetadata);
+      voltageProbeMetadataBySpiceVector.set(
+        normalizedSpiceVector,
+        voltageProbeMetadata
+      );
     } catch {
     }
   }
-  return metadata;
+  return voltageProbeMetadataBySpiceVector;
 };
 var extractCurrentProbeMetadata = (spiceString) => {
-  const metadata = /* @__PURE__ */ new Map();
+  const currentProbeMetadataBySpiceVector = /* @__PURE__ */ new Map();
   for (const line of spiceString.split(/\r?\n/)) {
     const match = line.match(/^\s*\*\s*tscircuit_current_probe\s+(.+)\s*$/);
     if (!match?.[1]) continue;
     try {
-      const parsed = JSON.parse(match[1]);
-      if (typeof parsed.simulation_current_probe_id !== "string" || typeof parsed.spice_vector !== "string") {
+      const parsedProbeMetadata = JSON.parse(match[1]);
+      if (typeof parsedProbeMetadata !== "object" || parsedProbeMetadata === null || !("simulation_current_probe_id" in parsedProbeMetadata) || typeof parsedProbeMetadata.simulation_current_probe_id !== "string" || !("spice_vector" in parsedProbeMetadata) || typeof parsedProbeMetadata.spice_vector !== "string") {
         continue;
       }
-      const normalizedSpiceVector = normalizeSpiceVector(parsed.spice_vector);
+      const normalizedSpiceVector = normalizeSpiceVector(
+        parsedProbeMetadata.spice_vector
+      );
       const currentProbeMetadata = {
-        simulation_current_probe_id: parsed.simulation_current_probe_id,
-        name: typeof parsed.name === "string" ? parsed.name : void 0,
-        spice_vector: parsed.spice_vector,
-        source_component_id: typeof parsed.source_component_id === "string" ? parsed.source_component_id : void 0,
-        source_trace_id: typeof parsed.source_trace_id === "string" ? parsed.source_trace_id : void 0
+        simulation_current_probe_id: parsedProbeMetadata.simulation_current_probe_id,
+        name: "name" in parsedProbeMetadata && typeof parsedProbeMetadata.name === "string" ? parsedProbeMetadata.name : void 0,
+        spice_vector: parsedProbeMetadata.spice_vector,
+        source_component_id: "source_component_id" in parsedProbeMetadata && typeof parsedProbeMetadata.source_component_id === "string" ? parsedProbeMetadata.source_component_id : void 0,
+        source_trace_id: "source_trace_id" in parsedProbeMetadata && typeof parsedProbeMetadata.source_trace_id === "string" ? parsedProbeMetadata.source_trace_id : void 0
       };
-      metadata.set(normalizedSpiceVector, currentProbeMetadata);
+      currentProbeMetadataBySpiceVector.set(
+        normalizedSpiceVector,
+        currentProbeMetadata
+      );
     } catch {
     }
   }
-  return metadata;
+  return currentProbeMetadataBySpiceVector;
 };
 
 // lib/extract-requested-plots.ts
+import { Print, parseSpiceNetlist as parseSpiceNetlist2 } from "spicets";
 var extractRequestedPlots = (spiceString) => {
-  const match = spiceString.match(/\.print\s+tran\s+(.*)/i);
-  if (!match?.[1]) {
+  const supportedAnalyses = /* @__PURE__ */ new Set(["tran", "op", "dc", "ac"]);
+  const print = parseSpiceNetlist2(spiceString, {
+    dialect: "ngspice"
+  }).directives.find(
+    (directive) => directive instanceof Print && supportedAnalyses.has(directive.analysis?.toLowerCase() ?? "")
+  );
+  if (!(print instanceof Print)) {
     return null;
   }
-  const tokens = match[1].match(/[VI]\s*\([^)]+\)/gi);
+  const tokens = print.getString().match(/[VI]\s*\([^)]+\)/gi);
   if (!tokens) {
     return null;
   }
-  const plotMap = /* @__PURE__ */ new Map();
+  const requestedPlotByNormalizedSpiceVector = /* @__PURE__ */ new Map();
   for (const token of tokens) {
-    const lowerCaseToken = token.toLowerCase().replace(/\s/g, "");
-    if (!plotMap.has(lowerCaseToken)) {
-      plotMap.set(lowerCaseToken, token);
+    const normalizedSpiceVector = token.toLowerCase().replace(/\s/g, "");
+    if (!requestedPlotByNormalizedSpiceVector.has(normalizedSpiceVector)) {
+      requestedPlotByNormalizedSpiceVector.set(normalizedSpiceVector, token);
+    }
+  }
+  return requestedPlotByNormalizedSpiceVector;
+};
+
+// lib/non-transient-result-helpers.ts
+var getRequestedPlotByNormalizedSpiceVector = ({
+  spiceString,
+  simulationOutputs
+}) => {
+  const requestedPlotByNormalizedSpiceVector = extractRequestedPlots(spiceString);
+  if (requestedPlotByNormalizedSpiceVector) {
+    return requestedPlotByNormalizedSpiceVector;
+  }
+  return new Map(
+    simulationOutputs.filter(
+      (simulationOutput) => simulationOutput.type === "voltage" || simulationOutput.type === "current"
+    ).map((simulationOutput) => [
+      normalizeSpiceVector(simulationOutput.name),
+      simulationOutput.name
+    ])
+  );
+};
+var getRealSampleMaps = (simulationOutputs) => {
+  const voltageSamplesBySpiceVector = new Map(
+    simulationOutputs.filter((simulationOutput) => simulationOutput.type === "voltage").map((simulationOutput) => [
+      normalizeSpiceVector(simulationOutput.name),
+      simulationOutput.values
+    ])
+  );
+  const currentSamplesBySpiceVector = new Map(
+    simulationOutputs.filter((simulationOutput) => simulationOutput.type === "current").map((simulationOutput) => [
+      normalizeSpiceVector(simulationOutput.name),
+      simulationOutput.values
+    ])
+  );
+  return { voltageSamplesBySpiceVector, currentSamplesBySpiceVector };
+};
+var getComplexSampleMaps = (simulationOutputs) => {
+  const voltageSamplesBySpiceVector = new Map(
+    simulationOutputs.filter((simulationOutput) => simulationOutput.type === "voltage").map((simulationOutput) => [
+      normalizeSpiceVector(simulationOutput.name),
+      simulationOutput.values
+    ])
+  );
+  const currentSamplesBySpiceVector = new Map(
+    simulationOutputs.filter((simulationOutput) => simulationOutput.type === "current").map((simulationOutput) => [
+      normalizeSpiceVector(simulationOutput.name),
+      simulationOutput.values
+    ])
+  );
+  return { voltageSamplesBySpiceVector, currentSamplesBySpiceVector };
+};
+var getRealVoltageSamples = ({
+  normalizedSpiceVector,
+  originalSpiceVector,
+  voltageSamplesBySpiceVector
+}) => {
+  const directVoltageSamples = voltageSamplesBySpiceVector.get(
+    normalizedSpiceVector
+  );
+  if (directVoltageSamples) return directVoltageSamples;
+  const differentialVoltageMatch = originalSpiceVector.match(
+    /^v\(([^,]+),\s*([^)]+)\)$/i
+  );
+  if (!differentialVoltageMatch?.[1] || !differentialVoltageMatch[2]) {
+    return void 0;
+  }
+  const positiveVoltageSamples = voltageSamplesBySpiceVector.get(
+    normalizeSpiceVector(`v(${differentialVoltageMatch[1]})`)
+  );
+  const negativeVoltageSamples = voltageSamplesBySpiceVector.get(
+    normalizeSpiceVector(`v(${differentialVoltageMatch[2]})`)
+  );
+  if (!positiveVoltageSamples || !negativeVoltageSamples) return void 0;
+  return positiveVoltageSamples.map(
+    (positiveVoltage, sampleIndex) => positiveVoltage - (negativeVoltageSamples[sampleIndex] ?? 0)
+  );
+};
+var getComplexVoltageSamples = ({
+  normalizedSpiceVector,
+  originalSpiceVector,
+  voltageSamplesBySpiceVector
+}) => {
+  const directVoltageSamples = voltageSamplesBySpiceVector.get(
+    normalizedSpiceVector
+  );
+  if (directVoltageSamples) return directVoltageSamples;
+  const differentialVoltageMatch = originalSpiceVector.match(
+    /^v\(([^,]+),\s*([^)]+)\)$/i
+  );
+  if (!differentialVoltageMatch?.[1] || !differentialVoltageMatch[2]) {
+    return void 0;
+  }
+  const positiveVoltageSamples = voltageSamplesBySpiceVector.get(
+    normalizeSpiceVector(`v(${differentialVoltageMatch[1]})`)
+  );
+  const negativeVoltageSamples = voltageSamplesBySpiceVector.get(
+    normalizeSpiceVector(`v(${differentialVoltageMatch[2]})`)
+  );
+  if (!positiveVoltageSamples || !negativeVoltageSamples) return void 0;
+  return positiveVoltageSamples.map((positiveVoltage, sampleIndex) => ({
+    real: positiveVoltage.real - (negativeVoltageSamples[sampleIndex]?.real ?? 0),
+    img: positiveVoltage.img - (negativeVoltageSamples[sampleIndex]?.img ?? 0)
+  }));
+};
+var toCircuitJsonComplexSamples = (complexSamples) => complexSamples.map(({ real, img }) => ({ re: real, im: img }));
+
+// lib/ac-sweep-result-to-graphs.ts
+var acSweepResultToGraphs = ({
+  eecircuitResult,
+  spiceString
+}) => {
+  const frequencyOutput = eecircuitResult.data.find(
+    (simulationOutput) => simulationOutput.type === "frequency"
+  );
+  if (!frequencyOutput) return [];
+  const simulationOutputs = eecircuitResult.data.filter(
+    (simulationOutput) => simulationOutput !== frequencyOutput
+  );
+  const { voltageSamplesBySpiceVector, currentSamplesBySpiceVector } = getComplexSampleMaps(simulationOutputs);
+  const frequenciesHz = frequencyOutput.values.map(({ real }) => real);
+  const voltageProbeMetadataBySpiceVector = extractVoltageProbeMetadata(spiceString);
+  const currentProbeMetadataBySpiceVector = extractCurrentProbeMetadata(spiceString);
+  const simulationGraphs = [];
+  for (const [
+    normalizedSpiceVector,
+    originalSpiceVector
+  ] of getRequestedPlotByNormalizedSpiceVector({
+    spiceString,
+    simulationOutputs
+  })) {
+    if (normalizedSpiceVector.startsWith("v(")) {
+      const complexVoltageSamples = getComplexVoltageSamples({
+        normalizedSpiceVector,
+        originalSpiceVector,
+        voltageSamplesBySpiceVector
+      });
+      if (!complexVoltageSamples) continue;
+      const probeMetadata2 = voltageProbeMetadataBySpiceVector.get(
+        normalizedSpiceVector
+      );
+      simulationGraphs.push({
+        graphType: "voltage",
+        analysisType: "ac_sweep",
+        netName: probeMetadata2?.name ?? getNetName(originalSpiceVector),
+        frequenciesHz,
+        complexVoltages: toCircuitJsonComplexSamples(complexVoltageSamples),
+        probeMetadata: probeMetadata2
+      });
+      continue;
     }
+    const complexCurrentSamples = currentSamplesBySpiceVector.get(
+      normalizedSpiceVector
+    );
+    if (!complexCurrentSamples) continue;
+    const probeMetadata = currentProbeMetadataBySpiceVector.get(
+      normalizedSpiceVector
+    );
+    simulationGraphs.push({
+      graphType: "current",
+      analysisType: "ac_sweep",
+      currentName: probeMetadata?.name ?? getCurrentName(originalSpiceVector),
+      frequenciesHz,
+      complexCurrents: toCircuitJsonComplexSamples(complexCurrentSamples),
+      probeMetadata
+    });
   }
-  return plotMap;
+  return simulationGraphs;
+};
+
+// lib/dc-sweep-result-to-graphs.ts
+var dcSweepResultToGraphs = ({
+  eecircuitResult,
+  spiceString,
+  sweepUnit
+}) => {
+  const [sweepCoordinateOutput, ...simulationOutputs] = eecircuitResult.data;
+  if (!sweepCoordinateOutput) return [];
+  const { voltageSamplesBySpiceVector, currentSamplesBySpiceVector } = getRealSampleMaps(simulationOutputs);
+  const voltageProbeMetadataBySpiceVector = extractVoltageProbeMetadata(spiceString);
+  const currentProbeMetadataBySpiceVector = extractCurrentProbeMetadata(spiceString);
+  const simulationGraphs = [];
+  for (const [
+    normalizedSpiceVector,
+    originalSpiceVector
+  ] of getRequestedPlotByNormalizedSpiceVector({
+    spiceString,
+    simulationOutputs
+  })) {
+    if (normalizedSpiceVector.startsWith("v(")) {
+      const voltageSamples = getRealVoltageSamples({
+        normalizedSpiceVector,
+        originalSpiceVector,
+        voltageSamplesBySpiceVector
+      });
+      if (!voltageSamples) continue;
+      const probeMetadata2 = voltageProbeMetadataBySpiceVector.get(
+        normalizedSpiceVector
+      );
+      simulationGraphs.push({
+        graphType: "voltage",
+        analysisType: "dc_sweep",
+        netName: probeMetadata2?.name ?? getNetName(originalSpiceVector),
+        sweepValues: sweepCoordinateOutput.values,
+        sweepUnit,
+        voltage: voltageSamples,
+        probeMetadata: probeMetadata2
+      });
+      continue;
+    }
+    const currentSamples = currentSamplesBySpiceVector.get(
+      normalizedSpiceVector
+    );
+    if (!currentSamples) continue;
+    const probeMetadata = currentProbeMetadataBySpiceVector.get(
+      normalizedSpiceVector
+    );
+    simulationGraphs.push({
+      graphType: "current",
+      analysisType: "dc_sweep",
+      currentName: probeMetadata?.name ?? getCurrentName(originalSpiceVector),
+      sweepValues: sweepCoordinateOutput.values,
+      sweepUnit,
+      current: currentSamples,
+      probeMetadata
+    });
+  }
+  return simulationGraphs;
 };
 
 // lib/linear-interpolate.ts
@@ -340,77 +581,182 @@ var linearInterpolate = (targetX, xPoints, yPoints) => {
   return y1 + (y2 - y1) * (targetX - x1) / (x2 - x1);
 };
 
+// lib/operating-point-result-to-graphs.ts
+var operatingPointResultToGraphs = ({
+  eecircuitResult,
+  spiceString
+}) => {
+  const simulationOutputs = eecircuitResult.data;
+  const { voltageSamplesBySpiceVector, currentSamplesBySpiceVector } = getRealSampleMaps(simulationOutputs);
+  const voltageProbeMetadataBySpiceVector = extractVoltageProbeMetadata(spiceString);
+  const currentProbeMetadataBySpiceVector = extractCurrentProbeMetadata(spiceString);
+  const simulationGraphs = [];
+  for (const [
+    normalizedSpiceVector,
+    originalSpiceVector
+  ] of getRequestedPlotByNormalizedSpiceVector({
+    spiceString,
+    simulationOutputs
+  })) {
+    if (normalizedSpiceVector.startsWith("v(")) {
+      const voltage = getRealVoltageSamples({
+        normalizedSpiceVector,
+        originalSpiceVector,
+        voltageSamplesBySpiceVector
+      })?.[0];
+      if (voltage === void 0) continue;
+      const probeMetadata2 = voltageProbeMetadataBySpiceVector.get(
+        normalizedSpiceVector
+      );
+      simulationGraphs.push({
+        graphType: "voltage",
+        analysisType: "dc_operating_point",
+        netName: probeMetadata2?.name ?? getNetName(originalSpiceVector),
+        voltage,
+        probeMetadata: probeMetadata2
+      });
+      continue;
+    }
+    const current = currentSamplesBySpiceVector.get(normalizedSpiceVector)?.[0];
+    if (current === void 0) continue;
+    const probeMetadata = currentProbeMetadataBySpiceVector.get(
+      normalizedSpiceVector
+    );
+    simulationGraphs.push({
+      graphType: "current",
+      analysisType: "dc_operating_point",
+      currentName: probeMetadata?.name ?? getCurrentName(originalSpiceVector),
+      current,
+      probeMetadata
+    });
+  }
+  return simulationGraphs;
+};
+
+// lib/parse-simulation-analysis.ts
+import { Ac, Dc, Op, parseSpiceNetlist as parseSpiceNetlist3, Tran as Tran2 } from "spicets";
+var parseSimulationAnalysis = (spiceString) => {
+  const analyses = parseSpiceNetlist3(spiceString, {
+    dialect: "ngspice"
+  }).analyses;
+  if (analyses.some((analysis) => analysis instanceof Tran2)) {
+    return { type: "transient" };
+  }
+  if (analyses.some((analysis) => analysis instanceof Op)) {
+    return { type: "dc_operating_point" };
+  }
+  const dcSweep = analyses.find((analysis) => analysis instanceof Dc);
+  if (dcSweep) {
+    const source = dcSweep.sweeps[0]?.source;
+    return {
+      type: "dc_sweep",
+      sweepUnit: source?.toLowerCase().startsWith("i") ? "A" : "V"
+    };
+  }
+  if (analyses.some((analysis) => analysis instanceof Ac)) {
+    return { type: "ac_sweep" };
+  }
+  return null;
+};
+
 // lib/eecircuit-result-to-simulation-graphs.ts
 var eecircuitResultToSimulationGraphs = (result, spiceString) => {
+  const analysis = parseSimulationAnalysis(spiceString);
+  if (analysis?.type === "dc_operating_point") {
+    return result.dataType === "real" ? operatingPointResultToGraphs({ eecircuitResult: result, spiceString }) : [];
+  }
+  if (analysis?.type === "dc_sweep") {
+    return result.dataType === "real" ? dcSweepResultToGraphs({
+      eecircuitResult: result,
+      spiceString,
+      sweepUnit: analysis.sweepUnit
+    }) : [];
+  }
+  if (analysis?.type === "ac_sweep") {
+    return result.dataType === "complex" ? acSweepResultToGraphs({ eecircuitResult: result, spiceString }) : [];
+  }
   if (!result?.data || result.dataType !== "real") {
     return [];
   }
-  const timeData = result.data.find((item) => item.type === "time");
-  if (!timeData || !Array.isArray(timeData.values)) {
+  const timeOutput = result.data.find(
+    (simulationOutput) => simulationOutput.type === "time"
+  );
+  if (!timeOutput || !Array.isArray(timeOutput.values)) {
     return [];
   }
-  const timeValues = timeData.values;
-  const voltageDataItems = result.data.filter(
-    (item) => item.type === "voltage" && Array.isArray(item.values)
+  const timeSeconds = timeOutput.values;
+  const voltageOutputs = result.data.filter(
+    (simulationOutput) => simulationOutput.type === "voltage" && Array.isArray(simulationOutput.values)
   );
-  const voltageDataMap = /* @__PURE__ */ new Map();
-  for (const item of voltageDataItems) {
-    voltageDataMap.set(item.name.toLowerCase(), item.values);
+  const voltageSamplesBySpiceVector = /* @__PURE__ */ new Map();
+  for (const voltageOutput of voltageOutputs) {
+    voltageSamplesBySpiceVector.set(
+      normalizeSpiceVector(voltageOutput.name),
+      voltageOutput.values
+    );
   }
-  const currentDataItems = result.data.filter(
-    (item) => item.type === "current" && Array.isArray(item.values)
+  const currentOutputs = result.data.filter(
+    (simulationOutput) => simulationOutput.type === "current" && Array.isArray(simulationOutput.values)
   );
-  const currentDataMap = /* @__PURE__ */ new Map();
-  for (const item of currentDataItems) {
-    currentDataMap.set(normalizeSpiceVector(item.name), item.values);
-  }
-  const requestedPlots = extractRequestedPlots(spiceString);
-  const voltageProbeMetadata = extractVoltageProbeMetadata(spiceString);
-  const currentProbeMetadata = extractCurrentProbeMetadata(spiceString);
-  if (!requestedPlots) {
+  const currentSamplesBySpiceVector = /* @__PURE__ */ new Map();
+  for (const currentOutput of currentOutputs) {
+    currentSamplesBySpiceVector.set(
+      normalizeSpiceVector(currentOutput.name),
+      currentOutput.values
+    );
+  }
+  const requestedPlotByNormalizedSpiceVector = extractRequestedPlots(spiceString);
+  const voltageProbeMetadataBySpiceVector = extractVoltageProbeMetadata(spiceString);
+  const currentProbeMetadataBySpiceVector = extractCurrentProbeMetadata(spiceString);
+  if (!requestedPlotByNormalizedSpiceVector) {
     return [
-      ...voltageDataItems.map((item) => {
-        const metadata = voltageProbeMetadata.get(
-          normalizeSpiceVector(item.name)
+      ...voltageOutputs.map((voltageOutput) => {
+        const probeMetadata = voltageProbeMetadataBySpiceVector.get(
+          normalizeSpiceVector(voltageOutput.name)
         );
         const voltageGraph = {
           graphType: "voltage",
-          netName: metadata?.name ?? getNetName(item.name),
-          time: timeValues,
-          voltage: item.values,
-          probeMetadata: metadata
+          analysisType: "transient",
+          netName: probeMetadata?.name ?? getNetName(voltageOutput.name),
+          time: timeSeconds,
+          voltage: voltageOutput.values,
+          probeMetadata
         };
         return voltageGraph;
       }),
-      ...currentDataItems.map((item) => {
-        const metadata = currentProbeMetadata.get(
-          normalizeSpiceVector(item.name)
+      ...currentOutputs.map((currentOutput) => {
+        const probeMetadata = currentProbeMetadataBySpiceVector.get(
+          normalizeSpiceVector(currentOutput.name)
         );
         const currentGraph = {
           graphType: "current",
-          currentName: metadata?.name ?? getCurrentName(item.name),
-          time: timeValues,
-          current: item.values,
-          probeMetadata: metadata
+          analysisType: "transient",
+          currentName: probeMetadata?.name ?? getCurrentName(currentOutput.name),
+          time: timeSeconds,
+          current: currentOutput.values,
+          probeMetadata
         };
         return currentGraph;
       })
     ];
   }
   const graphs = [];
-  for (const [lowerCaseToken, originalToken] of requestedPlots.entries()) {
+  for (const [
+    normalizedSpiceVector,
+    originalSpiceVector
+  ] of requestedPlotByNormalizedSpiceVector) {
     const graph = createVoltageGraphFromRequestedPlot({
-      lowerCaseToken,
-      originalToken,
-      timeValues,
-      voltageDataMap,
-      voltageProbeMetadata
+      normalizedSpiceVector,
+      originalSpiceVector,
+      timeSeconds,
+      voltageSamplesBySpiceVector,
+      voltageProbeMetadataBySpiceVector
     }) ?? createCurrentGraphFromRequestedPlot({
-      lowerCaseToken,
-      originalToken,
-      timeValues,
-      currentDataMap,
-      currentProbeMetadata
+      normalizedSpiceVector,
+      originalSpiceVector,
+      timeSeconds,
+      currentSamplesBySpiceVector,
+      currentProbeMetadataBySpiceVector
     });
     if (graph) graphs.push(graph);
   }
@@ -449,50 +795,123 @@ var eecircuitResultToSimulationGraphs = (result, spiceString) => {
 };
 var eecircuitResultToVGraphs = (result, spiceString) => {
   return eecircuitResultToSimulationGraphs(result, spiceString).filter(
-    (graph) => graph.graphType === "voltage"
+    (graph) => graph.graphType === "voltage" && graph.analysisType === "transient"
   );
 };
 
 // lib/simulation-graphs-to-circuit-json.ts
+var simulationExperimentId = "placeholder_simulation_experiment_id";
 var simulationGraphsToCircuitJson = (graphs, spiceString) => {
   const tranParams = parseTranParams(spiceString);
   return graphs.map((graph, index) => {
-    if (graph.graphType === "voltage") {
-      const graphIdSource2 = graph.probeMetadata?.simulation_voltage_probe_id ?? `${index}_${graph.netName}`;
-      const graphElement2 = {
-        type: "simulation_transient_voltage_graph",
-        simulation_experiment_id: "placeholder_simulation_experiment_id",
-        simulation_transient_voltage_graph_id: `simulation_graph_${graphIdSource2}`,
-        name: graph.netName,
-        voltage_levels: graph.voltage,
+    if (graph.analysisType === "transient") {
+      if (graph.graphType === "voltage") {
+        const graphIdSource2 = graph.probeMetadata?.simulation_voltage_probe_id ?? `${index}_${graph.netName}`;
+        const graphElement2 = {
+          type: "simulation_transient_voltage_graph",
+          simulation_experiment_id: simulationExperimentId,
+          simulation_transient_voltage_graph_id: `simulation_graph_${graphIdSource2}`,
+          name: graph.netName,
+          voltage_levels: graph.voltage,
+          timestamps_ms: graph.time.map((timePoint) => timePoint * 1e3),
+          start_time_ms: (tranParams?.tstart ?? 0) * 1e3,
+          time_per_step: (tranParams?.tstep ?? 0) * 1e3,
+          end_time_ms: (tranParams?.tstop ?? 0) * 1e3,
+          source_probe_id: graph.probeMetadata?.simulation_voltage_probe_id,
+          source_probe_name: graph.probeMetadata?.name,
+          source_node_name: graph.probeMetadata?.source_node_name,
+          reference_node_name: graph.probeMetadata?.reference_node_name
+        };
+        return graphElement2;
+      }
+      const graphIdSource = graph.probeMetadata?.simulation_current_probe_id ?? `${index}_${graph.currentName}`;
+      const graphElement = {
+        type: "simulation_transient_current_graph",
+        simulation_experiment_id: simulationExperimentId,
+        simulation_transient_current_graph_id: `simulation_graph_${graphIdSource}`,
+        name: graph.currentName,
+        current_levels: graph.current,
         timestamps_ms: graph.time.map((timePoint) => timePoint * 1e3),
         start_time_ms: (tranParams?.tstart ?? 0) * 1e3,
         time_per_step: (tranParams?.tstep ?? 0) * 1e3,
         end_time_ms: (tranParams?.tstop ?? 0) * 1e3,
-        source_probe_id: graph.probeMetadata?.simulation_voltage_probe_id,
+        source_probe_id: graph.probeMetadata?.simulation_current_probe_id,
         source_probe_name: graph.probeMetadata?.name,
-        source_node_name: graph.probeMetadata?.source_node_name,
-        reference_node_name: graph.probeMetadata?.reference_node_name
+        source_component_id: graph.probeMetadata?.source_component_id,
+        source_trace_id: graph.probeMetadata?.source_trace_id
+      };
+      return graphElement;
+    }
+    if (graph.analysisType === "dc_operating_point") {
+      if (graph.graphType === "voltage") {
+        const probeId3 = graph.probeMetadata?.simulation_voltage_probe_id ?? `simulation_voltage_probe_${index}_${graph.netName}`;
+        return {
+          type: "simulation_dc_operating_point_voltage",
+          simulation_dc_operating_point_voltage_id: `simulation_dc_operating_point_voltage_${probeId3}`,
+          simulation_experiment_id: simulationExperimentId,
+          simulation_voltage_probe_id: probeId3,
+          voltage: graph.voltage,
+          name: graph.netName
+        };
+      }
+      const probeId2 = graph.probeMetadata?.simulation_current_probe_id ?? `simulation_current_probe_${index}_${graph.currentName}`;
+      return {
+        type: "simulation_dc_operating_point_current",
+        simulation_dc_operating_point_current_id: `simulation_dc_operating_point_current_${probeId2}`,
+        simulation_experiment_id: simulationExperimentId,
+        simulation_current_probe_id: probeId2,
+        current: graph.current,
+        name: graph.currentName
       };
-      return graphElement2;
     }
-    const graphIdSource = graph.probeMetadata?.simulation_current_probe_id ?? `${index}_${graph.currentName}`;
-    const graphElement = {
-      type: "simulation_transient_current_graph",
-      simulation_experiment_id: "placeholder_simulation_experiment_id",
-      simulation_transient_current_graph_id: `simulation_graph_${graphIdSource}`,
-      name: graph.currentName,
-      current_levels: graph.current,
-      timestamps_ms: graph.time.map((timePoint) => timePoint * 1e3),
-      start_time_ms: (tranParams?.tstart ?? 0) * 1e3,
-      time_per_step: (tranParams?.tstep ?? 0) * 1e3,
-      end_time_ms: (tranParams?.tstop ?? 0) * 1e3,
-      source_probe_id: graph.probeMetadata?.simulation_current_probe_id,
-      source_probe_name: graph.probeMetadata?.name,
-      source_component_id: graph.probeMetadata?.source_component_id,
-      source_trace_id: graph.probeMetadata?.source_trace_id
+    if (graph.analysisType === "dc_sweep") {
+      if (graph.graphType === "voltage") {
+        const probeId3 = graph.probeMetadata?.simulation_voltage_probe_id ?? `simulation_voltage_probe_${index}_${graph.netName}`;
+        return {
+          type: "simulation_dc_sweep_voltage_graph",
+          simulation_dc_sweep_voltage_graph_id: `simulation_dc_sweep_voltage_graph_${probeId3}`,
+          simulation_experiment_id: simulationExperimentId,
+          simulation_voltage_probe_id: probeId3,
+          sweep_values: graph.sweepValues,
+          sweep_unit: graph.sweepUnit,
+          voltage_levels: graph.voltage,
+          name: graph.netName
+        };
+      }
+      const probeId2 = graph.probeMetadata?.simulation_current_probe_id ?? `simulation_current_probe_${index}_${graph.currentName}`;
+      return {
+        type: "simulation_dc_sweep_current_graph",
+        simulation_dc_sweep_current_graph_id: `simulation_dc_sweep_current_graph_${probeId2}`,
+        simulation_experiment_id: simulationExperimentId,
+        simulation_current_probe_id: probeId2,
+        sweep_values: graph.sweepValues,
+        sweep_unit: graph.sweepUnit,
+        current_levels: graph.current,
+        name: graph.currentName
+      };
+    }
+    if (graph.graphType === "voltage") {
+      const probeId2 = graph.probeMetadata?.simulation_voltage_probe_id ?? `simulation_voltage_probe_${index}_${graph.netName}`;
+      return {
+        type: "simulation_ac_sweep_voltage_graph",
+        simulation_ac_sweep_voltage_graph_id: `simulation_ac_sweep_voltage_graph_${probeId2}`,
+        simulation_experiment_id: simulationExperimentId,
+        simulation_voltage_probe_id: probeId2,
+        frequencies_hz: graph.frequenciesHz,
+        complex_voltages: graph.complexVoltages,
+        name: graph.netName
+      };
+    }
+    const probeId = graph.probeMetadata?.simulation_current_probe_id ?? `simulation_current_probe_${index}_${graph.currentName}`;
+    return {
+      type: "simulation_ac_sweep_current_graph",
+      simulation_ac_sweep_current_graph_id: `simulation_ac_sweep_current_graph_${probeId}`,
+      simulation_experiment_id: simulationExperimentId,
+      simulation_current_probe_id: probeId,
+      frequencies_hz: graph.frequenciesHz,
+      complex_currents: graph.complexCurrents,
+      name: graph.currentName
     };
-    return graphElement;
   });
 };
 
@@ -517,13 +936,7 @@ var simulate = async (spiceString) => {
   const simulation = await getSimulation();
   const simulationSpiceString = rewritePspiceCompatibilitySyntax(spiceString);
   simulation.setNetList(simulationSpiceString);
-  let result;
-  try {
-    result = await simulation.runSim();
-  } catch (error) {
-    console.error(error);
-    throw error;
-  }
+  const result = await simulation.runSim();
   if (!result) {
     return { simulationResultCircuitJson: [] };
   }
@@ -549,6 +962,7 @@ export {
   index_default as default,
   eecircuitResultToSimulationGraphs,
   eecircuitResultToVGraphs,
+  parseSimulationAnalysis,
   parseTranParams,
   rewritePspiceCompatibilitySyntax,
   simulationGraphsToCircuitJson

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tscircuit/ngspice-spice-engine",
-  "version": "0.0.18",
+  "version": "0.0.20",
   "description": "A tscircuit-compatible SPICE engine using ngspice.",
   "type": "module",
   "main": "./dist/index.js",
@@ -17,19 +17,21 @@
     "typecheck": "tsc --noEmit"
   },
   "devDependencies": {
-    "@tscircuit/props": "^0.0.551",
+    "@tscircuit/props": "^0.0.592",
     "bun-match-svg": "^0.0.14",
-    "circuit-json": "^0.0.437",
-    "circuit-to-svg": "^0.0.357",
+    "circuit-json": "^0.0.454",
+    "circuit-to-svg": "^0.0.393",
     "format-si-unit": "^0.0.7",
     "@biomejs/biome": "^2.2.7",
     "@types/bun": "latest",
+    "spicets": "^0.0.4",
     "tscircuit": "^0.0.805",
     "tsup": "^8.5.0"
   },
   "peerDependencies": {
     "typescript": "^5",
     "circuit-json": "*",
-    "@tscircuit/props": "*"
+    "@tscircuit/props": "*",
+    "spicets": "*"
   }
 }