@tscircuit/cli 0.1.1320 → 0.1.1322

package/dist/cli/main.js

@@ -100574,7 +100574,7 @@ var import_perfect_cli = __toESM2(require_dist2(), 1);
 // lib/getVersion.ts
 import { createRequire as createRequire2 } from "node:module";
 // package.json
-var version = "0.1.1319";
+var version = "0.1.1321";
 var package_default = {
   name: "@tscircuit/cli",
   version,
@@ -100588,7 +100588,7 @@ var package_default = {
     "@biomejs/biome": "^1.9.4",
     "@tscircuit/circuit-json-placement-analysis": "^0.0.6",
     "@tscircuit/circuit-json-routing-analysis": "^0.0.1",
-    "@tscircuit/circuit-json-schematic-placement-analysis": "github:tscircuit/circuit-json-schematic-placement-analysis#add7fd89b1edce7fda0471a173409b8118d2723c",
+    "@tscircuit/circuit-json-schematic-placement-analysis": "github:tscircuit/circuit-json-schematic-placement-analysis#a8b1e6a5357f8a5aea4881f84ffda7c76d5cfe8e",
     "@tscircuit/fake-snippets": "^0.0.182",
     "@tscircuit/file-server": "^0.0.32",
     "@tscircuit/image-utils": "^0.0.3",
@@ -241260,8 +241260,9 @@ var generateCapacitorOrientationIssues = (componentPlacements, circuitJson) => {
   });
 };
 
-// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/analyzers/schematic-box-sizing.ts
-var SCHEMATIC_BOX_SIZING_MESSAGE = "Shrink schematic box width";
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/analyzers/schematic-box-sizing/shared.ts
+var SCHEMATIC_BOX_TOO_WIDE_MESSAGE = "Shrink schematic box width";
+var SCHEMATIC_PIN_PADDING_TO_EDGE_TOO_LARGE_MESSAGE = "Move schematic pins closer to the box edge or change the schematic box";
 var PIN_HEADER_SCHEMATIC_BOX_SIZING_MAX_ALLOWED_GAP = 0.1;
 var CHIP_SCHEMATIC_BOX_SIZING_MAX_ALLOWED_GAP = 1;
 var PIN_LABEL_EDGE_PADDING = 0.1;
@@ -241270,6 +241271,7 @@ var FALLBACK_CHARACTER_WIDTH = 0.13;
 var GAP_COMPARISON_EPSILON = 0.000000001;
 var isSchematicPort = (element) => element.type === "schematic_port";
 var isSourcePort = (element) => element.type === "source_port";
+var isSchematicComponent2 = (element) => element.type === "schematic_component";
 var getSourceComponentWithFtype = (element) => {
   if (element.type !== "source_component" || !("source_component_id" in element) || typeof element.source_component_id !== "string") {
     return null;
@@ -241281,11 +241283,15 @@ var getSourceComponentWithFtype = (element) => {
   };
 };
 var isHorizontalSide = (side) => side === "left" || side === "right";
+var isVerticalSide = (side) => side === "top" || side === "bottom";
 var getCenteredRectBounds = (box2) => {
   const halfWidth = box2.width / 2;
+  const halfHeight = box2.height / 2;
   return {
     left: box2.schX - halfWidth,
-    right: box2.schX + halfWidth
+    right: box2.schX + halfWidth,
+    top: box2.schY + halfHeight,
+    bottom: box2.schY - halfHeight
   };
 };
 var isPinNameLabel = (label, sourcePort) => {
@@ -241297,6 +241303,172 @@ var estimateLabelWidth = (label, sourcePort) => {
   const characterWidth = isPinNameLabel(label, sourcePort) ? PIN_NAME_CHARACTER_WIDTH : FALLBACK_CHARACTER_WIDTH;
   return Array.from(label).length * characterWidth;
 };
+var exceedsMaxAllowedGap = (measuredInnerLabelEmptySpace, maxAllowedInnerLabelEmptySpace) => measuredInnerLabelEmptySpace - maxAllowedInnerLabelEmptySpace > GAP_COMPARISON_EPSILON;
+var getSourcePortById = (circuitJson) => new Map(circuitJson.filter(isSourcePort).map((sourcePort) => [sourcePort.source_port_id, sourcePort]));
+var getSourceComponentById = (circuitJson) => new Map(circuitJson.flatMap((element) => {
+  const sourceComponent = getSourceComponentWithFtype(element);
+  return sourceComponent ? [sourceComponent] : [];
+}).map((sourceComponent) => [
+  sourceComponent.source_component_id,
+  sourceComponent
+]));
+var getSchematicComponentById = (circuitJson) => new Map(circuitJson.filter(isSchematicComponent2).map((schematicComponent) => [
+  schematicComponent.schematic_component_id,
+  schematicComponent
+]));
+var getPlacementBySchematicComponentId = (componentPlacements) => new Map(componentPlacements.filter((placement) => placement.schematicComponentId).map((placement) => [placement.schematicComponentId, placement]));
+var getPortsBySchematicComponentId = (circuitJson, isRelevantSide) => {
+  const portsBySchematicComponentId = new Map;
+  for (const port of circuitJson.filter(isSchematicPort)) {
+    if (!port.schematic_component_id)
+      continue;
+    if (!isRelevantSide(port.side_of_component))
+      continue;
+    const ports = portsBySchematicComponentId.get(port.schematic_component_id);
+    if (ports) {
+      ports.push(port);
+    } else {
+      portsBySchematicComponentId.set(port.schematic_component_id, [port]);
+    }
+  }
+  return portsBySchematicComponentId;
+};
+var getSourceComponentFtype = (schematicBox, sourceComponentById) => schematicBox.sourceComponentId ? sourceComponentById.get(schematicBox.sourceComponentId)?.ftype : undefined;
+
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/analyzers/schematic-box-sizing/pin-padding-to-edge.ts
+var isSchematicSide = (side) => isHorizontalSide(side) || isVerticalSide(side);
+var getPinSpacing = (schematicBox, schematicComponentById) => {
+  if (!schematicBox.schematicComponentId)
+    return null;
+  const schematicComponent = schematicComponentById.get(schematicBox.schematicComponentId);
+  return typeof schematicComponent?.pin_spacing === "number" ? schematicComponent.pin_spacing : null;
+};
+var getPinName = (port, sourcePortById) => {
+  const sourcePort = sourcePortById.get(port.source_port_id);
+  if (sourcePort?.name)
+    return sourcePort.name;
+  if (port.display_pin_label)
+    return port.display_pin_label;
+  if (sourcePort?.pin_number !== undefined)
+    return String(sourcePort.pin_number);
+  return;
+};
+var getMaxLabelLengthBySide = (ports, sourcePortById) => {
+  const maxLabelLengthBySide = {
+    left: 0,
+    right: 0,
+    top: 0,
+    bottom: 0
+  };
+  for (const port of ports) {
+    if (!isSchematicSide(port.side_of_component))
+      continue;
+    if (!port.display_pin_label)
+      continue;
+    maxLabelLengthBySide[port.side_of_component] = Math.max(maxLabelLengthBySide[port.side_of_component], estimateLabelWidth(port.display_pin_label, sourcePortById.get(port.source_port_id)));
+  }
+  return maxLabelLengthBySide;
+};
+var getOuterPinBySide = (edgeSide, ports) => {
+  if (ports.length === 0)
+    return null;
+  switch (edgeSide) {
+    case "top":
+      return ports.reduce((topPort, port) => port.center.y > topPort.center.y ? port : topPort);
+    case "bottom":
+      return ports.reduce((bottomPort, port) => port.center.y < bottomPort.center.y ? port : bottomPort);
+    case "left":
+      return ports.reduce((leftPort, port) => port.center.x < leftPort.center.x ? port : leftPort);
+    case "right":
+      return ports.reduce((rightPort, port) => port.center.x > rightPort.center.x ? port : rightPort);
+  }
+};
+var getPinPaddingToEdge = (input) => {
+  const bounds = getCenteredRectBounds(input.schematicBox);
+  switch (input.edgeSide) {
+    case "top":
+      return Math.max(0, bounds.top - input.port.center.y);
+    case "bottom":
+      return Math.max(0, input.port.center.y - bounds.bottom);
+    case "left":
+      return Math.max(0, input.port.center.x - bounds.left);
+    case "right":
+      return Math.max(0, bounds.right - input.port.center.x);
+  }
+};
+var getBoxEdgeSidesForPinSide = (pinSide) => isHorizontalSide(pinSide) ? ["top", "bottom"] : ["left", "right"];
+var hasPinsOnAllSides = (portsBySide) => portsBySide.has("left") && portsBySide.has("right") && portsBySide.has("top") && portsBySide.has("bottom");
+var getMaxAllowedPinPadding = (input) => {
+  const edgeAxisSides = isHorizontalSide(input.edgeSide) ? ["left", "right"] : ["top", "bottom"];
+  return (input.maxLabelLengthBySide[edgeAxisSides[0]] + input.maxLabelLengthBySide[edgeAxisSides[1]] + input.spacing) / 2;
+};
+var createPinPaddingToEdgeIssue = (candidate) => ({
+  lineItemType: "SchematicPinPaddingToEdgeTooLarge",
+  pinSide: candidate.pinSide,
+  edgeSide: candidate.edgeSide,
+  pinName: candidate.pinName,
+  schematicBox: candidate.schematicBox,
+  measuredPadding: candidate.measuredPadding,
+  maxAllowedPadding: candidate.maxAllowedPadding,
+  message: isHorizontalSide(candidate.pinSide) ? `${SCHEMATIC_PIN_PADDING_TO_EDGE_TOO_LARGE_MESSAGE} height` : `${SCHEMATIC_PIN_PADDING_TO_EDGE_TOO_LARGE_MESSAGE} width`
+});
+var generateSchematicPinPaddingToEdgeCandidates = (componentPlacements, circuitJson) => {
+  const placementBySchematicComponentId = getPlacementBySchematicComponentId(componentPlacements);
+  const schematicComponentById = getSchematicComponentById(circuitJson);
+  const sourcePortById = getSourcePortById(circuitJson);
+  const portsBySchematicComponentId = getPortsBySchematicComponentId(circuitJson, isSchematicSide);
+  const candidates = [];
+  for (const [schematicComponentId, ports] of portsBySchematicComponentId) {
+    const schematicBox = placementBySchematicComponentId.get(schematicComponentId);
+    if (!schematicBox)
+      continue;
+    const pinSpacing = getPinSpacing(schematicBox, schematicComponentById);
+    if (pinSpacing === null)
+      continue;
+    const maxLabelLengthBySide = getMaxLabelLengthBySide(ports, sourcePortById);
+    const portsBySide = new Map;
+    for (const port of ports) {
+      if (!isSchematicSide(port.side_of_component))
+        continue;
+      const sidePorts = portsBySide.get(port.side_of_component) ?? [];
+      sidePorts.push(port);
+      portsBySide.set(port.side_of_component, sidePorts);
+    }
+    const useLabelAwareMaxPadding = hasPinsOnAllSides(portsBySide);
+    for (const [pinSide, sidePorts] of portsBySide) {
+      for (const edgeSide of getBoxEdgeSidesForPinSide(pinSide)) {
+        const outerPin = getOuterPinBySide(edgeSide, sidePorts);
+        if (!outerPin)
+          continue;
+        const measuredPinPadding = {
+          pinName: getPinName(outerPin, sourcePortById),
+          measuredPadding: getPinPaddingToEdge({
+            schematicBox,
+            port: outerPin,
+            edgeSide
+          })
+        };
+        candidates.push({
+          schematicBox,
+          pinSide,
+          edgeSide,
+          pinName: measuredPinPadding.pinName,
+          measuredPadding: measuredPinPadding.measuredPadding,
+          maxAllowedPadding: useLabelAwareMaxPadding ? getMaxAllowedPinPadding({
+            spacing: pinSpacing,
+            edgeSide,
+            maxLabelLengthBySide
+          }) : pinSpacing
+        });
+      }
+    }
+  }
+  return candidates;
+};
+var getSchematicPinPaddingToEdgeTooLargeIssues = (candidates) => candidates.filter((candidate) => exceedsMaxAllowedGap(candidate.measuredPadding, candidate.maxAllowedPadding)).map(createPinPaddingToEdgeIssue);
+var generateSchematicPinPaddingToEdgeTooLargeIssues = (componentPlacements, circuitJson) => getSchematicPinPaddingToEdgeTooLargeIssues(generateSchematicPinPaddingToEdgeCandidates(componentPlacements, circuitJson));
+
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/analyzers/schematic-box-sizing/too-wide.ts
 var getLabelColumn = (side, ports, sourcePortById) => {
   const labelWidths = ports.filter((port) => port.side_of_component === side).flatMap((port) => port.display_pin_label ? [
     estimateLabelWidth(port.display_pin_label, sourcePortById.get(port.source_port_id))
@@ -241316,14 +241488,13 @@ var getInnerLabelEdge = (bounds, labelColumn) => {
   return bounds.right - PIN_LABEL_EDGE_PADDING - labelColumn.maxLabelWidth;
 };
 var getSuggestedWidth = (input) => input.currentWidth - input.measuredInnerLabelHorizontalEmptySpace + input.maxAllowedInnerLabelHorizontalEmptySpace;
-var exceedsMaxAllowedGap = (measuredInnerLabelHorizontalEmptySpace, maxAllowedInnerLabelHorizontalEmptySpace) => measuredInnerLabelHorizontalEmptySpace - maxAllowedInnerLabelHorizontalEmptySpace > GAP_COMPARISON_EPSILON;
 var createPinHeaderIssue = (input) => ({
   lineItemType: "SchematicBoxTooWideForPinHeader",
   schematicBox: input.schematicBox,
   measuredInnerLabelHorizontalEmptySpace: input.measuredInnerLabelHorizontalEmptySpace,
   maxAllowedInnerLabelHorizontalEmptySpace: PIN_HEADER_SCHEMATIC_BOX_SIZING_MAX_ALLOWED_GAP,
   suggestedSchWidth: input.suggestedSchWidth,
-  message: SCHEMATIC_BOX_SIZING_MESSAGE
+  message: SCHEMATIC_BOX_TOO_WIDE_MESSAGE
 });
 var createChipIssue = (input) => ({
   lineItemType: "SchematicBoxTooWideForChip",
@@ -241331,31 +241502,13 @@ var createChipIssue = (input) => ({
   measuredInnerLabelHorizontalEmptySpace: input.measuredInnerLabelHorizontalEmptySpace,
   maxAllowedInnerLabelHorizontalEmptySpace: CHIP_SCHEMATIC_BOX_SIZING_MAX_ALLOWED_GAP,
   suggestedSchWidth: input.suggestedSchWidth,
-  message: SCHEMATIC_BOX_SIZING_MESSAGE
+  message: SCHEMATIC_BOX_TOO_WIDE_MESSAGE
 });
-var generateSchematicBoxSizingCandidates = (componentPlacements, circuitJson) => {
-  const placementBySchematicComponentId = new Map(componentPlacements.filter((placement) => placement.schematicComponentId).map((placement) => [placement.schematicComponentId, placement]));
-  const sourcePortById = new Map(circuitJson.filter(isSourcePort).map((sourcePort) => [sourcePort.source_port_id, sourcePort]));
-  const sourceComponentById = new Map(circuitJson.flatMap((element) => {
-    const sourceComponent = getSourceComponentWithFtype(element);
-    return sourceComponent ? [sourceComponent] : [];
-  }).map((sourceComponent) => [
-    sourceComponent.source_component_id,
-    sourceComponent
-  ]));
-  const portsBySchematicComponentId = new Map;
-  for (const port of circuitJson.filter(isSchematicPort)) {
-    if (!port.schematic_component_id)
-      continue;
-    if (!isHorizontalSide(port.side_of_component))
-      continue;
-    const ports = portsBySchematicComponentId.get(port.schematic_component_id);
-    if (ports) {
-      ports.push(port);
-    } else {
-      portsBySchematicComponentId.set(port.schematic_component_id, [port]);
-    }
-  }
+var generateSchematicBoxWidthSizingCandidates = (componentPlacements, circuitJson) => {
+  const placementBySchematicComponentId = getPlacementBySchematicComponentId(componentPlacements);
+  const sourcePortById = getSourcePortById(circuitJson);
+  const sourceComponentById = getSourceComponentById(circuitJson);
+  const portsBySchematicComponentId = getPortsBySchematicComponentId(circuitJson, isHorizontalSide);
   const candidates = [];
   for (const [schematicComponentId, ports] of portsBySchematicComponentId) {
     const schematicBox = placementBySchematicComponentId.get(schematicComponentId);
@@ -241364,7 +241517,7 @@ var generateSchematicBoxSizingCandidates = (componentPlacements, circuitJson) =>
     const bounds = getCenteredRectBounds(schematicBox);
     const leftLabelColumn = getLabelColumn("left", ports, sourcePortById);
     const rightLabelColumn = getLabelColumn("right", ports, sourcePortById);
-    const sourceComponentFtype = schematicBox.sourceComponentId ? sourceComponentById.get(schematicBox.sourceComponentId)?.ftype : undefined;
+    const sourceComponentFtype = getSourceComponentFtype(schematicBox, sourceComponentById);
     if (leftLabelColumn && rightLabelColumn) {
       const measuredInnerLabelHorizontalEmptySpace = getInnerLabelEdge(bounds, rightLabelColumn) - getInnerLabelEdge(bounds, leftLabelColumn);
       candidates.push({
@@ -241411,9 +241564,8 @@ var getSchematicBoxTooWideForChipIssues = (candidates) => candidates.filter((can
     currentWidth: candidate.schematicBox.width
   })
 }));
-var generateSchematicBoxTooWideForPinHeaderIssues = (componentPlacements, circuitJson) => getSchematicBoxTooWideForPinHeaderIssues(generateSchematicBoxSizingCandidates(componentPlacements, circuitJson));
-var generateSchematicBoxTooWideForChipIssues = (componentPlacements, circuitJson) => getSchematicBoxTooWideForChipIssues(generateSchematicBoxSizingCandidates(componentPlacements, circuitJson));
-
+var generateSchematicBoxTooWideForPinHeaderIssues = (componentPlacements, circuitJson) => getSchematicBoxTooWideForPinHeaderIssues(generateSchematicBoxWidthSizingCandidates(componentPlacements, circuitJson));
+var generateSchematicBoxTooWideForChipIssues = (componentPlacements, circuitJson) => getSchematicBoxTooWideForChipIssues(generateSchematicBoxWidthSizingCandidates(componentPlacements, circuitJson));
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/analyzers/schematic-box-overlap.ts
 var getCenteredRectBounds2 = (box2) => {
   const halfWidth = box2.width / 2;
@@ -241578,7 +241730,7 @@ var fmtDelta = (value) => {
   return value > 0 ? `+${formattedValue}` : formattedValue;
 };
 var isSchematicBox = (element) => element.type === "schematic_box";
-var isSchematicComponent2 = (element) => element.type === "schematic_component";
+var isSchematicComponent3 = (element) => element.type === "schematic_component";
 var getSourceComponentName = (circuitJson, sourceComponentId) => {
   if (!sourceComponentId)
     return;
@@ -241683,6 +241835,17 @@ var schematicBoxTooWideIssueToString = (issue) => {
   addAttr(attrs, "suggestedSchWidth", issue.suggestedSchWidth);
   return `<${issue.lineItemType} ${attrs.join(" ")} />`;
 };
+var schematicPinPaddingToEdgeTooLargeIssueToString = (issue) => {
+  const attrs = [];
+  addAttr(attrs, "message", issue.message, { escape: false });
+  addAttr(attrs, "componentName", issue.schematicBox.sourceComponentName);
+  addAttr(attrs, "pinSide", issue.pinSide);
+  addAttr(attrs, "edgeSide", issue.edgeSide);
+  addAttr(attrs, "pinName", issue.pinName);
+  addAttr(attrs, "measuredPadding", issue.measuredPadding);
+  addAttr(attrs, "maxAllowedPadding", issue.maxAllowedPadding);
+  return `<SchematicPinPaddingToEdgeTooLarge ${attrs.join(" ")} />`;
+};
 var correctionSuggestionToString = (suggestion) => {
   const attrs = [];
   addAttr(attrs, "target", suggestion.targetComponentName);
@@ -241729,6 +241892,8 @@ class SchematicPlacementAnalysis {
             case "SchematicBoxTooWideForPinHeader":
             case "SchematicBoxTooWideForChip":
               return schematicBoxTooWideIssueToString(issue);
+            case "SchematicPinPaddingToEdgeTooLarge":
+              return schematicPinPaddingToEdgeTooLargeIssueToString(issue);
             default:
               return "";
           }
@@ -241741,9 +241906,9 @@ class SchematicPlacementAnalysis {
 }
 var analyzeSchematicPlacement = (circuitJson) => {
   const schematicBoxes = circuitJson.filter(isSchematicBox);
-  const schematicComponentIds = new Set(circuitJson.filter(isSchematicComponent2).map((schematicComponent) => schematicComponent.schematic_component_id));
+  const schematicComponentIds = new Set(circuitJson.filter(isSchematicComponent3).map((schematicComponent) => schematicComponent.schematic_component_id));
   const lineItems = [
-    ...circuitJson.filter(isSchematicComponent2).map((schematicComponent) => schematicComponentToLineItem(schematicComponent, circuitJson, schematicBoxes.find((schematicBox) => schematicBox.schematic_component_id === schematicComponent.schematic_component_id))),
+    ...circuitJson.filter(isSchematicComponent3).map((schematicComponent) => schematicComponentToLineItem(schematicComponent, circuitJson, schematicBoxes.find((schematicBox) => schematicBox.schematic_component_id === schematicComponent.schematic_component_id))),
     ...schematicBoxes.filter((schematicBox) => !schematicBox.schematic_component_id || !schematicComponentIds.has(schematicBox.schematic_component_id)).map((schematicBox) => schematicBoxToLineItem(schematicBox, circuitJson))
   ];
   const issues = [
@@ -241751,7 +241916,8 @@ var analyzeSchematicPlacement = (circuitJson) => {
     ...generateCapacitorOrientationIssues(lineItems, circuitJson),
     ...generateVerboseNetLabelIssues(circuitJson),
     ...generateSchematicBoxTooWideForPinHeaderIssues(lineItems, circuitJson),
-    ...generateSchematicBoxTooWideForChipIssues(lineItems, circuitJson)
+    ...generateSchematicBoxTooWideForChipIssues(lineItems, circuitJson),
+    ...generateSchematicPinPaddingToEdgeTooLargeIssues(lineItems, circuitJson)
   ];
   return new SchematicPlacementAnalysis([
     ...lineItems,

package/dist/lib/index.js

@@ -65661,7 +65661,7 @@ var getNodeHandler = (winterSpec, { port, middleware = [] }) => {
   }));
 };
 // package.json
-var version = "0.1.1319";
+var version = "0.1.1321";
 var package_default = {
   name: "@tscircuit/cli",
   version,
@@ -65675,7 +65675,7 @@ var package_default = {
     "@biomejs/biome": "^1.9.4",
     "@tscircuit/circuit-json-placement-analysis": "^0.0.6",
     "@tscircuit/circuit-json-routing-analysis": "^0.0.1",
-    "@tscircuit/circuit-json-schematic-placement-analysis": "github:tscircuit/circuit-json-schematic-placement-analysis#add7fd89b1edce7fda0471a173409b8118d2723c",
+    "@tscircuit/circuit-json-schematic-placement-analysis": "github:tscircuit/circuit-json-schematic-placement-analysis#a8b1e6a5357f8a5aea4881f84ffda7c76d5cfe8e",
     "@tscircuit/fake-snippets": "^0.0.182",
     "@tscircuit/file-server": "^0.0.32",
     "@tscircuit/image-utils": "^0.0.3",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tscircuit/cli",
-  "version": "0.1.1320",
+  "version": "0.1.1322",
   "main": "dist/cli/main.js",
   "exports": {
     ".": "./dist/cli/main.js",
@@ -11,7 +11,7 @@
     "@biomejs/biome": "^1.9.4",
     "@tscircuit/circuit-json-placement-analysis": "^0.0.6",
     "@tscircuit/circuit-json-routing-analysis": "^0.0.1",
-    "@tscircuit/circuit-json-schematic-placement-analysis": "github:tscircuit/circuit-json-schematic-placement-analysis#add7fd89b1edce7fda0471a173409b8118d2723c",
+    "@tscircuit/circuit-json-schematic-placement-analysis": "github:tscircuit/circuit-json-schematic-placement-analysis#a8b1e6a5357f8a5aea4881f84ffda7c76d5cfe8e",
     "@tscircuit/fake-snippets": "^0.0.182",
     "@tscircuit/file-server": "^0.0.32",
     "@tscircuit/image-utils": "^0.0.3",