@tscircuit/core 0.0.2013 → 0.0.2015

package/dist/index.d.ts

@@ -110181,15 +110181,20 @@ declare class AssemblyDevice extends PrimitiveComponent<typeof assemblyDevicePro
         componentName: string;
         zodProps: zod.ZodObject<{
             name: zod.ZodOptional<zod.ZodString>;
+            modelUrl: zod.ZodOptional<zod.ZodEffects<zod.ZodType<string, zod.ZodTypeDef, string>, string, string>>;
         }, "strip", zod.ZodTypeAny, {
             name?: string | undefined;
+            modelUrl?: string | undefined;
         }, {
             name?: string | undefined;
+            modelUrl?: string | undefined;
         }>;
     };
     doInitialAssignNameToUnnamedComponents(): void;
     computeSchematicGlobalTransform(): Matrix;
     _computePcbGlobalTransformBeforeLayout(): Matrix;
+    doInitialSourceRender(): void;
+    doInitialCadModelRender(): void;
 }
 
 declare class AssemblyScreen extends PrimitiveComponent<typeof assemblyScreenProps> implements AssemblyDeviceContainer {
@@ -110198,6 +110203,7 @@ declare class AssemblyScreen extends PrimitiveComponent<typeof assemblyScreenPro
         componentName: string;
         zodProps: zod.ZodEffects<zod.ZodObject<{
             name: zod.ZodEffects<zod.ZodString, string, string>;
+            modelUrl: zod.ZodOptional<zod.ZodEffects<zod.ZodType<string, zod.ZodTypeDef, string>, string, string>>;
             connectsTo: zod.ZodEffects<zod.ZodString, string, string>;
             width: zod.ZodOptional<zod.ZodEffects<zod.ZodEffects<zod.ZodUnion<[zod.ZodString, zod.ZodNumber]>, number, string | number>, number, string | number>>;
             height: zod.ZodOptional<zod.ZodEffects<zod.ZodEffects<zod.ZodUnion<[zod.ZodString, zod.ZodNumber]>, number, string | number>, number, string | number>>;
@@ -110207,24 +110213,28 @@ declare class AssemblyScreen extends PrimitiveComponent<typeof assemblyScreenPro
             connectsTo: string;
             width?: number | undefined;
             height?: number | undefined;
+            modelUrl?: string | undefined;
             cadModel?: string | undefined;
         }, {
             name: string;
             connectsTo: string;
             width?: string | number | undefined;
             height?: string | number | undefined;
+            modelUrl?: string | undefined;
             cadModel?: string | undefined;
         }>, {
             name: string;
             connectsTo: string;
             width?: number | undefined;
             height?: number | undefined;
+            modelUrl?: string | undefined;
             cadModel?: string | undefined;
         }, {
             name: string;
             connectsTo: string;
             width?: string | number | undefined;
             height?: string | number | undefined;
+            modelUrl?: string | undefined;
             cadModel?: string | undefined;
         }>;
     };
@@ -110237,9 +110247,10 @@ declare class AssemblySubassembly extends PrimitiveComponent<typeof assemblySuba
     isAssemblyDeviceContainer: true;
     get config(): {
         componentName: string;
-        zodProps: zod.ZodObject<{
+        zodProps: zod.ZodEffects<zod.ZodObject<{
             name: zod.ZodEffects<zod.ZodString, string, string>;
             displayName: zod.ZodOptional<zod.ZodString>;
+            modelUrl: zod.ZodOptional<zod.ZodEffects<zod.ZodType<string, zod.ZodTypeDef, string>, string, string>>;
             cadModel: zod.ZodOptional<zod.ZodUnion<[zod.ZodNull, zod.ZodString, zod.ZodType<react.ReactElement<any, string | react.JSXElementConstructor<any>>, zod.ZodTypeDef, react.ReactElement<any, string | react.JSXElementConstructor<any>>>, zod.ZodObject<{
                 rotationOffset: zod.ZodOptional<zod.ZodUnion<[zod.ZodNumber, zod.ZodObject<{
                     x: zod.ZodUnion<[zod.ZodNumber, zod.ZodString]>;
@@ -111582,6 +111593,579 @@ declare class AssemblySubassembly extends PrimitiveComponent<typeof assemblySuba
         }, "strip", zod.ZodTypeAny, {
             name: string;
             displayName?: string | undefined;
+            modelUrl?: string | undefined;
+            cadModel?: string | {
+                stlUrl: string;
+                rotationOffset?: number | {
+                    x: string | number;
+                    y: string | number;
+                    z: string | number;
+                } | undefined;
+                positionOffset?: {
+                    x: number;
+                    y: number;
+                    z: number;
+                } | undefined;
+                modelOriginPosition?: {
+                    x: number;
+                    y: number;
+                    z: number;
+                } | undefined;
+                modelBounds?: {
+                    min: {
+                        x: number;
+                        y: number;
+                        z: number;
+                    };
+                    max: {
+                        x: number;
+                        y: number;
+                        z: number;
+                    };
+                } | undefined;
+                size?: {
+                    x: number;
+                    y: number;
+                    z: number;
+                } | undefined;
+                modelUnitToMmScale?: number | undefined;
+                modelBoardNormalDirection?: "x+" | "x-" | "y+" | "y-" | "z+" | "z-" | undefined;
+                pcbRotationOffset?: number | undefined;
+                zOffsetFromSurface?: number | undefined;
+                showAsTranslucentModel?: boolean | undefined;
+                stepUrl?: string | undefined;
+            } | {
+                objUrl: string;
+                rotationOffset?: number | {
+                    x: string | number;
+                    y: string | number;
+                    z: string | number;
+                } | undefined;
+                positionOffset?: {
+                    x: number;
+                    y: number;
+                    z: number;
+                } | undefined;
+                modelOriginPosition?: {
+                    x: number;
+                    y: number;
+                    z: number;
+                } | undefined;
+                modelBounds?: {
+                    min: {
+                        x: number;
+                        y: number;
+                        z: number;
+                    };
+                    max: {
+                        x: number;
+                        y: number;
+                        z: number;
+                    };
+                } | undefined;
+                size?: {
+                    x: number;
+                    y: number;
+                    z: number;
+                } | undefined;
+                modelUnitToMmScale?: number | undefined;
+                modelBoardNormalDirection?: "x+" | "x-" | "y+" | "y-" | "z+" | "z-" | undefined;
+                pcbRotationOffset?: number | undefined;
+                zOffsetFromSurface?: number | undefined;
+                showAsTranslucentModel?: boolean | undefined;
+                stepUrl?: string | undefined;
+                mtlUrl?: string | undefined;
+            } | {
+                gltfUrl: string;
+                rotationOffset?: number | {
+                    x: string | number;
+                    y: string | number;
+                    z: string | number;
+                } | undefined;
+                positionOffset?: {
+                    x: number;
+                    y: number;
+                    z: number;
+                } | undefined;
+                modelOriginPosition?: {
+                    x: number;
+                    y: number;
+                    z: number;
+                } | undefined;
+                modelBounds?: {
+                    min: {
+                        x: number;
+                        y: number;
+                        z: number;
+                    };
+                    max: {
+                        x: number;
+                        y: number;
+                        z: number;
+                    };
+                } | undefined;
+                size?: {
+                    x: number;
+                    y: number;
+                    z: number;
+                } | undefined;
+                modelUnitToMmScale?: number | undefined;
+                modelBoardNormalDirection?: "x+" | "x-" | "y+" | "y-" | "z+" | "z-" | undefined;
+                pcbRotationOffset?: number | undefined;
+                zOffsetFromSurface?: number | undefined;
+                showAsTranslucentModel?: boolean | undefined;
+                stepUrl?: string | undefined;
+            } | {
+                glbUrl: string;
+                rotationOffset?: number | {
+                    x: string | number;
+                    y: string | number;
+                    z: string | number;
+                } | undefined;
+                positionOffset?: {
+                    x: number;
+                    y: number;
+                    z: number;
+                } | undefined;
+                modelOriginPosition?: {
+                    x: number;
+                    y: number;
+                    z: number;
+                } | undefined;
+                modelBounds?: {
+                    min: {
+                        x: number;
+                        y: number;
+                        z: number;
+                    };
+                    max: {
+                        x: number;
+                        y: number;
+                        z: number;
+                    };
+                } | undefined;
+                size?: {
+                    x: number;
+                    y: number;
+                    z: number;
+                } | undefined;
+                modelUnitToMmScale?: number | undefined;
+                modelBoardNormalDirection?: "x+" | "x-" | "y+" | "y-" | "z+" | "z-" | undefined;
+                pcbRotationOffset?: number | undefined;
+                zOffsetFromSurface?: number | undefined;
+                showAsTranslucentModel?: boolean | undefined;
+                stepUrl?: string | undefined;
+            } | {
+                stepUrl: string;
+                rotationOffset?: number | {
+                    x: string | number;
+                    y: string | number;
+                    z: string | number;
+                } | undefined;
+                positionOffset?: {
+                    x: number;
+                    y: number;
+                    z: number;
+                } | undefined;
+                modelOriginPosition?: {
+                    x: number;
+                    y: number;
+                    z: number;
+                } | undefined;
+                modelBounds?: {
+                    min: {
+                        x: number;
+                        y: number;
+                        z: number;
+                    };
+                    max: {
+                        x: number;
+                        y: number;
+                        z: number;
+                    };
+                } | undefined;
+                size?: {
+                    x: number;
+                    y: number;
+                    z: number;
+                } | undefined;
+                modelUnitToMmScale?: number | undefined;
+                modelBoardNormalDirection?: "x+" | "x-" | "y+" | "y-" | "z+" | "z-" | undefined;
+                pcbRotationOffset?: number | undefined;
+                zOffsetFromSurface?: number | undefined;
+                showAsTranslucentModel?: boolean | undefined;
+            } | {
+                wrlUrl: string;
+                rotationOffset?: number | {
+                    x: string | number;
+                    y: string | number;
+                    z: string | number;
+                } | undefined;
+                positionOffset?: {
+                    x: number;
+                    y: number;
+                    z: number;
+                } | undefined;
+                modelOriginPosition?: {
+                    x: number;
+                    y: number;
+                    z: number;
+                } | undefined;
+                modelBounds?: {
+                    min: {
+                        x: number;
+                        y: number;
+                        z: number;
+                    };
+                    max: {
+                        x: number;
+                        y: number;
+                        z: number;
+                    };
+                } | undefined;
+                size?: {
+                    x: number;
+                    y: number;
+                    z: number;
+                } | undefined;
+                modelUnitToMmScale?: number | undefined;
+                modelBoardNormalDirection?: "x+" | "x-" | "y+" | "y-" | "z+" | "z-" | undefined;
+                pcbRotationOffset?: number | undefined;
+                zOffsetFromSurface?: number | undefined;
+                showAsTranslucentModel?: boolean | undefined;
+                stepUrl?: string | undefined;
+            } | {
+                jscad: Record<string, any>;
+                rotationOffset?: number | {
+                    x: string | number;
+                    y: string | number;
+                    z: string | number;
+                } | undefined;
+                positionOffset?: {
+                    x: number;
+                    y: number;
+                    z: number;
+                } | undefined;
+                modelOriginPosition?: {
+                    x: number;
+                    y: number;
+                    z: number;
+                } | undefined;
+                modelBounds?: {
+                    min: {
+                        x: number;
+                        y: number;
+                        z: number;
+                    };
+                    max: {
+                        x: number;
+                        y: number;
+                        z: number;
+                    };
+                } | undefined;
+                size?: {
+                    x: number;
+                    y: number;
+                    z: number;
+                } | undefined;
+                modelUnitToMmScale?: number | undefined;
+                modelBoardNormalDirection?: "x+" | "x-" | "y+" | "y-" | "z+" | "z-" | undefined;
+                pcbRotationOffset?: number | undefined;
+                zOffsetFromSurface?: number | undefined;
+                showAsTranslucentModel?: boolean | undefined;
+                stepUrl?: string | undefined;
+            } | react.ReactElement<any, string | react.JSXElementConstructor<any>> | null | undefined;
+            children?: react.ReactNode;
+        }, {
+            name: string;
+            displayName?: string | undefined;
+            modelUrl?: string | undefined;
+            cadModel?: string | {
+                stlUrl: string;
+                rotationOffset?: number | {
+                    x: string | number;
+                    y: string | number;
+                    z: string | number;
+                } | undefined;
+                positionOffset?: {
+                    x: string | number;
+                    y: string | number;
+                    z: string | number;
+                } | undefined;
+                modelOriginPosition?: {
+                    x: string | number;
+                    y: string | number;
+                    z: string | number;
+                } | undefined;
+                modelBounds?: {
+                    min: {
+                        x: string | number;
+                        y: string | number;
+                        z: string | number;
+                    };
+                    max: {
+                        x: string | number;
+                        y: string | number;
+                        z: string | number;
+                    };
+                } | undefined;
+                size?: {
+                    x: string | number;
+                    y: string | number;
+                    z: string | number;
+                } | undefined;
+                modelUnitToMmScale?: string | number | undefined;
+                modelBoardNormalDirection?: "x+" | "x-" | "y+" | "y-" | "z+" | "z-" | undefined;
+                pcbRotationOffset?: number | undefined;
+                zOffsetFromSurface?: string | number | undefined;
+                showAsTranslucentModel?: boolean | undefined;
+                stepUrl?: string | undefined;
+            } | {
+                objUrl: string;
+                rotationOffset?: number | {
+                    x: string | number;
+                    y: string | number;
+                    z: string | number;
+                } | undefined;
+                positionOffset?: {
+                    x: string | number;
+                    y: string | number;
+                    z: string | number;
+                } | undefined;
+                modelOriginPosition?: {
+                    x: string | number;
+                    y: string | number;
+                    z: string | number;
+                } | undefined;
+                modelBounds?: {
+                    min: {
+                        x: string | number;
+                        y: string | number;
+                        z: string | number;
+                    };
+                    max: {
+                        x: string | number;
+                        y: string | number;
+                        z: string | number;
+                    };
+                } | undefined;
+                size?: {
+                    x: string | number;
+                    y: string | number;
+                    z: string | number;
+                } | undefined;
+                modelUnitToMmScale?: string | number | undefined;
+                modelBoardNormalDirection?: "x+" | "x-" | "y+" | "y-" | "z+" | "z-" | undefined;
+                pcbRotationOffset?: number | undefined;
+                zOffsetFromSurface?: string | number | undefined;
+                showAsTranslucentModel?: boolean | undefined;
+                stepUrl?: string | undefined;
+                mtlUrl?: string | undefined;
+            } | {
+                gltfUrl: string;
+                rotationOffset?: number | {
+                    x: string | number;
+                    y: string | number;
+                    z: string | number;
+                } | undefined;
+                positionOffset?: {
+                    x: string | number;
+                    y: string | number;
+                    z: string | number;
+                } | undefined;
+                modelOriginPosition?: {
+                    x: string | number;
+                    y: string | number;
+                    z: string | number;
+                } | undefined;
+                modelBounds?: {
+                    min: {
+                        x: string | number;
+                        y: string | number;
+                        z: string | number;
+                    };
+                    max: {
+                        x: string | number;
+                        y: string | number;
+                        z: string | number;
+                    };
+                } | undefined;
+                size?: {
+                    x: string | number;
+                    y: string | number;
+                    z: string | number;
+                } | undefined;
+                modelUnitToMmScale?: string | number | undefined;
+                modelBoardNormalDirection?: "x+" | "x-" | "y+" | "y-" | "z+" | "z-" | undefined;
+                pcbRotationOffset?: number | undefined;
+                zOffsetFromSurface?: string | number | undefined;
+                showAsTranslucentModel?: boolean | undefined;
+                stepUrl?: string | undefined;
+            } | {
+                glbUrl: string;
+                rotationOffset?: number | {
+                    x: string | number;
+                    y: string | number;
+                    z: string | number;
+                } | undefined;
+                positionOffset?: {
+                    x: string | number;
+                    y: string | number;
+                    z: string | number;
+                } | undefined;
+                modelOriginPosition?: {
+                    x: string | number;
+                    y: string | number;
+                    z: string | number;
+                } | undefined;
+                modelBounds?: {
+                    min: {
+                        x: string | number;
+                        y: string | number;
+                        z: string | number;
+                    };
+                    max: {
+                        x: string | number;
+                        y: string | number;
+                        z: string | number;
+                    };
+                } | undefined;
+                size?: {
+                    x: string | number;
+                    y: string | number;
+                    z: string | number;
+                } | undefined;
+                modelUnitToMmScale?: string | number | undefined;
+                modelBoardNormalDirection?: "x+" | "x-" | "y+" | "y-" | "z+" | "z-" | undefined;
+                pcbRotationOffset?: number | undefined;
+                zOffsetFromSurface?: string | number | undefined;
+                showAsTranslucentModel?: boolean | undefined;
+                stepUrl?: string | undefined;
+            } | {
+                stepUrl: string;
+                rotationOffset?: number | {
+                    x: string | number;
+                    y: string | number;
+                    z: string | number;
+                } | undefined;
+                positionOffset?: {
+                    x: string | number;
+                    y: string | number;
+                    z: string | number;
+                } | undefined;
+                modelOriginPosition?: {
+                    x: string | number;
+                    y: string | number;
+                    z: string | number;
+                } | undefined;
+                modelBounds?: {
+                    min: {
+                        x: string | number;
+                        y: string | number;
+                        z: string | number;
+                    };
+                    max: {
+                        x: string | number;
+                        y: string | number;
+                        z: string | number;
+                    };
+                } | undefined;
+                size?: {
+                    x: string | number;
+                    y: string | number;
+                    z: string | number;
+                } | undefined;
+                modelUnitToMmScale?: string | number | undefined;
+                modelBoardNormalDirection?: "x+" | "x-" | "y+" | "y-" | "z+" | "z-" | undefined;
+                pcbRotationOffset?: number | undefined;
+                zOffsetFromSurface?: string | number | undefined;
+                showAsTranslucentModel?: boolean | undefined;
+            } | {
+                wrlUrl: string;
+                rotationOffset?: number | {
+                    x: string | number;
+                    y: string | number;
+                    z: string | number;
+                } | undefined;
+                positionOffset?: {
+                    x: string | number;
+                    y: string | number;
+                    z: string | number;
+                } | undefined;
+                modelOriginPosition?: {
+                    x: string | number;
+                    y: string | number;
+                    z: string | number;
+                } | undefined;
+                modelBounds?: {
+                    min: {
+                        x: string | number;
+                        y: string | number;
+                        z: string | number;
+                    };
+                    max: {
+                        x: string | number;
+                        y: string | number;
+                        z: string | number;
+                    };
+                } | undefined;
+                size?: {
+                    x: string | number;
+                    y: string | number;
+                    z: string | number;
+                } | undefined;
+                modelUnitToMmScale?: string | number | undefined;
+                modelBoardNormalDirection?: "x+" | "x-" | "y+" | "y-" | "z+" | "z-" | undefined;
+                pcbRotationOffset?: number | undefined;
+                zOffsetFromSurface?: string | number | undefined;
+                showAsTranslucentModel?: boolean | undefined;
+                stepUrl?: string | undefined;
+            } | {
+                jscad: Record<string, any>;
+                rotationOffset?: number | {
+                    x: string | number;
+                    y: string | number;
+                    z: string | number;
+                } | undefined;
+                positionOffset?: {
+                    x: string | number;
+                    y: string | number;
+                    z: string | number;
+                } | undefined;
+                modelOriginPosition?: {
+                    x: string | number;
+                    y: string | number;
+                    z: string | number;
+                } | undefined;
+                modelBounds?: {
+                    min: {
+                        x: string | number;
+                        y: string | number;
+                        z: string | number;
+                    };
+                    max: {
+                        x: string | number;
+                        y: string | number;
+                        z: string | number;
+                    };
+                } | undefined;
+                size?: {
+                    x: string | number;
+                    y: string | number;
+                    z: string | number;
+                } | undefined;
+                modelUnitToMmScale?: string | number | undefined;
+                modelBoardNormalDirection?: "x+" | "x-" | "y+" | "y-" | "z+" | "z-" | undefined;
+                pcbRotationOffset?: number | undefined;
+                zOffsetFromSurface?: string | number | undefined;
+                showAsTranslucentModel?: boolean | undefined;
+                stepUrl?: string | undefined;
+            } | react.ReactElement<any, string | react.JSXElementConstructor<any>> | null | undefined;
+            children?: react.ReactNode;
+        }>, {
+            name: string;
+            displayName?: string | undefined;
+            modelUrl?: string | undefined;
             cadModel?: string | {
                 stlUrl: string;
                 rotationOffset?: number | {
@@ -111867,6 +112451,7 @@ declare class AssemblySubassembly extends PrimitiveComponent<typeof assemblySuba
         }, {
             name: string;
             displayName?: string | undefined;
+            modelUrl?: string | undefined;
             cadModel?: string | {
                 stlUrl: string;
                 rotationOffset?: number | {

package/dist/index.js

@@ -3196,6 +3196,53 @@ function fillPolygonWithRects(polygon, options = {}) {
   return rects;
 }
 
+// lib/utils/obstacles/generateApproximatingRects.ts
+function generateApproximatingRects(rotatedRect, numRects = 2) {
+  const { center, width, height, rotation: rotation5 } = rotatedRect;
+  const rects = [];
+  const angleRad = rotation5 * Math.PI / 180;
+  const cosAngle = Math.cos(angleRad);
+  const sinAngle = Math.sin(angleRad);
+  const normalizedRotation = (rotation5 % 360 + 360) % 360;
+  const sliceAlongWidth = height <= width ? normalizedRotation >= 45 && normalizedRotation < 135 || normalizedRotation >= 225 && normalizedRotation < 315 : normalizedRotation >= 135 && normalizedRotation < 225 || normalizedRotation >= 315 || normalizedRotation < 45;
+  if (sliceAlongWidth) {
+    const sliceWidth = width / numRects;
+    for (let i = 0; i < numRects; i++) {
+      const x = (i - numRects / 2 + 0.5) * sliceWidth;
+      const rotatedX = -x * cosAngle;
+      const rotatedY = -x * sinAngle;
+      const coverageWidth = sliceWidth * 1.1;
+      const coverageHeight = Math.abs(height * cosAngle) + Math.abs(sliceWidth * sinAngle);
+      rects.push({
+        center: {
+          x: center.x + rotatedX,
+          y: center.y + rotatedY
+        },
+        width: coverageWidth,
+        height: coverageHeight
+      });
+    }
+  } else {
+    const sliceHeight = height / numRects;
+    for (let i = 0; i < numRects; i++) {
+      const y = (i - numRects / 2 + 0.5) * sliceHeight;
+      const rotatedX = -y * sinAngle;
+      const rotatedY = y * cosAngle;
+      const coverageWidth = Math.abs(width * cosAngle) + Math.abs(sliceHeight * sinAngle);
+      const coverageHeight = sliceHeight * 1.1;
+      rects.push({
+        center: {
+          x: center.x + rotatedX,
+          y: center.y + rotatedY
+        },
+        width: coverageWidth,
+        height: coverageHeight
+      });
+    }
+  }
+  return rects;
+}
+
 // lib/utils/obstacles/getAxisAlignedRectFromPolygon.ts
 var AXIS_ALIGNED_RECT_TOLERANCE_MM = 1e-3;
 var getAxisAlignedRectFromPolygon = (points) => {
@@ -3233,6 +3280,59 @@ var getAxisAlignedRectFromPolygon = (points) => {
   };
 };
 
+// lib/utils/obstacles/getObstaclesFromPcbKeepoutOutline.ts
+var getObstaclesFromPcbKeepoutOutline = (keepout, componentId) => {
+  const { outline, stroke_width } = keepout;
+  if (!Number.isFinite(stroke_width) || stroke_width <= 0) return [];
+  const obstacles = [];
+  for (let segmentIndex = 0; segmentIndex < outline.length - 1; segmentIndex++) {
+    const start = outline[segmentIndex];
+    const end = outline[segmentIndex + 1];
+    const deltaX = end.x - start.x;
+    const deltaY = end.y - start.y;
+    const segmentLength = Math.hypot(deltaX, deltaY);
+    if (!Number.isFinite(segmentLength) || segmentLength === 0) continue;
+    const approximatingRects = generateApproximatingRects({
+      center: {
+        x: (start.x + end.x) / 2,
+        y: (start.y + end.y) / 2
+      },
+      width: segmentLength,
+      height: stroke_width,
+      rotation: Math.atan2(deltaY, deltaX) * 180 / Math.PI
+    });
+    for (const [approximationIndex, rect] of approximatingRects.entries()) {
+      obstacles.push({
+        obstacleId: `${keepout.pcb_keepout_id}_segment_${segmentIndex}_rect_${approximationIndex}`,
+        componentId,
+        type: "rect",
+        layers: keepout.layers,
+        ...rect,
+        connectedTo: []
+      });
+    }
+  }
+  const isClosed = outline.length > 1 && outline[0].x === outline.at(-1)?.x && outline[0].y === outline.at(-1)?.y;
+  const joinPoints = isClosed ? outline.slice(0, -1) : outline;
+  for (const [joinIndex, point6] of joinPoints.entries()) {
+    const approximatingRects = fillCircleWithRects(
+      { center: point6, radius: stroke_width / 2 },
+      { rectHeight: stroke_width / 4 }
+    );
+    for (const [approximationIndex, rect] of approximatingRects.entries()) {
+      obstacles.push({
+        obstacleId: `${keepout.pcb_keepout_id}_join_${joinIndex}_rect_${approximationIndex}`,
+        componentId,
+        type: "rect",
+        layers: keepout.layers,
+        ...rect,
+        connectedTo: []
+      });
+    }
+  }
+  return obstacles;
+};
+
 // lib/utils/obstacles/getObstaclesFromRoute.ts
 var isCloseTo = (a, b) => Math.abs(a - b) < 1e-4;
 var getObstaclesFromRoute = (route, source_trace_id, { viaDiameter = 0.5 } = {}) => {
@@ -3472,6 +3572,10 @@ var getObstaclesFromCircuitJson = (circuitJson, connMap) => {
           height: element.height,
           connectedTo: []
         });
+      } else if (element.shape === "outline") {
+        obstacles.push(
+          ...getObstaclesFromPcbKeepoutOutline(element, pcbComponentId)
+        );
       }
     } else if (element.type === "pcb_cutout") {
       if (element.shape === "rect") {
@@ -13815,10 +13919,28 @@ var getFileExtension = (filename) => {
 };
 
 // lib/components/primitive-components/CadModel_renderInAssembly.ts
-import {
-  cadModelBase as cadModelBase2,
-  point3 as point32
-} from "@tscircuit/props";
+import { cadModelBase as cadModelBase2, point3 as point32 } from "@tscircuit/props";
+
+// lib/components/primitive-components/resolve-assembly-model-url.ts
+var resolveAssemblyModelUrl = (modelUrl) => {
+  const url = modelUrl.replace(/#ext=\w+$/, "");
+  switch (getFileExtension(modelUrl)) {
+    case "obj":
+      return { objUrl: url };
+    case "gltf":
+      return { gltfUrl: url };
+    case "glb":
+      return { glbUrl: url };
+    case "step":
+    case "stp":
+      return { stepUrl: url };
+    case "wrl":
+    case "vrml":
+      return { wrlUrl: url };
+    default:
+      return { stlUrl: url };
+  }
+};
 
 // lib/components/primitive-components/render-assembly-cad-model.ts
 import { normalizeDegrees as normalizeDegrees3 } from "@tscircuit/math-utils";
@@ -13905,30 +14027,7 @@ var CadModel_renderInAssembly = (component) => {
       z: props.pcbZ ?? 0
     })
   });
-  const modelUrl = props.modelUrl.replace(/#ext=\w+$/, "");
-  let model;
-  switch (getFileExtension(props.modelUrl)) {
-    case "obj":
-      model = { ...base, objUrl: modelUrl };
-      break;
-    case "gltf":
-      model = { ...base, gltfUrl: modelUrl };
-      break;
-    case "glb":
-      model = { ...base, glbUrl: modelUrl };
-      break;
-    case "step":
-    case "stp":
-      model = { ...base, stepUrl: modelUrl };
-      break;
-    case "wrl":
-    case "vrml":
-      model = { ...base, wrlUrl: modelUrl };
-      break;
-    default:
-      model = { ...base, stlUrl: modelUrl };
-      break;
-  }
+  const model = { ...base, ...resolveAssemblyModelUrl(props.modelUrl) };
   component.cad_component_id = renderAssemblyCadModel(owner, model, placement);
   return true;
 };
@@ -64471,7 +64570,7 @@ function Group_getRoutingPhasePlans(group) {
 var package_default = {
   name: "@tscircuit/core",
   type: "module",
-  version: "0.0.2012",
+  version: "0.0.2014",
   types: "dist/index.d.ts",
   main: "dist/index.js",
   module: "dist/index.js",
@@ -64526,7 +64625,7 @@ var package_default = {
     "@tscircuit/math-utils": "^0.0.36",
     "@tscircuit/miniflex": "^0.0.4",
     "@tscircuit/ngspice-spice-engine": "^0.0.20",
-    "@tscircuit/props": "^0.0.669",
+    "@tscircuit/props": "^0.0.670",
     "@tscircuit/schematic-match-adapt": "^0.0.18",
     "@tscircuit/schematic-trace-solver": "^0.0.212",
     "@tscircuit/solver-utils": "^0.0.16",
@@ -64605,7 +64704,7 @@ var package_default = {
   },
   overrides: {
     "@tscircuit/circuit-json-util": "^0.0.116",
-    "@tscircuit/props": "^0.0.669",
+    "@tscircuit/props": "^0.0.670",
     "circuit-json": "^0.0.506"
   }
 };
@@ -76441,9 +76540,22 @@ var AssemblyDevice = class extends PrimitiveComponent2 {
   _computePcbGlobalTransformBeforeLayout() {
     return identity10();
   }
-  // Compatibility stage: this is a transparent product-level container and emits no
-  // Circuit JSON. The later schema migration adds source_assembly_device without
-  // changing the authoring element or its assembly-container semantics.
+  doInitialSourceRender() {
+    if (this._parsedProps.modelUrl === void 0 || !this.root) return;
+    this.source_component_id = this.root.db.source_component.insert({
+      ftype: "simple_chip",
+      name: this.name
+    }).source_component_id;
+  }
+  doInitialCadModelRender() {
+    if (!this.root || this.root.pcbDisabled || !this.source_component_id || this._parsedProps.modelUrl === void 0)
+      return;
+    this.cad_component_id = renderAssemblyCadModel(
+      this,
+      resolveAssemblyModelUrl(this._parsedProps.modelUrl),
+      { position: { x: 0, y: 0, z: 0 }, pcbRotation: 0, layer: "top" }
+    );
+  }
 };
 
 // lib/components/primitive-components/AssemblyScreen.ts
@@ -76466,7 +76578,7 @@ var AssemblyScreen_doInitialCadModelRender = (component) => {
   const placement = resolveAssemblyPlacement(component);
   component.cad_component_id = renderAssemblyCadModel(
     component,
-    component._parsedProps.cadModel ?? getDefaultFlexScreenModel(component),
+    component._parsedProps.modelUrl !== void 0 ? resolveAssemblyModelUrl(component._parsedProps.modelUrl) : component._parsedProps.cadModel ?? getDefaultFlexScreenModel(component),
     placement
   );
 };
@@ -76525,7 +76637,7 @@ var AssemblySubassembly = class extends PrimitiveComponent2 {
   doInitialCadModelRender() {
     if (!this.root || this.root.pcbDisabled || !this.source_component_id) return;
     const placement = resolveAssemblyPlacement(this);
-    const model = this._parsedProps.cadModel;
+    const model = this._parsedProps.modelUrl !== void 0 ? resolveAssemblyModelUrl(this._parsedProps.modelUrl) : this._parsedProps.cadModel;
     if (model && !(typeof model === "object" && "type" in model)) {
       this.cad_component_id = renderAssemblyCadModel(this, model, placement);
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/core",
   "type": "module",
-  "version": "0.0.2013",
+  "version": "0.0.2015",
   "types": "dist/index.d.ts",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -56,7 +56,7 @@
     "@tscircuit/math-utils": "^0.0.36",
     "@tscircuit/miniflex": "^0.0.4",
     "@tscircuit/ngspice-spice-engine": "^0.0.20",
-    "@tscircuit/props": "^0.0.669",
+    "@tscircuit/props": "^0.0.670",
     "@tscircuit/schematic-match-adapt": "^0.0.18",
     "@tscircuit/schematic-trace-solver": "^0.0.212",
     "@tscircuit/solver-utils": "^0.0.16",
@@ -135,7 +135,7 @@
   },
   "overrides": {
     "@tscircuit/circuit-json-util": "^0.0.116",
-    "@tscircuit/props": "^0.0.669",
+    "@tscircuit/props": "^0.0.670",
     "circuit-json": "^0.0.506"
   }
 }