@tscircuit/ngspice-spice-engine 0.0.15 → 0.0.17

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import { SpiceEngine } from '@tscircuit/props';
 import { ResultType } from '@tscircuit/eecircuit-engine';
+import { SimulationTransientVoltageGraph, SimulationTransientCurrentGraph } from 'circuit-json';
 
 interface TranParams {
     tstep?: number;
@@ -10,20 +11,43 @@ interface TranParams {
 }
 declare const parseTranParams: (spiceString: string) => TranParams | null;
 
-interface VoltageGraph {
-    netName: string;
-    time: number[];
-    voltage: number[];
-    probeMetadata?: ProbeMetadata;
-}
-interface ProbeMetadata {
+declare const rewritePspiceCompatibilitySyntax: (spiceString: string) => string;
+
+interface VoltageProbeMetadata {
     simulation_voltage_probe_id: string;
     name?: string;
     spice_vector: string;
     source_node_name: string;
     reference_node_name?: string;
 }
+interface CurrentProbeMetadata {
+    simulation_current_probe_id: string;
+    name?: string;
+    spice_vector: string;
+    source_component_id?: string;
+    source_trace_id?: string;
+}
+interface VoltageGraph {
+    graphType: "voltage";
+    netName: string;
+    time: number[];
+    voltage: number[];
+    probeMetadata?: VoltageProbeMetadata;
+}
+interface CurrentGraph {
+    graphType: "current";
+    currentName: string;
+    time: number[];
+    current: number[];
+    probeMetadata?: CurrentProbeMetadata;
+}
+type SimulationGraph = VoltageGraph | CurrentGraph;
+
+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 createNgspiceSpiceEngine: () => Promise<SpiceEngine>;
 
-export { type TranParams, createNgspiceSpiceEngine, createNgspiceSpiceEngine as default, eecircuitResultToVGraphs, parseTranParams };
+export { type TranParams, createNgspiceSpiceEngine, createNgspiceSpiceEngine as default, eecircuitResultToSimulationGraphs, eecircuitResultToVGraphs, parseTranParams, rewritePspiceCompatibilitySyntax, simulationGraphsToCircuitJson };

package/dist/index.js

@@ -1,28 +1,3 @@
-// lib/linear-interpolate.ts
-var linearInterpolate = (targetX, xPoints, yPoints) => {
-  if (xPoints.length === 0) {
-    return 0;
-  }
-  if (targetX <= xPoints[0]) {
-    return yPoints[0];
-  }
-  if (targetX >= xPoints[xPoints.length - 1]) {
-    return yPoints[yPoints.length - 1];
-  }
-  let i = 1;
-  while (i < xPoints.length && xPoints[i] < targetX) {
-    i++;
-  }
-  const x1 = xPoints[i - 1];
-  const y1 = yPoints[i - 1];
-  const x2 = xPoints[i];
-  const y2 = yPoints[i];
-  if (x2 === x1) {
-    return y1;
-  }
-  return y1 + (y2 - y1) * (targetX - x1) / (x2 - x1);
-};
-
 // lib/parse-tran-params.ts
 var SUFFIX_MULTIPLIERS = {
   t: 1e12,
@@ -108,43 +83,149 @@ var parseTranParams = (spiceString) => {
   return null;
 };
 
-// lib/index.ts
-var ensureSimulation = async () => {
-  const { Simulation: SimulationCtor } = await import("@tscircuit/eecircuit-engine");
-  const instance = new SimulationCtor({ ngBehavior: "psa" });
-  await instance.start();
-  return instance;
-};
-var simulationPromise = null;
-var getSimulation = async () => {
-  if (!simulationPromise) {
-    simulationPromise = ensureSimulation().catch((error) => {
-      simulationPromise = null;
-      throw error;
+// lib/rewrite-pspice-compatibility-syntax.ts
+var pspiceNumberToken = String.raw`([+-]?(?:(?:\d+(?:\.\d*)?)|(?:\.\d+))(?:[eE][+-]?\d+)?)`;
+var rewritePspiceResistorTcPairs = (spiceString) => spiceString.split(/\r?\n/).map((line) => {
+  if (!/^\s*r/i.test(line)) return line;
+  return line.replace(
+    new RegExp(
+      String.raw`\bTC\s*=\s*${pspiceNumberToken}\s*,\s*${pspiceNumberToken}\b`,
+      "gi"
+    ),
+    "TC1=$1 TC2=$2"
+  );
+}).join("\n");
+var pspiceComparisonOperator = "(?:<=|>=|==|!=|(?<![!<>=])=(?!=)|<|>)";
+var pspiceComparisonOperand = String.raw`(?:V\s*\([^)]*\)|\{[^}\r\n]+\}|${pspiceNumberToken}(?:[a-zA-Z]+)?|[A-Za-z_][\w.$]*)`;
+var pspiceComparisonExpression = String.raw`${pspiceComparisonOperand}\s*${pspiceComparisonOperator}\s*${pspiceComparisonOperand}`;
+var pspiceComparisonBeforeCaretPattern = new RegExp(
+  String.raw`${pspiceComparisonExpression}\s*$`,
+  "i"
+);
+var pspiceComparisonAfterCaretPattern = new RegExp(
+  String.raw`^\s*\+?\s*${pspiceComparisonExpression}`,
+  "i"
+);
+var isPspiceBooleanCaret = (block, caretOffset, operatorLength) => pspiceComparisonBeforeCaretPattern.test(block.slice(0, caretOffset)) && pspiceComparisonAfterCaretPattern.test(
+  block.slice(caretOffset + operatorLength)
+);
+var rewritePspiceValueBooleanCarets = (spiceString) => {
+  let result = "";
+  let cursor = 0;
+  const valueStartPattern = /\bVALUE\s*\{/gi;
+  for (; ; ) {
+    valueStartPattern.lastIndex = cursor;
+    const match = valueStartPattern.exec(spiceString);
+    if (!match) break;
+    const blockStart = match.index;
+    const firstBraceIndex = spiceString.indexOf("{", blockStart);
+    let depth = 0;
+    let blockEnd = -1;
+    for (let i = firstBraceIndex; i < spiceString.length; i++) {
+      const char = spiceString[i];
+      if (char === "{") {
+        depth += 1;
+      } else if (char === "}") {
+        depth -= 1;
+        if (depth === 0) {
+          blockEnd = i + 1;
+          break;
+        }
+      }
+    }
+    if (blockEnd === -1) break;
+    result += spiceString.slice(cursor, blockStart);
+    const block = spiceString.slice(blockStart, blockEnd);
+    result += block.replace(/\s+\^\s+/g, (operator, offset, fullBlock) => {
+      if (isPspiceBooleanCaret(fullBlock, offset, operator.length)) {
+        return operator.replace("^", "!=");
+      }
+      return operator;
     });
+    cursor = blockEnd;
   }
-  return simulationPromise;
+  return result + spiceString.slice(cursor);
 };
-var extractRequestedPlots = (spiceString) => {
-  const match = spiceString.match(/\.print\s+tran\s+(.*)/i);
-  if (!match || !match[1]) {
-    return null;
+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()}`;
   }
-  const tokens = match[1].match(/[VI]\s*\([^)]+\)/gi);
-  if (!tokens) {
-    return null;
+  const match = rawName.match(/^v\((.*)\)$/i);
+  if (!match) {
+    return rawName;
   }
-  const plotMap = /* @__PURE__ */ new Map();
-  for (const token of tokens) {
-    const lowerCaseToken = token.toLowerCase().replace(/\s/g, "");
-    if (!plotMap.has(lowerCaseToken)) {
-      plotMap.set(lowerCaseToken, token);
+  return match[1] ?? rawName;
+};
+var getCurrentName = (rawName) => {
+  const match = rawName.match(/^i\((.*)\)$/i);
+  if (!match) {
+    return rawName;
+  }
+  return match[1] ?? rawName;
+};
+var createVoltageGraphFromRequestedPlot = ({
+  lowerCaseToken,
+  originalToken,
+  timeValues,
+  voltageDataMap,
+  voltageProbeMetadata
+}) => {
+  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));
+      }
     }
+  } else {
+    voltage = voltageDataMap.get(lowerCaseToken);
   }
-  return plotMap;
+  if (!voltage) return null;
+  const metadata = voltageProbeMetadata.get(lowerCaseToken);
+  const voltageGraph = {
+    graphType: "voltage",
+    netName: metadata?.name ?? getNetName(originalToken),
+    time: timeValues,
+    voltage,
+    probeMetadata: metadata
+  };
+  return voltageGraph;
 };
+var createCurrentGraphFromRequestedPlot = ({
+  lowerCaseToken,
+  originalToken,
+  timeValues,
+  currentDataMap,
+  currentProbeMetadata
+}) => {
+  if (!lowerCaseToken.startsWith("i(")) return null;
+  const current = currentDataMap.get(lowerCaseToken);
+  if (!current) return null;
+  const metadata = currentProbeMetadata.get(lowerCaseToken);
+  const currentGraph = {
+    graphType: "current",
+    currentName: metadata?.name ?? getCurrentName(originalToken),
+    time: timeValues,
+    current,
+    probeMetadata: metadata
+  };
+  return currentGraph;
+};
+
+// lib/extract-probe-metadata.ts
 var normalizeSpiceVector = (value) => value.toLowerCase().replace(/\s/g, "");
-var extractProbeMetadata = (spiceString) => {
+var extractVoltageProbeMetadata = (spiceString) => {
   const metadata = /* @__PURE__ */ new Map();
   for (const line of spiceString.split(/\r?\n/)) {
     const match = line.match(/^\s*\*\s*tscircuit_probe\s+(.+)\s*$/);
@@ -154,32 +235,93 @@ var extractProbeMetadata = (spiceString) => {
       if (typeof parsed.simulation_voltage_probe_id !== "string" || typeof parsed.spice_vector !== "string" || typeof parsed.source_node_name !== "string") {
         continue;
       }
-      metadata.set(normalizeSpiceVector(parsed.spice_vector), {
+      const normalizedSpiceVector = normalizeSpiceVector(parsed.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
-      });
+      };
+      metadata.set(normalizedSpiceVector, voltageProbeMetadata);
     } catch {
-      continue;
     }
   }
   return metadata;
 };
-var getNetName = (rawName) => {
-  const diffMatch = rawName.match(/^v\(([^,]+),\s*([^)]+)\)$/i);
-  if (diffMatch?.[1] && diffMatch?.[2]) {
-    return `${diffMatch[1].trim()}-${diffMatch[2].trim()}`;
+var extractCurrentProbeMetadata = (spiceString) => {
+  const metadata = /* @__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") {
+        continue;
+      }
+      const normalizedSpiceVector = normalizeSpiceVector(parsed.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
+      };
+      metadata.set(normalizedSpiceVector, currentProbeMetadata);
+    } catch {
+    }
   }
-  const match = rawName.match(/^v\((.*)\)$/i);
-  if (!match) {
-    return rawName;
+  return metadata;
+};
+
+// lib/extract-requested-plots.ts
+var extractRequestedPlots = (spiceString) => {
+  const match = spiceString.match(/\.print\s+tran\s+(.*)/i);
+  if (!match?.[1]) {
+    return null;
   }
-  return match[1] ?? rawName;
+  const tokens = match[1].match(/[VI]\s*\([^)]+\)/gi);
+  if (!tokens) {
+    return null;
+  }
+  const plotMap = /* @__PURE__ */ new Map();
+  for (const token of tokens) {
+    const lowerCaseToken = token.toLowerCase().replace(/\s/g, "");
+    if (!plotMap.has(lowerCaseToken)) {
+      plotMap.set(lowerCaseToken, token);
+    }
+  }
+  return plotMap;
 };
-var eecircuitResultToVGraphs = (result, spiceString) => {
-  if (!result || !result.data || result.dataType !== "real") {
+
+// lib/linear-interpolate.ts
+var linearInterpolate = (targetX, xPoints, yPoints) => {
+  if (xPoints.length === 0) {
+    return 0;
+  }
+  if (targetX <= xPoints[0]) {
+    return yPoints[0];
+  }
+  if (targetX >= xPoints[xPoints.length - 1]) {
+    return yPoints[yPoints.length - 1];
+  }
+  let i = 1;
+  while (i < xPoints.length && xPoints[i] < targetX) {
+    i++;
+  }
+  const x1 = xPoints[i - 1];
+  const y1 = yPoints[i - 1];
+  const x2 = xPoints[i];
+  const y2 = yPoints[i];
+  if (x2 === x1) {
+    return y1;
+  }
+  return y1 + (y2 - y1) * (targetX - x1) / (x2 - x1);
+};
+
+// lib/eecircuit-result-to-simulation-graphs.ts
+var eecircuitResultToSimulationGraphs = (result, spiceString) => {
+  if (!result?.data || result.dataType !== "real") {
     return [];
   }
   const timeData = result.data.find((item) => item.type === "time");
@@ -194,46 +336,62 @@ var eecircuitResultToVGraphs = (result, spiceString) => {
   for (const item of voltageDataItems) {
     voltageDataMap.set(item.name.toLowerCase(), item.values);
   }
+  const currentDataItems = result.data.filter(
+    (item) => item.type === "current" && Array.isArray(item.values)
+  );
+  const currentDataMap = /* @__PURE__ */ new Map();
+  for (const item of currentDataItems) {
+    currentDataMap.set(normalizeSpiceVector(item.name), item.values);
+  }
   const requestedPlots = extractRequestedPlots(spiceString);
-  const probeMetadata = extractProbeMetadata(spiceString);
+  const voltageProbeMetadata = extractVoltageProbeMetadata(spiceString);
+  const currentProbeMetadata = extractCurrentProbeMetadata(spiceString);
   if (!requestedPlots) {
-    return voltageDataItems.map((item) => {
-      const metadata = probeMetadata.get(normalizeSpiceVector(item.name));
-      return {
-        netName: metadata?.name ?? getNetName(item.name),
-        time: timeValues,
-        voltage: item.values,
-        probeMetadata: metadata
-      };
-    });
+    return [
+      ...voltageDataItems.map((item) => {
+        const metadata = voltageProbeMetadata.get(
+          normalizeSpiceVector(item.name)
+        );
+        const voltageGraph = {
+          graphType: "voltage",
+          netName: metadata?.name ?? getNetName(item.name),
+          time: timeValues,
+          voltage: item.values,
+          probeMetadata: metadata
+        };
+        return voltageGraph;
+      }),
+      ...currentDataItems.map((item) => {
+        const metadata = currentProbeMetadata.get(
+          normalizeSpiceVector(item.name)
+        );
+        const currentGraph = {
+          graphType: "current",
+          currentName: metadata?.name ?? getCurrentName(item.name),
+          time: timeValues,
+          current: item.values,
+          probeMetadata: metadata
+        };
+        return currentGraph;
+      })
+    ];
   }
   const graphs = [];
   for (const [lowerCaseToken, originalToken] of requestedPlots.entries()) {
-    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));
-        }
-      }
-    } else {
-      voltage = voltageDataMap.get(lowerCaseToken);
-    }
-    if (voltage) {
-      const metadata = probeMetadata.get(lowerCaseToken);
-      graphs.push({
-        netName: metadata?.name ?? getNetName(originalToken),
-        time: timeValues,
-        voltage,
-        probeMetadata: metadata
-      });
-    }
+    const graph = createVoltageGraphFromRequestedPlot({
+      lowerCaseToken,
+      originalToken,
+      timeValues,
+      voltageDataMap,
+      voltageProbeMetadata
+    }) ?? createCurrentGraphFromRequestedPlot({
+      lowerCaseToken,
+      originalToken,
+      timeValues,
+      currentDataMap,
+      currentProbeMetadata
+    });
+    if (graph) graphs.push(graph);
   }
   const tranParams = parseTranParams(spiceString);
   if (tranParams?.tstep && tranParams.tstep > 0 && tranParams.tstop && graphs.length > 0) {
@@ -246,42 +404,98 @@ var eecircuitResultToVGraphs = (result, spiceString) => {
         (_, i) => tstart + i * tstep
       );
       const oldTimeValues = graphs[0].time;
-      return graphs.map((graph) => ({
-        ...graph,
-        time: newTimeValues,
-        voltage: newTimeValues.map(
-          (t) => linearInterpolate(t, oldTimeValues, graph.voltage)
-        )
-      }));
+      return graphs.map((graph) => {
+        if (graph.graphType === "voltage") {
+          return {
+            ...graph,
+            time: newTimeValues,
+            voltage: newTimeValues.map(
+              (t) => linearInterpolate(t, oldTimeValues, graph.voltage)
+            )
+          };
+        }
+        return {
+          ...graph,
+          time: newTimeValues,
+          current: newTimeValues.map(
+            (t) => linearInterpolate(t, oldTimeValues, graph.current)
+          )
+        };
+      });
     }
   }
   return graphs;
 };
-var voltageGraphsToCircuitJson = (graphs, spiceString) => {
+var eecircuitResultToVGraphs = (result, spiceString) => {
+  return eecircuitResultToSimulationGraphs(result, spiceString).filter(
+    (graph) => graph.graphType === "voltage"
+  );
+};
+
+// lib/simulation-graphs-to-circuit-json.ts
+var simulationGraphsToCircuitJson = (graphs, spiceString) => {
   const tranParams = parseTranParams(spiceString);
   return graphs.map((graph, index) => {
-    const graphIdSource = graph.probeMetadata?.simulation_voltage_probe_id ?? `${index}_${graph.netName}`;
+    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,
+        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_voltage_graph",
+      type: "simulation_transient_current_graph",
       simulation_experiment_id: "placeholder_simulation_experiment_id",
-      simulation_transient_voltage_graph_id: `simulation_graph_${graphIdSource}`,
-      name: graph.netName,
-      voltage_levels: graph.voltage,
+      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;
   });
 };
+
+// lib/index.ts
+var ensureSimulation = async () => {
+  const { Simulation: SimulationCtor } = await import("@tscircuit/eecircuit-engine");
+  const instance = new SimulationCtor({ ngBehavior: "psa" });
+  await instance.start();
+  return instance;
+};
+var simulationPromise = null;
+var getSimulation = async () => {
+  if (!simulationPromise) {
+    simulationPromise = ensureSimulation().catch((error) => {
+      simulationPromise = null;
+      throw error;
+    });
+  }
+  return simulationPromise;
+};
 var simulate = async (spiceString) => {
   const simulation = await getSimulation();
-  simulation.setNetList(spiceString);
+  const simulationSpiceString = rewritePspiceCompatibilitySyntax(spiceString);
+  simulation.setNetList(simulationSpiceString);
   let result;
   try {
     result = await simulation.runSim();
@@ -292,11 +506,14 @@ var simulate = async (spiceString) => {
   if (!result) {
     return { simulationResultCircuitJson: [] };
   }
-  const graphs = eecircuitResultToVGraphs(result, spiceString);
+  const graphs = eecircuitResultToSimulationGraphs(
+    result,
+    simulationSpiceString
+  );
   return {
-    simulationResultCircuitJson: voltageGraphsToCircuitJson(
+    simulationResultCircuitJson: simulationGraphsToCircuitJson(
       graphs,
-      spiceString
+      simulationSpiceString
     )
   };
 };
@@ -309,6 +526,9 @@ var index_default = createNgspiceSpiceEngine;
 export {
   createNgspiceSpiceEngine,
   index_default as default,
+  eecircuitResultToSimulationGraphs,
   eecircuitResultToVGraphs,
-  parseTranParams
+  parseTranParams,
+  rewritePspiceCompatibilitySyntax,
+  simulationGraphsToCircuitJson
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tscircuit/ngspice-spice-engine",
-  "version": "0.0.15",
+  "version": "0.0.17",
   "description": "A tscircuit-compatible SPICE engine using ngspice.",
   "type": "module",
   "main": "./dist/index.js",
@@ -18,10 +18,10 @@
   },
   "devDependencies": {
     "@tscircuit/eecircuit-engine": "https://jscdn.tscircuit.com/@tscircuit/eecircuit-engine/1.7.4.tgz",
-    "@tscircuit/props": "^0.0.374",
+    "@tscircuit/props": "^0.0.551",
     "bun-match-svg": "^0.0.14",
-    "circuit-json": "^0.0.435",
-    "circuit-to-svg": "^0.0.217",
+    "circuit-json": "^0.0.437",
+    "circuit-to-svg": "^0.0.357",
     "format-si-unit": "^0.0.7",
     "@biomejs/biome": "^2.2.7",
     "@types/bun": "latest",