@cadit-app/fillet-script-with-unique-name 1.0.0

package/README.md

@@ -0,0 +1,45 @@
+# Fillet script with unique name
+
+![Fillet script with unique name](./images/fillet-image.webp)
+
+An implementation of a fillet algorithm for ManifoldCAD.
+
+> 🔧 This is a [CADit](https://cadit.app) script package - a code-based 3D model you can open and modify.
+> 
+> Open this design in [CADit](https://cadit.app) to preview in 3D, customize, and export.
+> You can also fork this design and re-publish your own version!
+
+## Use in Your Project
+
+Install as a dependency in your TypeScript/JavaScript project:
+
+```bash
+npm install @cadit-app/fillet-script-with-unique-name
+```
+
+Then import and use it in your code.
+
+## Build Locally
+
+Clone this repo and build 3D files offline:
+
+```bash
+git clone https://github.com/CADit-app/fillet-script-with-unique-name.git
+cd fillet-script-with-unique-name
+npm install
+npm run build:3mf
+npm run build:glb
+```
+
+## License
+
+[CC BY-SA 4.0 (Attribution-ShareAlike)](https://creativecommons.org/licenses/by-sa/4.0/)
+
+---
+
+<p align="center">
+  <sub>Created with <a href="https://cadit.app">CADit</a> - The open platform for code-based 3D models.</sub>
+</p>
+<p align="center">
+  <sub>Use our web-based <a href="https://app.cadit.app">CAD application</a> to create, open and edit designs visually.</sub>
+</p>

package/dist/context.d.ts

@@ -0,0 +1,3 @@
+import { ManifoldToplevel } from 'manifold-3d';
+export declare const setupFillet: (manifoldInstance: ManifoldToplevel) => void;
+export declare const getManifold: () => ManifoldToplevel;

package/dist/context.js

@@ -0,0 +1,10 @@
+let manifold;
+export const setupFillet = (manifoldInstance) => {
+    manifold = manifoldInstance;
+};
+export const getManifold = () => {
+    if (!manifold) {
+        throw new Error('Manifold instance not set. Call setupFillet(manifold) before using fillet functions.');
+    }
+    return manifold;
+};

package/dist/edgeSelection.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Edge selection types for fillet operations.
+ *
+ * Point-based selection: Find edges nearest to a 3D point
+ * Angle-based selection: Find all edges sharper than a threshold angle
+ */
+import { Manifold } from 'manifold-3d';
+/** Point-based edge selection - fillet edge nearest to a point */
+export interface PointEdgeSelection {
+    type: 'point';
+    point: [number, number, number];
+    maxDistance?: number;
+}
+/** Angle-based edge selection - fillet all edges sharper than threshold */
+export interface AngleEdgeSelection {
+    type: 'angle';
+    minAngle: number;
+}
+export type EdgeSelection = PointEdgeSelection | AngleEdgeSelection;
+/**
+ * Represents an edge in a mesh as a pair of vertex indices
+ * with associated face normals for dihedral angle calculation
+ */
+export interface MeshEdge {
+    v0: number;
+    v1: number;
+    /** Vertex positions */
+    p0: [number, number, number];
+    p1: [number, number, number];
+    /** Face normals of adjacent triangles */
+    n0: [number, number, number];
+    n1: [number, number, number];
+    /** Dihedral angle in degrees (180 = flat, 90 = right angle) */
+    dihedralAngle: number;
+}
+/**
+ * Extracts edges from a Manifold mesh with dihedral angle information.
+ * An edge is defined as a pair of vertices shared by exactly 2 triangles.
+ */
+export declare function extractEdges(mf: Manifold): MeshEdge[];
+/**
+ * Selects edges based on selection criteria.
+ */
+export declare function selectEdges(edges: MeshEdge[], selection: EdgeSelection): MeshEdge[];
+/**
+ * Sample points along an edge for tube generation.
+ */
+export declare function sampleEdge(edge: MeshEdge, numSamples?: number): [number, number, number][];
+/**
+ * Compute the edge direction (normalized).
+ */
+export declare function edgeDirection(edge: MeshEdge): [number, number, number];
+/**
+ * Compute the "inward" direction perpendicular to the edge,
+ * pointing into the solid (average of face normals, negated).
+ */
+export declare function edgeInwardDirection(edge: MeshEdge): [number, number, number];

package/dist/edgeSelection.js

@@ -0,0 +1,206 @@
+/**
+ * Edge selection types for fillet operations.
+ *
+ * Point-based selection: Find edges nearest to a 3D point
+ * Angle-based selection: Find all edges sharper than a threshold angle
+ */
+/**
+ * Extracts edges from a Manifold mesh with dihedral angle information.
+ * An edge is defined as a pair of vertices shared by exactly 2 triangles.
+ */
+export function extractEdges(mf) {
+    const mesh = mf.getMesh();
+    const { triVerts, vertProperties, numProp } = mesh;
+    const numTris = triVerts.length / 3;
+    // Build edge -> triangles map
+    // Key: "min_max" of vertex indices
+    const edgeToTris = new Map();
+    const getVertex = (idx) => {
+        const offset = idx * numProp;
+        return [
+            vertProperties[offset],
+            vertProperties[offset + 1],
+            vertProperties[offset + 2]
+        ];
+    };
+    const computeNormal = (v0, v1, v2) => {
+        // Edge vectors
+        const e1 = [v1[0] - v0[0], v1[1] - v0[1], v1[2] - v0[2]];
+        const e2 = [v2[0] - v0[0], v2[1] - v0[1], v2[2] - v0[2]];
+        // Cross product
+        const n = [
+            e1[1] * e2[2] - e1[2] * e2[1],
+            e1[2] * e2[0] - e1[0] * e2[2],
+            e1[0] * e2[1] - e1[1] * e2[0]
+        ];
+        // Normalize
+        const len = Math.sqrt(n[0] * n[0] + n[1] * n[1] + n[2] * n[2]);
+        if (len > 1e-12) {
+            n[0] /= len;
+            n[1] /= len;
+            n[2] /= len;
+        }
+        return n;
+    };
+    // Process each triangle
+    for (let t = 0; t < numTris; t++) {
+        const i0 = triVerts[t * 3];
+        const i1 = triVerts[t * 3 + 1];
+        const i2 = triVerts[t * 3 + 2];
+        const v0 = getVertex(i0);
+        const v1 = getVertex(i1);
+        const v2 = getVertex(i2);
+        const normal = computeNormal(v0, v1, v2);
+        // Add each edge of this triangle
+        const edges = [
+            [i0, i1],
+            [i1, i2],
+            [i2, i0]
+        ];
+        for (const [a, b] of edges) {
+            const key = a < b ? `${a}_${b}` : `${b}_${a}`;
+            if (!edgeToTris.has(key)) {
+                edgeToTris.set(key, []);
+            }
+            edgeToTris.get(key).push({ tri: t, normal });
+        }
+    }
+    // Extract edges that have exactly 2 adjacent triangles (manifold edges)
+    const meshEdges = [];
+    for (const [key, tris] of edgeToTris) {
+        if (tris.length !== 2)
+            continue; // Skip boundary or non-manifold edges
+        const [aStr, bStr] = key.split('_');
+        const v0 = parseInt(aStr);
+        const v1 = parseInt(bStr);
+        const p0 = getVertex(v0);
+        const p1 = getVertex(v1);
+        const n0 = tris[0].normal;
+        const n1 = tris[1].normal;
+        // Compute dihedral angle between face normals
+        const dot = n0[0] * n1[0] + n0[1] * n1[1] + n0[2] * n1[2];
+        const clampedDot = Math.max(-1, Math.min(1, dot));
+        const dihedralAngle = Math.acos(clampedDot) * (180 / Math.PI);
+        meshEdges.push({
+            v0,
+            v1,
+            p0,
+            p1,
+            n0,
+            n1,
+            dihedralAngle
+        });
+    }
+    return meshEdges;
+}
+/**
+ * Selects edges based on selection criteria.
+ */
+export function selectEdges(edges, selection) {
+    if (selection.type === 'point') {
+        return selectByPoint(edges, selection);
+    }
+    else {
+        return selectByAngle(edges, selection);
+    }
+}
+/**
+ * Find the edge closest to a point.
+ */
+function selectByPoint(edges, selection) {
+    const [px, py, pz] = selection.point;
+    const maxDist = selection.maxDistance ?? Infinity;
+    let closestEdge = null;
+    let closestDist = Infinity;
+    for (const edge of edges) {
+        const dist = pointToSegmentDistance([px, py, pz], edge.p0, edge.p1);
+        if (dist < closestDist && dist <= maxDist) {
+            closestDist = dist;
+            closestEdge = edge;
+        }
+    }
+    return closestEdge ? [closestEdge] : [];
+}
+/**
+ * Find all edges sharper than a threshold angle.
+ * A dihedral angle of 180° is flat (faces are coplanar).
+ * A dihedral angle of 90° is a right-angle edge.
+ *
+ * @param minAngle Minimum angle to consider "sharp" (e.g., 80 means edges < 100° dihedral)
+ */
+function selectByAngle(edges, selection) {
+    // minAngle represents how sharp the edge is
+    // 180 - dihedralAngle gives us the "sharpness" angle
+    const threshold = 180 - selection.minAngle;
+    return edges.filter(edge => edge.dihedralAngle <= threshold);
+}
+/**
+ * Compute distance from point to line segment.
+ */
+function pointToSegmentDistance(p, a, b) {
+    const ab = [b[0] - a[0], b[1] - a[1], b[2] - a[2]];
+    const ap = [p[0] - a[0], p[1] - a[1], p[2] - a[2]];
+    const abLenSq = ab[0] * ab[0] + ab[1] * ab[1] + ab[2] * ab[2];
+    if (abLenSq < 1e-12) {
+        // Degenerate segment
+        return Math.sqrt(ap[0] * ap[0] + ap[1] * ap[1] + ap[2] * ap[2]);
+    }
+    // Project point onto line, clamped to segment
+    const t = Math.max(0, Math.min(1, (ap[0] * ab[0] + ap[1] * ab[1] + ap[2] * ab[2]) / abLenSq));
+    // Closest point on segment
+    const closest = [
+        a[0] + t * ab[0],
+        a[1] + t * ab[1],
+        a[2] + t * ab[2]
+    ];
+    // Distance
+    const dx = p[0] - closest[0];
+    const dy = p[1] - closest[1];
+    const dz = p[2] - closest[2];
+    return Math.sqrt(dx * dx + dy * dy + dz * dz);
+}
+/**
+ * Sample points along an edge for tube generation.
+ */
+export function sampleEdge(edge, numSamples = 10) {
+    const samples = [];
+    for (let i = 0; i <= numSamples; i++) {
+        const t = i / numSamples;
+        samples.push([
+            edge.p0[0] + t * (edge.p1[0] - edge.p0[0]),
+            edge.p0[1] + t * (edge.p1[1] - edge.p0[1]),
+            edge.p0[2] + t * (edge.p1[2] - edge.p0[2])
+        ]);
+    }
+    return samples;
+}
+/**
+ * Compute the edge direction (normalized).
+ */
+export function edgeDirection(edge) {
+    const dx = edge.p1[0] - edge.p0[0];
+    const dy = edge.p1[1] - edge.p0[1];
+    const dz = edge.p1[2] - edge.p0[2];
+    const len = Math.sqrt(dx * dx + dy * dy + dz * dz);
+    if (len < 1e-12)
+        return [1, 0, 0];
+    return [dx / len, dy / len, dz / len];
+}
+/**
+ * Compute the "inward" direction perpendicular to the edge,
+ * pointing into the solid (average of face normals, negated).
+ */
+export function edgeInwardDirection(edge) {
+    // Average of face normals points "outward" from the edge
+    // For fillet, we want direction toward the solid interior
+    const n = [
+        (edge.n0[0] + edge.n1[0]) / 2,
+        (edge.n0[1] + edge.n1[1]) / 2,
+        (edge.n0[2] + edge.n1[2]) / 2
+    ];
+    const len = Math.sqrt(n[0] * n[0] + n[1] * n[1] + n[2] * n[2]);
+    if (len < 1e-12)
+        return [0, 0, 1];
+    // Negate to point inward
+    return [-n[0] / len, -n[1] / len, -n[2] / len];
+}

package/dist/example.d.ts

@@ -0,0 +1,3 @@
+import type { Manifold as ManifoldType } from 'manifold-3d';
+declare const _default: ManifoldType[];
+export default _default;

package/dist/example.js

@@ -0,0 +1,25 @@
+import { Manifold } from 'manifold-3d/manifoldCAD';
+import { fillet } from './fillet';
+const box = Manifold.cube([20, 20, 20], true);
+// Fillet the edge at position (10, 10, 0)
+const rounded = fillet(box, {
+    radius: 2,
+    selection: {
+        type: 'point',
+        point: [10, 10, 0],
+        maxDistance: 5 // optional: limit search radius
+    },
+    segments: 50
+});
+const box1 = Manifold.cube([20, 20, 20], true);
+// Fillet all sharp edges (dihedral angle < 100°)
+const fullyRounded = fillet(box1, {
+    radius: 2,
+    selection: {
+        type: 'angle',
+        minAngle: 80 // edges sharper than 80° from flat
+    },
+    segments: 50
+})
+    .translate([30, 0, 0]);
+export default [rounded, fullyRounded];

package/dist/fillet.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Fillet/Round operations for Manifold meshes.
+ *
+ * Implements the "dirty nasty (but working)" CSG approach from:
+ * https://github.com/elalish/manifold/discussions/1411
+ *
+ * Algorithm:
+ * 1. Create a tube (cylinder) tangent to the inner faces of the corner
+ * 2. Create a wedge (prism) that covers the corner tip but fits inside the tube's "back" side
+ * 3. Subtract tube from wedge → cutting tool (just the corner tip)
+ * 4. Subtract cutting tool from original → rounded edge
+ */
+import { Manifold } from 'manifold-3d';
+import { EdgeSelection } from './edgeSelection';
+export interface FilletOptions {
+    /** Fillet radius */
+    radius: number;
+    /** Edge selection criteria */
+    selection: EdgeSelection;
+    /** Number of segments for circular profiles (default: 16) */
+    segments?: number;
+}
+/**
+ * Apply fillet/round to selected edges of a Manifold.
+ */
+export declare function fillet(mf: Manifold, options: FilletOptions): Manifold;
+export type { EdgeSelection, PointEdgeSelection, AngleEdgeSelection } from './edgeSelection';

package/dist/fillet.js

@@ -0,0 +1,115 @@
+/**
+ * Fillet/Round operations for Manifold meshes.
+ *
+ * Implements the "dirty nasty (but working)" CSG approach from:
+ * https://github.com/elalish/manifold/discussions/1411
+ *
+ * Algorithm:
+ * 1. Create a tube (cylinder) tangent to the inner faces of the corner
+ * 2. Create a wedge (prism) that covers the corner tip but fits inside the tube's "back" side
+ * 3. Subtract tube from wedge → cutting tool (just the corner tip)
+ * 4. Subtract cutting tool from original → rounded edge
+ */
+import { getManifold } from './context';
+import { extractEdges, selectEdges } from './edgeSelection';
+/**
+ * Apply fillet/round to selected edges of a Manifold.
+ */
+export function fillet(mf, options) {
+    const manifold = getManifold();
+    const { radius, selection, segments = 16 } = options;
+    if (radius <= 0) {
+        throw new Error('Fillet radius must be positive');
+    }
+    // Extract all edges from mesh
+    const allEdges = extractEdges(mf);
+    if (allEdges.length === 0) {
+        console.warn('fillet: No edges found in mesh');
+        return mf;
+    }
+    // Select edges based on criteria
+    const selectedEdges = selectEdges(allEdges, selection);
+    if (selectedEdges.length === 0) {
+        console.warn('fillet: No edges matched selection criteria');
+        return mf;
+    }
+    console.log('fillet: Found', selectedEdges.length, 'edges to fillet');
+    let result = mf;
+    // Process convex edges
+    // We can union all tools for a single subtraction if they don't overlap
+    const cuttingTools = [];
+    for (const edge of selectedEdges) {
+        // Only handling convex edges (standard fillets)
+        // Filter out flat edges (dihedral angle approx 0) which are just triangulation artifacts
+        if (edge.dihedralAngle > 5 && edge.dihedralAngle < 175) {
+            const tool = createFilletCuttingTool(edge, radius, segments);
+            if (tool && tool.volume() > 1e-9) {
+                cuttingTools.push(tool);
+            }
+        }
+    }
+    // Subtract tools sequentially to avoid memory spikes from large unions
+    if (cuttingTools.length > 0) {
+        // Sort by volume or position might help stability, but just sequential is fine for now
+        console.log(`fillet: Subtracting ${cuttingTools.length} tools sequentially`);
+        for (const tool of cuttingTools) {
+            result = result.subtract(tool);
+        }
+    }
+    return result;
+}
+/**
+ * Create a fillet cutting tool using the wedge-minus-tube approach.
+ */
+function createFilletCuttingTool(edge, radius, segments) {
+    const manifold = getManifold();
+    // Edge endpoints
+    const [x0, y0, z0] = edge.p0;
+    const [x1, y1, z1] = edge.p1;
+    const ex = x1 - x0, ey = y1 - y0, ez = z1 - z0;
+    const edgeLen = Math.sqrt(ex * ex + ey * ey + ez * ez);
+    if (edgeLen < 1e-9)
+        return null;
+    const edgeDir = [ex / edgeLen, ey / edgeLen, ez / edgeLen];
+    const [n0x, n0y, n0z] = edge.n0;
+    const [n1x, n1y, n1z] = edge.n1;
+    // 1. TUBE: Positioned INWARD (tangent to faces)
+    // Center = Edge - radius*n0 - radius*n1 (for 90 degree edges)
+    // Note: For non-90 degree, this approximation works for small fillets but
+    // true bisector logic should be used. Using the sum offset for now as it handles 90 deg.
+    const ext = radius * 0.1;
+    const tubeStart = [
+        x0 - n0x * radius - n1x * radius - edgeDir[0] * ext,
+        y0 - n0y * radius - n1y * radius - edgeDir[1] * ext,
+        z0 - n0z * radius - n1z * radius - edgeDir[2] * ext
+    ];
+    const tubeEnd = [
+        x1 - n0x * radius - n1x * radius + edgeDir[0] * ext,
+        y1 - n0y * radius - n1y * radius + edgeDir[1] * ext,
+        z1 - n0z * radius - n1z * radius + edgeDir[2] * ext
+    ];
+    const sphere0 = manifold.Manifold.sphere(radius, segments).translate(tubeStart);
+    const sphere1 = manifold.Manifold.sphere(radius, segments).translate(tubeEnd);
+    const tube = manifold.Manifold.hull([sphere0, sphere1]);
+    // 2. WEDGE: Triangular prism extending INWARD
+    // CRITICAL: The wedge depth must be limited so it is completely contained
+    // within the tube on the "back" side. If deeper than the tube, subtracting
+    // the tube leaves "internal debris" which carves holes in the solid.
+    // For 90 degree corners, radius*1.0 is safe (reaches tube center).
+    const wedgeDepth = radius * 1.1;
+    const wedgePoints = [];
+    // At start
+    const sX = x0 - edgeDir[0] * ext, sY = y0 - edgeDir[1] * ext, sZ = z0 - edgeDir[2] * ext;
+    wedgePoints.push([sX, sY, sZ]); // Edge
+    wedgePoints.push([sX - n0x * wedgeDepth, sY - n0y * wedgeDepth, sZ - n0z * wedgeDepth]);
+    wedgePoints.push([sX - n1x * wedgeDepth, sY - n1y * wedgeDepth, sZ - n1z * wedgeDepth]);
+    // At end
+    const eX = x1 + edgeDir[0] * ext, eY = y1 + edgeDir[1] * ext, eZ = z1 + edgeDir[2] * ext;
+    wedgePoints.push([eX, eY, eZ]); // Edge
+    wedgePoints.push([eX - n0x * wedgeDepth, eY - n0y * wedgeDepth, eZ - n0z * wedgeDepth]);
+    wedgePoints.push([eX - n1x * wedgeDepth, eY - n1y * wedgeDepth, eZ - n1z * wedgeDepth]);
+    const wedge = manifold.Manifold.hull(wedgePoints);
+    // 3. CUTTING TOOL: Wedge - Tube
+    // Since wedge is small, wedge - tube leaves only the corner tip.
+    return wedge.subtract(tube);
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from './context';
+export * from './fillet';
+export * from './edgeSelection';
+export * from './pipeAlongPath';
+export * from './wedgeBuilder';
+export { default } from './example';

package/dist/index.js

@@ -0,0 +1,6 @@
+export * from './context';
+export * from './fillet';
+export * from './edgeSelection';
+export * from './pipeAlongPath';
+export * from './wedgeBuilder';
+export { default } from './example';

package/dist/pipeAlongPath.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Generates a tube (pipe) along a path using hull of spheres.
+ * This approach is reliable for curved paths and produces
+ * smooth results with proper manifold topology.
+ */
+import { Manifold } from 'manifold-3d';
+/**
+ * Creates a tube along a polyline path using convex hulls of spheres.
+ *
+ * @param path Array of 3D points defining the path
+ * @param radius Radius of the tube
+ * @param segments Optional circular segments for sphere quality
+ * @returns Manifold representing the tube
+ */
+export declare function pipeAlongPath(path: [number, number, number][], radius: number, segments?: number): Manifold;
+/**
+ * Creates a tube along an edge path that extends slightly beyond
+ * the endpoints to ensure proper boolean overlap.
+ *
+ * @param path Path points
+ * @param radius Tube radius
+ * @param extensionFactor How much to extend beyond endpoints (as fraction of radius)
+ * @param segments Circular segments
+ */
+export declare function pipeAlongPathExtended(path: [number, number, number][], radius: number, extensionFactor?: number, segments?: number): Manifold;

package/dist/pipeAlongPath.js

@@ -0,0 +1,82 @@
+/**
+ * Generates a tube (pipe) along a path using hull of spheres.
+ * This approach is reliable for curved paths and produces
+ * smooth results with proper manifold topology.
+ */
+import { getManifold } from './context';
+/**
+ * Creates a tube along a polyline path using convex hulls of spheres.
+ *
+ * @param path Array of 3D points defining the path
+ * @param radius Radius of the tube
+ * @param segments Optional circular segments for sphere quality
+ * @returns Manifold representing the tube
+ */
+export function pipeAlongPath(path, radius, segments) {
+    const manifold = getManifold();
+    if (path.length < 2) {
+        throw new Error('Path must have at least 2 points');
+    }
+    // Create spheres at each path point
+    const spheres = [];
+    for (const [x, y, z] of path) {
+        const sphere = manifold.Manifold.sphere(radius, segments)
+            .translate([x, y, z]);
+        spheres.push(sphere);
+    }
+    // Hull adjacent spheres to create tube segments, then union
+    const segments_ = [];
+    for (let i = 0; i < path.length - 1; i++) {
+        // Hull two adjacent spheres to form a tube segment
+        const segment = manifold.Manifold.hull([spheres[i], spheres[i + 1]]);
+        segments_.push(segment);
+    }
+    // Union all segments
+    if (segments_.length === 1) {
+        return segments_[0];
+    }
+    return manifold.Manifold.union(segments_);
+}
+/**
+ * Creates a tube along an edge path that extends slightly beyond
+ * the endpoints to ensure proper boolean overlap.
+ *
+ * @param path Path points
+ * @param radius Tube radius
+ * @param extensionFactor How much to extend beyond endpoints (as fraction of radius)
+ * @param segments Circular segments
+ */
+export function pipeAlongPathExtended(path, radius, extensionFactor = 0.1, segments) {
+    if (path.length < 2) {
+        throw new Error('Path must have at least 2 points');
+    }
+    // Compute extension vectors at start and end
+    const start = path[0];
+    const afterStart = path[1];
+    const startDir = normalize([
+        start[0] - afterStart[0],
+        start[1] - afterStart[1],
+        start[2] - afterStart[2]
+    ]);
+    const end = path[path.length - 1];
+    const beforeEnd = path[path.length - 2];
+    const endDir = normalize([
+        end[0] - beforeEnd[0],
+        end[1] - beforeEnd[1],
+        end[2] - beforeEnd[2]
+    ]);
+    const ext = radius * extensionFactor;
+    // Create extended path
+    const extendedPath = [
+        [start[0] + startDir[0] * ext, start[1] + startDir[1] * ext, start[2] + startDir[2] * ext],
+        ...path,
+        [end[0] + endDir[0] * ext, end[1] + endDir[1] * ext, end[2] + endDir[2] * ext]
+    ];
+    return pipeAlongPath(extendedPath, radius, segments);
+}
+function normalize(v) {
+    const len = Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
+    if (len < 1e-12)
+        return [1, 0, 0];
+    return [v[0] / len, v[1] / len, v[2] / len];
+}

package/dist/wedgeBuilder.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Builds a wedge solid along an edge for fillet operations.
+ *
+ * The wedge is formed by offsetting from the edge along the
+ * adjacent face normals. This creates a triangular prism that,
+ * when the tube is subtracted, leaves the fillet surface.
+ */
+import { Manifold } from 'manifold-3d';
+import { MeshEdge } from './edgeSelection';
+/**
+ * Creates a wedge solid along an edge.
+ *
+ * The wedge spans:
+ * - Along the edge direction (with small extension)
+ * - From the edge outward along both face normals
+ *
+ * @param edge The edge to build wedge for
+ * @param distance How far to offset along face normals
+ * @param inflate Extra inflation for boolean overlap (typically 2× precision)
+ * @returns Manifold representing the wedge
+ */
+export declare function buildWedge(edge: MeshEdge, distance: number, inflate?: number): Manifold;

package/dist/wedgeBuilder.js

@@ -0,0 +1,109 @@
+/**
+ * Builds a wedge solid along an edge for fillet operations.
+ *
+ * The wedge is formed by offsetting from the edge along the
+ * adjacent face normals. This creates a triangular prism that,
+ * when the tube is subtracted, leaves the fillet surface.
+ */
+import { getManifold } from './context';
+import { edgeDirection } from './edgeSelection';
+/**
+ * Creates a wedge solid along an edge.
+ *
+ * The wedge spans:
+ * - Along the edge direction (with small extension)
+ * - From the edge outward along both face normals
+ *
+ * @param edge The edge to build wedge for
+ * @param distance How far to offset along face normals
+ * @param inflate Extra inflation for boolean overlap (typically 2× precision)
+ * @returns Manifold representing the wedge
+ */
+export function buildWedge(edge, distance, inflate = 0.001) {
+    const manifold = getManifold();
+    // Edge vector and direction
+    const edgeVec = [
+        edge.p1[0] - edge.p0[0],
+        edge.p1[1] - edge.p0[1],
+        edge.p1[2] - edge.p0[2]
+    ];
+    const dir = edgeDirection(edge);
+    // Compute offset directions perpendicular to edge, along face normals
+    // We need vectors in the plane of each face, perpendicular to the edge
+    const offsetA = crossAndNormalize(edge.n0, dir);
+    const offsetB = crossAndNormalize(edge.n1, dir);
+    // Ensure offset directions point "outward" from the edge (same side as normals)
+    // This aligns them with how the fillet should remove material
+    const dotA = dot(offsetA, edge.n0);
+    const dotB = dot(offsetB, edge.n1);
+    if (dotA < 0) {
+        offsetA[0] = -offsetA[0];
+        offsetA[1] = -offsetA[1];
+        offsetA[2] = -offsetA[2];
+    }
+    if (dotB < 0) {
+        offsetB[0] = -offsetB[0];
+        offsetB[1] = -offsetB[1];
+        offsetB[2] = -offsetB[2];
+    }
+    // Create wedge vertices
+    // The wedge is a triangular prism along the edge
+    const d = distance + inflate;
+    const ext = inflate; // Small extension along edge
+    // Start cap vertices (at p0 - ext along edge)
+    const s0 = [
+        edge.p0[0] - dir[0] * ext,
+        edge.p0[1] - dir[1] * ext,
+        edge.p0[2] - dir[2] * ext
+    ];
+    const sA = [
+        s0[0] + offsetA[0] * d,
+        s0[1] + offsetA[1] * d,
+        s0[2] + offsetA[2] * d
+    ];
+    const sB = [
+        s0[0] + offsetB[0] * d,
+        s0[1] + offsetB[1] * d,
+        s0[2] + offsetB[2] * d
+    ];
+    // End cap vertices (at p1 + ext along edge)
+    const e0 = [
+        edge.p1[0] + dir[0] * ext,
+        edge.p1[1] + dir[1] * ext,
+        edge.p1[2] + dir[2] * ext
+    ];
+    const eA = [
+        e0[0] + offsetA[0] * d,
+        e0[1] + offsetA[1] * d,
+        e0[2] + offsetA[2] * d
+    ];
+    const eB = [
+        e0[0] + offsetB[0] * d,
+        e0[1] + offsetB[1] * d,
+        e0[2] + offsetB[2] * d
+    ];
+    // Build the wedge as a convex hull of these 6 points
+    // This guarantees a valid manifold
+    const points = [s0, sA, sB, e0, eA, eB];
+    return manifold.Manifold.hull(points);
+}
+/**
+ * Cross product of two vectors, normalized.
+ */
+function crossAndNormalize(a, b) {
+    const c = [
+        a[1] * b[2] - a[2] * b[1],
+        a[2] * b[0] - a[0] * b[2],
+        a[0] * b[1] - a[1] * b[0]
+    ];
+    const len = Math.sqrt(c[0] ** 2 + c[1] ** 2 + c[2] ** 2);
+    if (len < 1e-12)
+        return [0, 0, 1];
+    return [c[0] / len, c[1] / len, c[2] / len];
+}
+/**
+ * Dot product of two vectors.
+ */
+function dot(a, b) {
+    return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@cadit-app/fillet-script-with-unique-name",
+  "version": "1.0.0",
+  "description": "An implementation of a fillet algorithm for ManifoldCAD",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./*": {
+      "import": "./dist/*.js",
+      "types": "./dist/*.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "bash -c 'output=$(tsc --noCheck 2>&1); echo \"$output\"; echo \"$output\" | grep -v \"error TS2742\" | grep -q \"error TS\" && exit 1 || exit 0'",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "lint": "eslint src",
+    "build:3mf": "manifold-cad index.ts output.3mf",
+    "build:glb": "manifold-cad index.ts output.glb"
+  },
+  "author": "CadIt",
+  "license": "cc-by-sa",
+  "keywords": [
+    "manifold",
+    "fillet",
+    "cad"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/CADit-app/fillet-script-with-unique-name"
+  },
+  "homepage": "https://github.com/CADit-app/fillet-script-with-unique-name#readme",
+  "bugs": {
+    "url": "https://github.com/CADit-app/fillet-script-with-unique-name/issues"
+  },
+  "peerDependencies": {
+    "manifold-3d": "^2.1.0 || ^3.0.0"
+  },
+  "devDependencies": {
+    "manifold-3d": "^3.3.2",
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.3"
+  },
+  "module": "dist/index.mjs",
+  "publishConfig": {
+    "access": "public"
+  }
+}