@tscircuit/props 0.0.358 → 0.0.360

package/dist/index.js

@@ -472,6 +472,7 @@ var border = z27.object({
   dashed: z27.boolean().optional(),
   solid: z27.boolean().optional()
 });
+var pcbPositionAnchorAutocomplete = z27.custom((value) => typeof value === "string");
 var autorouterConfig = z27.object({
   serverUrl: z27.string().optional(),
   inputFormat: z27.enum(["simplified", "circuit-json"]).optional(),
@@ -597,7 +598,8 @@ var baseGroupProps = commonLayoutProps.extend({
   pcbPaddingLeft: length2.optional(),
   pcbPaddingRight: length2.optional(),
   pcbPaddingTop: length2.optional(),
-  pcbPaddingBottom: length2.optional()
+  pcbPaddingBottom: length2.optional(),
+  pcbPositionAnchor: pcbPositionAnchorAutocomplete.optional()
 });
 var partsEngine = z27.custom((v) => "findPart" in v);
 var subcircuitGroupProps = baseGroupProps.extend({
@@ -1504,6 +1506,7 @@ var fabricationNoteTextProps = pcbLayoutProps.extend({
   fontSize: length3.optional(),
   color: z65.string().optional()
 });
+expectTypesMatch(true);
 
 // lib/components/fabrication-note-rect.ts
 import { distance as distance15 } from "circuit-json";
@@ -1527,38 +1530,54 @@ var fabricationNotePathProps = pcbLayoutProps.omit({ pcbX: true, pcbY: true, pcb
   color: z67.string().optional()
 });
 
-// lib/components/pcb-trace.ts
-import { distance as distance16, route_hint_point as route_hint_point4 } from "circuit-json";
+// lib/components/fabrication-note-dimension.ts
+import { distance as distance16, length as length5 } from "circuit-json";
 import { z as z68 } from "zod";
-var pcbTraceProps = z68.object({
-  layer: z68.string().optional(),
-  thickness: distance16.optional(),
-  route: z68.array(route_hint_point4)
+var dimensionTarget = z68.union([z68.string(), point]);
+var fabricationNoteDimensionProps = pcbLayoutProps.omit({ pcbX: true, pcbY: true, pcbRotation: true }).extend({
+  from: dimensionTarget,
+  to: dimensionTarget,
+  text: z68.string().optional(),
+  offset: distance16.optional(),
+  font: z68.enum(["tscircuit2024"]).optional(),
+  fontSize: length5.optional(),
+  color: z68.string().optional(),
+  arrowSize: distance16.optional()
 });
+expectTypesMatch(true);
 
-// lib/components/via.ts
-import { distance as distance17, layer_ref as layer_ref5 } from "circuit-json";
+// lib/components/pcb-trace.ts
+import { distance as distance17, route_hint_point as route_hint_point4 } from "circuit-json";
 import { z as z69 } from "zod";
+var pcbTraceProps = z69.object({
+  layer: z69.string().optional(),
+  thickness: distance17.optional(),
+  route: z69.array(route_hint_point4)
+});
+
+// lib/components/via.ts
+import { distance as distance18, layer_ref as layer_ref5 } from "circuit-json";
+import { z as z70 } from "zod";
 var viaProps = commonLayoutProps.extend({
-  name: z69.string().optional(),
+  name: z70.string().optional(),
   fromLayer: layer_ref5,
   toLayer: layer_ref5,
-  holeDiameter: distance17,
-  outerDiameter: distance17,
-  connectsTo: z69.string().or(z69.array(z69.string())).optional()
+  holeDiameter: distance18,
+  outerDiameter: distance18,
+  connectsTo: z70.string().or(z70.array(z70.string())).optional()
 });
 expectTypesMatch(true);
 
 // lib/components/testpoint.ts
-import { distance as distance18 } from "circuit-json";
-import { z as z70 } from "zod";
+import { distance as distance19 } from "circuit-json";
+import { z as z71 } from "zod";
 var testpointProps = commonComponentProps.extend({
-  footprintVariant: z70.enum(["pad", "through_hole"]).optional(),
-  padShape: z70.enum(["rect", "circle"]).optional().default("circle"),
-  padDiameter: distance18.optional(),
-  holeDiameter: distance18.optional(),
-  width: distance18.optional(),
-  height: distance18.optional()
+  footprintVariant: z71.enum(["pad", "through_hole"]).optional(),
+  padShape: z71.enum(["rect", "circle"]).optional().default("circle"),
+  padDiameter: distance19.optional(),
+  holeDiameter: distance19.optional(),
+  width: distance19.optional(),
+  height: distance19.optional()
 }).refine(
   (props) => props.footprintVariant !== "through_hole" || props.holeDiameter !== void 0,
   { message: "holeDiameter is required for through_hole testpoints" }
@@ -1566,58 +1585,58 @@ var testpointProps = commonComponentProps.extend({
 expectTypesMatch(true);
 
 // lib/components/breakoutpoint.ts
-import { z as z71 } from "zod";
+import { z as z72 } from "zod";
 var breakoutPointProps = pcbLayoutProps.omit({ pcbRotation: true, layer: true }).extend({
-  connection: z71.string()
+  connection: z72.string()
 });
 expectTypesMatch(true);
 
 // lib/components/pcb-keepout.ts
-import { distance as distance19 } from "circuit-json";
-import { z as z72 } from "zod";
-var pcbKeepoutProps = z72.union([
+import { distance as distance20 } from "circuit-json";
+import { z as z73 } from "zod";
+var pcbKeepoutProps = z73.union([
   pcbLayoutProps.omit({ pcbRotation: true }).extend({
-    shape: z72.literal("circle"),
-    radius: distance19
+    shape: z73.literal("circle"),
+    radius: distance20
   }),
   pcbLayoutProps.extend({
-    shape: z72.literal("rect"),
-    width: distance19,
-    height: distance19
+    shape: z73.literal("rect"),
+    width: distance20,
+    height: distance20
   })
 ]);
 
 // lib/components/courtyard-rect.ts
-import { distance as distance20 } from "circuit-json";
-import { z as z73 } from "zod";
+import { distance as distance21 } from "circuit-json";
+import { z as z74 } from "zod";
 var courtyardRectProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
-  width: distance20,
-  height: distance20,
-  strokeWidth: distance20.optional(),
-  isFilled: z73.boolean().optional(),
-  hasStroke: z73.boolean().optional(),
-  isStrokeDashed: z73.boolean().optional(),
-  color: z73.string().optional()
+  width: distance21,
+  height: distance21,
+  strokeWidth: distance21.optional(),
+  isFilled: z74.boolean().optional(),
+  hasStroke: z74.boolean().optional(),
+  isStrokeDashed: z74.boolean().optional(),
+  color: z74.string().optional()
 });
 
 // lib/components/courtyard-outline.ts
-import { length as length5 } from "circuit-json";
-import { z as z74 } from "zod";
+import { length as length6 } from "circuit-json";
+import { z as z75 } from "zod";
 var courtyardOutlineProps = pcbLayoutProps.omit({ pcbX: true, pcbY: true, pcbRotation: true }).extend({
-  outline: z74.array(point),
-  strokeWidth: length5.optional(),
-  isClosed: z74.boolean().optional(),
-  isStrokeDashed: z74.boolean().optional(),
-  color: z74.string().optional()
+  outline: z75.array(point),
+  strokeWidth: length6.optional(),
+  isClosed: z75.boolean().optional(),
+  isStrokeDashed: z75.boolean().optional(),
+  color: z75.string().optional()
 });
 
 // lib/components/copper-pour.ts
-import { z as z75 } from "zod";
+import { z as z76 } from "zod";
 import { layer_ref as layer_ref6 } from "circuit-json";
-var copperPourProps = z75.object({
-  name: z75.string().optional(),
+var copperPourProps = z76.object({
+  name: z76.string().optional(),
   layer: layer_ref6,
-  connectsTo: z75.string(),
+  connectsTo: z76.string(),
   padMargin: distance.optional(),
   traceMargin: distance.optional()
 });
@@ -1625,27 +1644,27 @@ expectTypesMatch(true);
 
 // lib/components/cadassembly.ts
 import { layer_ref as layer_ref7 } from "circuit-json";
-import { z as z76 } from "zod";
-var cadassemblyProps = z76.object({
+import { z as z77 } from "zod";
+var cadassemblyProps = z77.object({
   originalLayer: layer_ref7.default("top").optional(),
-  children: z76.any().optional()
+  children: z77.any().optional()
 });
 expectTypesMatch(true);
 
 // lib/components/cadmodel.ts
-import { z as z77 } from "zod";
-var pcbPosition = z77.object({
+import { z as z78 } from "zod";
+var pcbPosition = z78.object({
   pcbX: distance.optional(),
   pcbY: distance.optional(),
   pcbZ: distance.optional()
 });
 var cadModelBaseWithUrl = cadModelBase.extend({
-  modelUrl: z77.string(),
-  stepUrl: z77.string().optional()
+  modelUrl: z78.string(),
+  stepUrl: z78.string().optional()
 });
 var cadModelObject = cadModelBaseWithUrl.merge(pcbPosition);
 expectTypesMatch(true);
-var cadmodelProps = z77.union([z77.null(), z77.string(), cadModelObject]);
+var cadmodelProps = z78.union([z78.null(), z78.string(), cadModelObject]);
 
 // lib/components/power-source.ts
 import { voltage as voltage3 } from "circuit-json";
@@ -1655,9 +1674,9 @@ var powerSourceProps = commonComponentProps.extend({
 
 // lib/components/voltagesource.ts
 import { frequency as frequency3, rotation as rotation4, voltage as voltage4 } from "circuit-json";
-import { z as z78 } from "zod";
+import { z as z79 } from "zod";
 var voltageSourcePinLabels = ["pin1", "pin2", "pos", "neg"];
-var percentage = z78.union([z78.string(), z78.number()]).transform((val) => {
+var percentage = z79.union([z79.string(), z79.number()]).transform((val) => {
   if (typeof val === "string") {
     if (val.endsWith("%")) {
       return parseFloat(val.slice(0, -1)) / 100;
@@ -1666,13 +1685,13 @@ var percentage = z78.union([z78.string(), z78.number()]).transform((val) => {
   }
   return val;
 }).pipe(
-  z78.number().min(0, "Duty cycle must be non-negative").max(1, "Duty cycle cannot be greater than 100%")
+  z79.number().min(0, "Duty cycle must be non-negative").max(1, "Duty cycle cannot be greater than 100%")
 );
 var voltageSourceProps = commonComponentProps.extend({
   voltage: voltage4.optional(),
   frequency: frequency3.optional(),
   peakToPeakVoltage: voltage4.optional(),
-  waveShape: z78.enum(["sinewave", "square", "triangle", "sawtooth"]).optional(),
+  waveShape: z79.enum(["sinewave", "square", "triangle", "sawtooth"]).optional(),
   phase: rotation4.optional(),
   dutyCycle: percentage.optional(),
   connections: createConnectionsProp(voltageSourcePinLabels).optional()
@@ -1681,47 +1700,47 @@ var voltageSourcePins = lrPolarPins;
 expectTypesMatch(true);
 
 // lib/components/voltageprobe.ts
-import { z as z79 } from "zod";
+import { z as z80 } from "zod";
 var voltageProbeProps = commonComponentProps.omit({ name: true }).extend({
-  name: z79.string().optional(),
-  connectsTo: z79.string().or(z79.array(z79.string()))
+  name: z80.string().optional(),
+  connectsTo: z80.string().or(z80.array(z80.string()))
 });
 expectTypesMatch(true);
 
 // lib/components/schematic-arc.ts
-import { distance as distance21, point as point5, rotation as rotation5 } from "circuit-json";
-import { z as z80 } from "zod";
-var schematicArcProps = z80.object({
+import { distance as distance22, point as point5, rotation as rotation5 } from "circuit-json";
+import { z as z81 } from "zod";
+var schematicArcProps = z81.object({
   center: point5,
-  radius: distance21,
+  radius: distance22,
   startAngleDegrees: rotation5,
   endAngleDegrees: rotation5,
-  direction: z80.enum(["clockwise", "counterclockwise"]).default("counterclockwise"),
-  strokeWidth: distance21.optional(),
-  color: z80.string().optional().default("#000000"),
-  isDashed: z80.boolean().optional().default(false)
+  direction: z81.enum(["clockwise", "counterclockwise"]).default("counterclockwise"),
+  strokeWidth: distance22.optional(),
+  color: z81.string().optional().default("#000000"),
+  isDashed: z81.boolean().optional().default(false)
 });
 
 // lib/components/schematic-box.ts
-import { distance as distance22 } from "circuit-json";
-import { z as z81 } from "zod";
-var schematicBoxProps = z81.object({
-  schX: distance22.optional(),
-  schY: distance22.optional(),
-  width: distance22.optional(),
-  height: distance22.optional(),
-  overlay: z81.array(z81.string()).optional(),
-  padding: distance22.optional(),
-  paddingLeft: distance22.optional(),
-  paddingRight: distance22.optional(),
-  paddingTop: distance22.optional(),
-  paddingBottom: distance22.optional(),
-  title: z81.string().optional(),
+import { distance as distance23 } from "circuit-json";
+import { z as z82 } from "zod";
+var schematicBoxProps = z82.object({
+  schX: distance23.optional(),
+  schY: distance23.optional(),
+  width: distance23.optional(),
+  height: distance23.optional(),
+  overlay: z82.array(z82.string()).optional(),
+  padding: distance23.optional(),
+  paddingLeft: distance23.optional(),
+  paddingRight: distance23.optional(),
+  paddingTop: distance23.optional(),
+  paddingBottom: distance23.optional(),
+  title: z82.string().optional(),
   titleAlignment: ninePointAnchor.default("top_left"),
-  titleColor: z81.string().optional(),
-  titleFontSize: distance22.optional(),
-  titleInside: z81.boolean().default(false),
-  strokeStyle: z81.enum(["solid", "dashed"]).default("solid")
+  titleColor: z82.string().optional(),
+  titleFontSize: distance23.optional(),
+  titleInside: z82.boolean().default(false),
+  strokeStyle: z82.enum(["solid", "dashed"]).default("solid")
 }).refine(
   (elm) => elm.width !== void 0 && elm.height !== void 0 || Array.isArray(elm.overlay) && elm.overlay.length > 0,
   {
@@ -1735,27 +1754,11 @@ var schematicBoxProps = z81.object({
 );
 
 // lib/components/schematic-circle.ts
-import { distance as distance23, point as point6 } from "circuit-json";
-import { z as z82 } from "zod";
-var schematicCircleProps = z82.object({
-  center: point6,
-  radius: distance23,
-  strokeWidth: distance23.optional(),
-  color: z82.string().optional().default("#000000"),
-  isFilled: z82.boolean().optional().default(false),
-  fillColor: z82.string().optional(),
-  isDashed: z82.boolean().optional().default(false)
-});
-
-// lib/components/schematic-rect.ts
-import { distance as distance24, rotation as rotation6 } from "circuit-json";
+import { distance as distance24, point as point6 } from "circuit-json";
 import { z as z83 } from "zod";
-var schematicRectProps = z83.object({
-  schX: distance24.optional(),
-  schY: distance24.optional(),
-  width: distance24,
-  height: distance24,
-  rotation: rotation6.default(0),
+var schematicCircleProps = z83.object({
+  center: point6,
+  radius: distance24,
   strokeWidth: distance24.optional(),
   color: z83.string().optional().default("#000000"),
   isFilled: z83.boolean().optional().default(false),
@@ -1763,26 +1766,42 @@ var schematicRectProps = z83.object({
   isDashed: z83.boolean().optional().default(false)
 });
 
-// lib/components/schematic-line.ts
-import { distance as distance25 } from "circuit-json";
+// lib/components/schematic-rect.ts
+import { distance as distance25, rotation as rotation6 } from "circuit-json";
 import { z as z84 } from "zod";
-var schematicLineProps = z84.object({
-  x1: distance25,
-  y1: distance25,
-  x2: distance25,
-  y2: distance25,
+var schematicRectProps = z84.object({
+  schX: distance25.optional(),
+  schY: distance25.optional(),
+  width: distance25,
+  height: distance25,
+  rotation: rotation6.default(0),
   strokeWidth: distance25.optional(),
   color: z84.string().optional().default("#000000"),
+  isFilled: z84.boolean().optional().default(false),
+  fillColor: z84.string().optional(),
   isDashed: z84.boolean().optional().default(false)
 });
 
+// lib/components/schematic-line.ts
+import { distance as distance26 } from "circuit-json";
+import { z as z85 } from "zod";
+var schematicLineProps = z85.object({
+  x1: distance26,
+  y1: distance26,
+  x2: distance26,
+  y2: distance26,
+  strokeWidth: distance26.optional(),
+  color: z85.string().optional().default("#000000"),
+  isDashed: z85.boolean().optional().default(false)
+});
+
 // lib/components/schematic-text.ts
-import { distance as distance26, rotation as rotation7 } from "circuit-json";
-import { z as z86 } from "zod";
+import { distance as distance27, rotation as rotation7 } from "circuit-json";
+import { z as z87 } from "zod";
 
 // lib/common/fivePointAnchor.ts
-import { z as z85 } from "zod";
-var fivePointAnchor = z85.enum([
+import { z as z86 } from "zod";
+var fivePointAnchor = z86.enum([
   "center",
   "left",
   "right",
@@ -1791,213 +1810,284 @@ var fivePointAnchor = z85.enum([
 ]);
 
 // lib/components/schematic-text.ts
-var schematicTextProps = z86.object({
-  schX: distance26.optional(),
-  schY: distance26.optional(),
-  text: z86.string(),
-  fontSize: z86.number().default(1),
-  anchor: z86.union([fivePointAnchor.describe("legacy"), ninePointAnchor]).default("center"),
-  color: z86.string().default("#000000"),
+var schematicTextProps = z87.object({
+  schX: distance27.optional(),
+  schY: distance27.optional(),
+  text: z87.string(),
+  fontSize: z87.number().default(1),
+  anchor: z87.union([fivePointAnchor.describe("legacy"), ninePointAnchor]).default("center"),
+  color: z87.string().default("#000000"),
   schRotation: rotation7.default(0)
 });
 
 // lib/components/schematic-path.ts
 import { point as point8 } from "circuit-json";
-import { z as z87 } from "zod";
-var schematicPathProps = z87.object({
-  points: z87.array(point8),
-  isFilled: z87.boolean().optional().default(false),
-  fillColor: z87.enum(["red", "blue"]).optional()
+import { z as z88 } from "zod";
+var schematicPathProps = z88.object({
+  points: z88.array(point8),
+  isFilled: z88.boolean().optional().default(false),
+  fillColor: z88.enum(["red", "blue"]).optional()
 });
 
 // lib/components/schematic-table.ts
-import { distance as distance27 } from "circuit-json";
-import { z as z88 } from "zod";
-var schematicTableProps = z88.object({
-  schX: distance27.optional(),
-  schY: distance27.optional(),
-  children: z88.any().optional(),
-  cellPadding: distance27.optional(),
-  borderWidth: distance27.optional(),
+import { distance as distance28 } from "circuit-json";
+import { z as z89 } from "zod";
+var schematicTableProps = z89.object({
+  schX: distance28.optional(),
+  schY: distance28.optional(),
+  children: z89.any().optional(),
+  cellPadding: distance28.optional(),
+  borderWidth: distance28.optional(),
   anchor: ninePointAnchor.optional(),
-  fontSize: distance27.optional()
+  fontSize: distance28.optional()
 });
 expectTypesMatch(true);
 
 // lib/components/schematic-row.ts
-import { distance as distance28 } from "circuit-json";
-import { z as z89 } from "zod";
-var schematicRowProps = z89.object({
-  children: z89.any().optional(),
-  height: distance28.optional()
+import { distance as distance29 } from "circuit-json";
+import { z as z90 } from "zod";
+var schematicRowProps = z90.object({
+  children: z90.any().optional(),
+  height: distance29.optional()
 });
 expectTypesMatch(true);
 
 // lib/components/schematic-cell.ts
-import { distance as distance29 } from "circuit-json";
-import { z as z90 } from "zod";
-var schematicCellProps = z90.object({
-  children: z90.string().optional(),
-  horizontalAlign: z90.enum(["left", "center", "right"]).optional(),
-  verticalAlign: z90.enum(["top", "middle", "bottom"]).optional(),
-  fontSize: distance29.optional(),
-  rowSpan: z90.number().optional(),
-  colSpan: z90.number().optional(),
-  width: distance29.optional(),
-  text: z90.string().optional()
+import { distance as distance30 } from "circuit-json";
+import { z as z91 } from "zod";
+var schematicCellProps = z91.object({
+  children: z91.string().optional(),
+  horizontalAlign: z91.enum(["left", "center", "right"]).optional(),
+  verticalAlign: z91.enum(["top", "middle", "bottom"]).optional(),
+  fontSize: distance30.optional(),
+  rowSpan: z91.number().optional(),
+  colSpan: z91.number().optional(),
+  width: distance30.optional(),
+  text: z91.string().optional()
 });
 expectTypesMatch(true);
 
 // lib/components/silkscreen-text.ts
-import { layer_ref as layer_ref8, length as length6 } from "circuit-json";
-import { z as z91 } from "zod";
+import { layer_ref as layer_ref8, length as length7 } from "circuit-json";
+import { z as z92 } from "zod";
 var silkscreenTextProps = pcbLayoutProps.extend({
-  text: z91.string(),
+  text: z92.string(),
   anchorAlignment: ninePointAnchor.default("center"),
-  font: z91.enum(["tscircuit2024"]).optional(),
-  fontSize: length6.optional(),
+  font: z92.enum(["tscircuit2024"]).optional(),
+  fontSize: length7.optional(),
   /**
    * If true, text will knock out underlying silkscreen
    */
-  isKnockout: z91.boolean().optional(),
-  knockoutPadding: length6.optional(),
-  knockoutPaddingLeft: length6.optional(),
-  knockoutPaddingRight: length6.optional(),
-  knockoutPaddingTop: length6.optional(),
-  knockoutPaddingBottom: length6.optional(),
-  layers: z91.array(layer_ref8).optional()
+  isKnockout: z92.boolean().optional(),
+  knockoutPadding: length7.optional(),
+  knockoutPaddingLeft: length7.optional(),
+  knockoutPaddingRight: length7.optional(),
+  knockoutPaddingTop: length7.optional(),
+  knockoutPaddingBottom: length7.optional(),
+  layers: z92.array(layer_ref8).optional()
 });
 
 // lib/components/silkscreen-path.ts
-import { length as length7, route_hint_point as route_hint_point5 } from "circuit-json";
-import { z as z92 } from "zod";
+import { length as length8, route_hint_point as route_hint_point5 } from "circuit-json";
+import { z as z93 } from "zod";
 var silkscreenPathProps = pcbLayoutProps.omit({ pcbX: true, pcbY: true, pcbRotation: true }).extend({
-  route: z92.array(route_hint_point5),
-  strokeWidth: length7.optional()
+  route: z93.array(route_hint_point5),
+  strokeWidth: length8.optional()
 });
 
 // lib/components/silkscreen-line.ts
-import { distance as distance30 } from "circuit-json";
+import { distance as distance31 } from "circuit-json";
 var silkscreenLineProps = pcbLayoutProps.omit({ pcbX: true, pcbY: true, pcbRotation: true }).extend({
-  strokeWidth: distance30,
-  x1: distance30,
-  y1: distance30,
-  x2: distance30,
-  y2: distance30
+  strokeWidth: distance31,
+  x1: distance31,
+  y1: distance31,
+  x2: distance31,
+  y2: distance31
 });
 
 // lib/components/silkscreen-rect.ts
-import { distance as distance31 } from "circuit-json";
-import { z as z93 } from "zod";
+import { distance as distance32 } from "circuit-json";
+import { z as z94 } from "zod";
 var silkscreenRectProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
-  filled: z93.boolean().default(true).optional(),
-  stroke: z93.enum(["dashed", "solid", "none"]).optional(),
-  strokeWidth: distance31.optional(),
-  width: distance31,
-  height: distance31
+  filled: z94.boolean().default(true).optional(),
+  stroke: z94.enum(["dashed", "solid", "none"]).optional(),
+  strokeWidth: distance32.optional(),
+  width: distance32,
+  height: distance32
 });
 
 // lib/components/silkscreen-circle.ts
-import { distance as distance32 } from "circuit-json";
-import { z as z94 } from "zod";
+import { distance as distance33 } from "circuit-json";
+import { z as z95 } from "zod";
 var silkscreenCircleProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
-  isFilled: z94.boolean().optional(),
-  isOutline: z94.boolean().optional(),
-  strokeWidth: distance32.optional(),
-  radius: distance32
+  isFilled: z95.boolean().optional(),
+  isOutline: z95.boolean().optional(),
+  strokeWidth: distance33.optional(),
+  radius: distance33
 });
 
 // lib/components/trace-hint.ts
-import { distance as distance33, layer_ref as layer_ref9, route_hint_point as route_hint_point6 } from "circuit-json";
-import { z as z95 } from "zod";
-var routeHintPointProps = z95.object({
-  x: distance33,
-  y: distance33,
-  via: z95.boolean().optional(),
+import { distance as distance34, layer_ref as layer_ref9, route_hint_point as route_hint_point6 } from "circuit-json";
+import { z as z96 } from "zod";
+var routeHintPointProps = z96.object({
+  x: distance34,
+  y: distance34,
+  via: z96.boolean().optional(),
   toLayer: layer_ref9.optional()
 });
-var traceHintProps = z95.object({
-  for: z95.string().optional().describe(
+var traceHintProps = z96.object({
+  for: z96.string().optional().describe(
     "Selector for the port you're targeting, not required if you're inside a trace"
   ),
-  order: z95.number().optional(),
+  order: z96.number().optional(),
   offset: route_hint_point6.or(routeHintPointProps).optional(),
-  offsets: z95.array(route_hint_point6).or(z95.array(routeHintPointProps)).optional(),
-  traceWidth: z95.number().optional()
+  offsets: z96.array(route_hint_point6).or(z96.array(routeHintPointProps)).optional(),
+  traceWidth: z96.number().optional()
 });
 
 // lib/components/port.ts
-import { z as z96 } from "zod";
+import { z as z97 } from "zod";
 var portProps = commonLayoutProps.extend({
-  name: z96.string(),
-  pinNumber: z96.number().optional(),
-  aliases: z96.array(z96.string()).optional(),
+  name: z97.string(),
+  pinNumber: z97.number().optional(),
+  aliases: z97.array(z97.string()).optional(),
   direction,
-  connectsTo: z96.string().or(z96.array(z96.string())).optional()
+  connectsTo: z97.string().or(z97.array(z97.string())).optional()
 });
 
+// lib/components/pcb-note-text.ts
+import { length as length9 } from "circuit-json";
+import { z as z98 } from "zod";
+var pcbNoteTextProps = pcbLayoutProps.extend({
+  text: z98.string(),
+  anchorAlignment: z98.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center"),
+  font: z98.enum(["tscircuit2024"]).optional(),
+  fontSize: length9.optional(),
+  color: z98.string().optional()
+});
+expectTypesMatch(true);
+
+// lib/components/pcb-note-rect.ts
+import { distance as distance35 } from "circuit-json";
+import { z as z99 } from "zod";
+var pcbNoteRectProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
+  width: distance35,
+  height: distance35,
+  strokeWidth: distance35.optional(),
+  isFilled: z99.boolean().optional(),
+  hasStroke: z99.boolean().optional(),
+  isStrokeDashed: z99.boolean().optional(),
+  color: z99.string().optional()
+});
+expectTypesMatch(true);
+
+// lib/components/pcb-note-path.ts
+import {
+  length as length10,
+  route_hint_point as route_hint_point7
+} from "circuit-json";
+import { z as z100 } from "zod";
+var pcbNotePathProps = pcbLayoutProps.omit({ pcbX: true, pcbY: true, pcbRotation: true }).extend({
+  route: z100.array(route_hint_point7),
+  strokeWidth: length10.optional(),
+  color: z100.string().optional()
+});
+expectTypesMatch(true);
+
+// lib/components/pcb-note-line.ts
+import { distance as distance36 } from "circuit-json";
+import { z as z101 } from "zod";
+var pcbNoteLineProps = pcbLayoutProps.omit({ pcbX: true, pcbY: true, pcbRotation: true }).extend({
+  x1: distance36,
+  y1: distance36,
+  x2: distance36,
+  y2: distance36,
+  strokeWidth: distance36.optional(),
+  color: z101.string().optional(),
+  isDashed: z101.boolean().optional()
+});
+expectTypesMatch(true);
+
+// lib/components/pcb-note-dimension.ts
+import { distance as distance37, length as length11 } from "circuit-json";
+import { z as z102 } from "zod";
+var dimensionTarget2 = z102.union([z102.string(), point]);
+var pcbNoteDimensionProps = pcbLayoutProps.omit({ pcbX: true, pcbY: true, pcbRotation: true }).extend({
+  from: dimensionTarget2,
+  to: dimensionTarget2,
+  text: z102.string().optional(),
+  offset: distance37.optional(),
+  font: z102.enum(["tscircuit2024"]).optional(),
+  fontSize: length11.optional(),
+  color: z102.string().optional(),
+  arrowSize: distance37.optional()
+});
+expectTypesMatch(
+  true
+);
+
 // lib/platformConfig.ts
-import { z as z97 } from "zod";
+import { z as z103 } from "zod";
 import { frequency as frequency4, ms as ms2 } from "circuit-json";
-var unvalidatedCircuitJson = z97.array(z97.any()).describe("Circuit JSON");
-var footprintLibraryResult = z97.object({
-  footprintCircuitJson: z97.array(z97.any()),
+var unvalidatedCircuitJson = z103.array(z103.any()).describe("Circuit JSON");
+var footprintLibraryResult = z103.object({
+  footprintCircuitJson: z103.array(z103.any()),
   cadModel: cadModelProp.optional()
 });
-var pathToCircuitJsonFn = z97.function().args(z97.string()).returns(z97.promise(footprintLibraryResult)).describe("A function that takes a path and returns Circuit JSON");
-var footprintFileParserEntry = z97.object({
-  loadFromUrl: z97.function().args(z97.string()).returns(z97.promise(footprintLibraryResult)).describe(
+var pathToCircuitJsonFn = z103.function().args(z103.string()).returns(z103.promise(footprintLibraryResult)).describe("A function that takes a path and returns Circuit JSON");
+var footprintFileParserEntry = z103.object({
+  loadFromUrl: z103.function().args(z103.string()).returns(z103.promise(footprintLibraryResult)).describe(
     "A function that takes a footprint file URL and returns Circuit JSON"
   )
 });
-var spiceEngineSimulationResult = z97.object({
-  engineVersionString: z97.string().optional(),
+var spiceEngineSimulationResult = z103.object({
+  engineVersionString: z103.string().optional(),
   simulationResultCircuitJson: unvalidatedCircuitJson
 });
-var spiceEngineZod = z97.object({
-  simulate: z97.function().args(z97.string()).returns(z97.promise(spiceEngineSimulationResult)).describe(
+var spiceEngineZod = z103.object({
+  simulate: z103.function().args(z103.string()).returns(z103.promise(spiceEngineSimulationResult)).describe(
     "A function that takes a SPICE string and returns a simulation result"
   )
 });
-var autorouterInstance = z97.object({
-  run: z97.function().args().returns(z97.promise(z97.unknown())).describe("Run the autorouter"),
-  getOutputSimpleRouteJson: z97.function().args().returns(z97.promise(z97.any())).describe("Get the resulting SimpleRouteJson")
+var autorouterInstance = z103.object({
+  run: z103.function().args().returns(z103.promise(z103.unknown())).describe("Run the autorouter"),
+  getOutputSimpleRouteJson: z103.function().args().returns(z103.promise(z103.any())).describe("Get the resulting SimpleRouteJson")
 });
-var autorouterDefinition = z97.object({
-  createAutorouter: z97.function().args(z97.any(), z97.any().optional()).returns(z97.union([autorouterInstance, z97.promise(autorouterInstance)])).describe("Create an autorouter instance")
+var autorouterDefinition = z103.object({
+  createAutorouter: z103.function().args(z103.any(), z103.any().optional()).returns(z103.union([autorouterInstance, z103.promise(autorouterInstance)])).describe("Create an autorouter instance")
 });
-var platformConfig = z97.object({
+var platformConfig = z103.object({
   partsEngine: partsEngine.optional(),
   autorouter: autorouterProp.optional(),
-  autorouterMap: z97.record(z97.string(), autorouterDefinition).optional(),
-  registryApiUrl: z97.string().optional(),
-  cloudAutorouterUrl: z97.string().optional(),
-  projectName: z97.string().optional(),
-  projectBaseUrl: z97.string().optional(),
-  version: z97.string().optional(),
-  url: z97.string().optional(),
-  printBoardInformationToSilkscreen: z97.boolean().optional(),
-  localCacheEngine: z97.any().optional(),
-  pcbDisabled: z97.boolean().optional(),
-  schematicDisabled: z97.boolean().optional(),
-  partsEngineDisabled: z97.boolean().optional(),
-  spiceEngineMap: z97.record(z97.string(), spiceEngineZod).optional(),
-  footprintLibraryMap: z97.record(
-    z97.string(),
-    z97.union([
+  autorouterMap: z103.record(z103.string(), autorouterDefinition).optional(),
+  registryApiUrl: z103.string().optional(),
+  cloudAutorouterUrl: z103.string().optional(),
+  projectName: z103.string().optional(),
+  projectBaseUrl: z103.string().optional(),
+  version: z103.string().optional(),
+  url: z103.string().optional(),
+  printBoardInformationToSilkscreen: z103.boolean().optional(),
+  localCacheEngine: z103.any().optional(),
+  pcbDisabled: z103.boolean().optional(),
+  schematicDisabled: z103.boolean().optional(),
+  partsEngineDisabled: z103.boolean().optional(),
+  spiceEngineMap: z103.record(z103.string(), spiceEngineZod).optional(),
+  footprintLibraryMap: z103.record(
+    z103.string(),
+    z103.union([
       pathToCircuitJsonFn,
-      z97.record(
-        z97.string(),
-        z97.union([unvalidatedCircuitJson, pathToCircuitJsonFn])
+      z103.record(
+        z103.string(),
+        z103.union([unvalidatedCircuitJson, pathToCircuitJsonFn])
       )
     ])
   ).optional(),
-  footprintFileParserMap: z97.record(z97.string(), footprintFileParserEntry).optional(),
+  footprintFileParserMap: z103.record(z103.string(), footprintFileParserEntry).optional(),
   simSwitchFrequency: frequency4.optional(),
   simCloseAt: ms2.optional(),
   simOpenAt: ms2.optional(),
-  simStartClosed: z97.boolean().optional(),
-  simStartOpen: z97.boolean().optional()
+  simStartClosed: z103.boolean().optional(),
+  simStartOpen: z103.boolean().optional()
 });
 expectTypesMatch(true);
 
@@ -2068,6 +2158,7 @@ export {
   edit_schematic_group_location_event,
   edit_trace_hint_event,
   explicitPinSideDefinition,
+  fabricationNoteDimensionProps,
   fabricationNotePathProps,
   fabricationNoteRectProps,
   fabricationNoteTextProps,
@@ -2099,6 +2190,11 @@ export {
   partsEngine,
   pcbKeepoutProps,
   pcbLayoutProps,
+  pcbNoteDimensionProps,
+  pcbNoteLineProps,
+  pcbNotePathProps,
+  pcbNoteRectProps,
+  pcbNoteTextProps,
   pcbSameXConstraintProps,
   pcbSameYConstraintProps,
   pcbTraceProps,