@cadit-app/manifold-fillet 1.0.0 → 1.0.1

package/dist/example.js

@@ -1,13 +1,12 @@
 /**
- * Example usage of the fillet library in CADit environment.
+ * Example usage of the fillet library.
  *
- * In CADit, `manifold` is available as a global variable containing
- * the initialized Manifold WASM module.
+ * Works on both manifoldcad.org and CADit.
  */
 import { Manifold } from 'manifold-3d/manifoldCAD';
 import { createFillet } from './index';
-// Create fillet API bound to the manifold instance
-const { fillet } = createFillet(manifold);
+// Create fillet API bound to the Manifold class
+const { fillet } = createFillet(Manifold);
 const box = Manifold.cube([20, 20, 20], true);
 // Fillet the edge at position (10, 10, 0)
 const rounded = fillet(box, {

package/dist/fillet.d.ts

@@ -10,7 +10,8 @@
  * 3. Subtract tube from wedge → cutting tool (just the corner tip)
  * 4. Subtract cutting tool from original → rounded edge
  */
-import type { Manifold, ManifoldToplevel } from 'manifold-3d';
+import type { Manifold } from 'manifold-3d';
+import type { ManifoldStatic } from './index';
 import { EdgeSelection } from './edgeSelection';
 export interface FilletOptions {
     /** Fillet radius */
@@ -23,10 +24,10 @@ export interface FilletOptions {
 /**
  * Apply fillet/round to selected edges of a Manifold.
  *
- * @param manifold - The initialized Manifold WASM module
+ * @param Manifold - The Manifold class with static constructors
  * @param mf - The Manifold shape to fillet
  * @param options - Fillet options (radius, selection, segments)
  * @returns A new Manifold with filleted edges
  */
-export declare function filletWithManifold(manifold: ManifoldToplevel, mf: Manifold, options: FilletOptions): Manifold;
+export declare function filletWithManifold(Manifold: ManifoldStatic, mf: Manifold, options: FilletOptions): Manifold;
 export type { EdgeSelection, PointEdgeSelection, AngleEdgeSelection } from './edgeSelection';

package/dist/fillet.js

@@ -14,12 +14,12 @@ import { extractEdges, selectEdges } from './edgeSelection';
 /**
  * Apply fillet/round to selected edges of a Manifold.
  *
- * @param manifold - The initialized Manifold WASM module
+ * @param Manifold - The Manifold class with static constructors
  * @param mf - The Manifold shape to fillet
  * @param options - Fillet options (radius, selection, segments)
  * @returns A new Manifold with filleted edges
  */
-export function filletWithManifold(manifold, mf, options) {
+export function filletWithManifold(Manifold, mf, options) {
     const { radius, selection, segments = 16 } = options;
     if (radius <= 0) {
         throw new Error('Fillet radius must be positive');
@@ -45,7 +45,7 @@ export function filletWithManifold(manifold, mf, options) {
         // 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(manifold, edge, radius, segments);
+            const tool = createFilletCuttingTool(Manifold, edge, radius, segments);
             if (tool && tool.volume() > 1e-9) {
                 cuttingTools.push(tool);
             }
@@ -64,7 +64,7 @@ export function filletWithManifold(manifold, mf, options) {
 /**
  * Create a fillet cutting tool using the wedge-minus-tube approach.
  */
-function createFilletCuttingTool(manifold, edge, radius, segments) {
+function createFilletCuttingTool(Manifold, edge, radius, segments) {
     // Edge endpoints
     const [x0, y0, z0] = edge.p0;
     const [x1, y1, z1] = edge.p1;
@@ -90,9 +90,9 @@ function createFilletCuttingTool(manifold, edge, radius, segments) {
         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]);
+    const sphere0 = Manifold.sphere(radius, segments).translate(tubeStart);
+    const sphere1 = Manifold.sphere(radius, segments).translate(tubeEnd);
+    const tube = 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
@@ -110,7 +110,7 @@ function createFilletCuttingTool(manifold, edge, radius, segments) {
     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);
+    const wedge = 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

@@ -3,22 +3,38 @@
  *
  * Usage:
  * ```typescript
+ * // Option 1: With full Manifold module
  * import ManifoldModule from 'manifold-3d';
  * import { createFillet } from '@cadit-app/brute-force-fillet';
  *
- * const manifold = await ManifoldModule();
- * const { fillet } = createFillet(manifold);
+ * const wasm = await ManifoldModule();
+ * const { fillet } = createFillet(wasm.Manifold);
  *
- * const box = manifold.Manifold.cube([10, 10, 10], true);
- * const rounded = fillet(box, { radius: 1, selection: { type: 'angle', minAngle: 80 } });
+ * // Option 2: With Manifold class directly (e.g., manifoldcad.org)
+ * import { Manifold } from 'manifold-3d/manifoldCAD';
+ * import { createFillet } from '@cadit-app/brute-force-fillet';
+ *
+ * const { fillet } = createFillet(Manifold);
  * ```
  */
-import type { Manifold, ManifoldToplevel } from 'manifold-3d';
+import type { Manifold } from 'manifold-3d';
 import { FilletOptions } from './fillet';
 import { extractEdges, selectEdges, edgeDirection, edgeInwardDirection, sampleEdge, MeshEdge } from './edgeSelection';
-export type { ManifoldToplevel } from './context';
 export type { FilletOptions } from './fillet';
 export type { MeshEdge, EdgeSelection, PointEdgeSelection, AngleEdgeSelection } from './edgeSelection';
+/**
+ * The Manifold class type with static constructors.
+ * This is what you get from `manifold.Manifold` or `import { Manifold } from 'manifold-3d/manifoldCAD'`.
+ */
+export interface ManifoldStatic {
+    cube: (size: [number, number, number] | number, center?: boolean) => Manifold;
+    sphere: (radius: number, circularSegments?: number) => Manifold;
+    cylinder: (height: number, radiusLow: number, radiusHigh?: number, circularSegments?: number, center?: boolean) => Manifold;
+    hull: (manifolds: Manifold[] | [number, number, number][]) => Manifold;
+    union: (manifolds: Manifold[]) => Manifold;
+    intersection: (manifolds: Manifold[]) => Manifold;
+    difference: (manifolds: Manifold[]) => Manifold;
+}
 /**
  * The fillet API returned by createFillet.
  */
@@ -65,28 +81,30 @@ export interface FilletAPI {
     sampleEdge: typeof sampleEdge;
 }
 /**
- * Creates a fillet API bound to a specific Manifold instance.
+ * Creates a fillet API bound to a specific Manifold class.
  *
- * @param manifold - The initialized Manifold WASM module (from `await ManifoldModule()`)
- * @returns An object containing all fillet functions bound to the manifold instance
+ * @param Manifold - The Manifold class with static constructors (cube, sphere, hull, etc.)
+ * @returns An object containing all fillet functions bound to the Manifold class
  *
  * @example
  * ```typescript
- * import ManifoldModule from 'manifold-3d';
+ * // On manifoldcad.org:
+ * import { Manifold } from 'manifold-3d/manifoldCAD';
  * import { createFillet } from '@cadit-app/brute-force-fillet';
  *
- * const manifold = await ManifoldModule();
- * const { fillet } = createFillet(manifold);
+ * const { fillet } = createFillet(Manifold);
+ * const box = Manifold.cube([10, 10, 10], true);
+ * const rounded = fillet(box, { radius: 1, selection: { type: 'angle', minAngle: 80 } });
  *
- * const box = manifold.Manifold.cube([10, 10, 10], true);
- * const rounded = fillet(box, {
- *   radius: 1,
- *   selection: { type: 'angle', minAngle: 80 }
- * });
+ * // In Node.js:
+ * import ManifoldModule from 'manifold-3d';
+ * const wasm = await ManifoldModule();
+ * const { fillet } = createFillet(wasm.Manifold);
  * ```
  */
-export declare function createFillet(manifold: ManifoldToplevel): FilletAPI;
+export declare function createFillet(Manifold: ManifoldStatic): FilletAPI;
 export { extractEdges, selectEdges, edgeDirection, edgeInwardDirection, sampleEdge };
 export { filletWithManifold } from './fillet';
 export { pipeAlongPath, pipeAlongPathExtended } from './pipeAlongPath';
 export { buildWedge } from './wedgeBuilder';
+export { default } from './example';

package/dist/index.js

@@ -3,14 +3,18 @@
  *
  * Usage:
  * ```typescript
+ * // Option 1: With full Manifold module
  * import ManifoldModule from 'manifold-3d';
  * import { createFillet } from '@cadit-app/brute-force-fillet';
  *
- * const manifold = await ManifoldModule();
- * const { fillet } = createFillet(manifold);
+ * const wasm = await ManifoldModule();
+ * const { fillet } = createFillet(wasm.Manifold);
  *
- * const box = manifold.Manifold.cube([10, 10, 10], true);
- * const rounded = fillet(box, { radius: 1, selection: { type: 'angle', minAngle: 80 } });
+ * // Option 2: With Manifold class directly (e.g., manifoldcad.org)
+ * import { Manifold } from 'manifold-3d/manifoldCAD';
+ * import { createFillet } from '@cadit-app/brute-force-fillet';
+ *
+ * const { fillet } = createFillet(Manifold);
  * ```
  */
 import { filletWithManifold } from './fillet';
@@ -18,32 +22,33 @@ import { pipeAlongPath, pipeAlongPathExtended } from './pipeAlongPath';
 import { buildWedge } from './wedgeBuilder';
 import { extractEdges, selectEdges, edgeDirection, edgeInwardDirection, sampleEdge } from './edgeSelection';
 /**
- * Creates a fillet API bound to a specific Manifold instance.
+ * Creates a fillet API bound to a specific Manifold class.
  *
- * @param manifold - The initialized Manifold WASM module (from `await ManifoldModule()`)
- * @returns An object containing all fillet functions bound to the manifold instance
+ * @param Manifold - The Manifold class with static constructors (cube, sphere, hull, etc.)
+ * @returns An object containing all fillet functions bound to the Manifold class
  *
  * @example
  * ```typescript
- * import ManifoldModule from 'manifold-3d';
+ * // On manifoldcad.org:
+ * import { Manifold } from 'manifold-3d/manifoldCAD';
  * import { createFillet } from '@cadit-app/brute-force-fillet';
  *
- * const manifold = await ManifoldModule();
- * const { fillet } = createFillet(manifold);
+ * const { fillet } = createFillet(Manifold);
+ * const box = Manifold.cube([10, 10, 10], true);
+ * const rounded = fillet(box, { radius: 1, selection: { type: 'angle', minAngle: 80 } });
  *
- * const box = manifold.Manifold.cube([10, 10, 10], true);
- * const rounded = fillet(box, {
- *   radius: 1,
- *   selection: { type: 'angle', minAngle: 80 }
- * });
+ * // In Node.js:
+ * import ManifoldModule from 'manifold-3d';
+ * const wasm = await ManifoldModule();
+ * const { fillet } = createFillet(wasm.Manifold);
  * ```
  */
-export function createFillet(manifold) {
+export function createFillet(Manifold) {
     return {
-        fillet: (mf, options) => filletWithManifold(manifold, mf, options),
-        pipeAlongPath: (path, radius, segments) => pipeAlongPath(manifold, path, radius, segments),
-        pipeAlongPathExtended: (path, radius, extensionFactor, segments) => pipeAlongPathExtended(manifold, path, radius, extensionFactor, segments),
-        buildWedge: (edge, distance, inflate) => buildWedge(manifold, edge, distance, inflate),
+        fillet: (mf, options) => filletWithManifold(Manifold, mf, options),
+        pipeAlongPath: (path, radius, segments) => pipeAlongPath(Manifold, path, radius, segments),
+        pipeAlongPathExtended: (path, radius, extensionFactor, segments) => pipeAlongPathExtended(Manifold, path, radius, extensionFactor, segments),
+        buildWedge: (edge, distance, inflate) => buildWedge(Manifold, edge, distance, inflate),
         // These don't need manifold instance
         extractEdges,
         selectEdges,
@@ -58,3 +63,4 @@ export { extractEdges, selectEdges, edgeDirection, edgeInwardDirection, sampleEd
 export { filletWithManifold } from './fillet';
 export { pipeAlongPath, pipeAlongPathExtended } from './pipeAlongPath';
 export { buildWedge } from './wedgeBuilder';
+export { default } from './example';

package/dist/pipeAlongPath.d.ts

@@ -3,25 +3,26 @@
  * This approach is reliable for curved paths and produces
  * smooth results with proper manifold topology.
  */
-import type { Manifold, ManifoldToplevel } from 'manifold-3d';
+import type { Manifold } from 'manifold-3d';
+import type { ManifoldStatic } from './index';
 /**
  * Creates a tube along a polyline path using convex hulls of spheres.
  *
- * @param manifold - The initialized Manifold WASM module
+ * @param Manifold - The Manifold class with static constructors
  * @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(manifold: ManifoldToplevel, path: [number, number, number][], radius: number, segments?: number): Manifold;
+export declare function pipeAlongPath(Manifold: ManifoldStatic, 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 manifold - The initialized Manifold WASM module
+ * @param Manifold - The Manifold class with static constructors
  * @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(manifold: ManifoldToplevel, path: [number, number, number][], radius: number, extensionFactor?: number, segments?: number): Manifold;
+export declare function pipeAlongPathExtended(Manifold: ManifoldStatic, path: [number, number, number][], radius: number, extensionFactor?: number, segments?: number): Manifold;

package/dist/pipeAlongPath.js

@@ -6,20 +6,20 @@
 /**
  * Creates a tube along a polyline path using convex hulls of spheres.
  *
- * @param manifold - The initialized Manifold WASM module
+ * @param Manifold - The Manifold class with static constructors
  * @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(manifold, path, radius, segments) {
+export function pipeAlongPath(Manifold, path, radius, segments) {
     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)
+        const sphere = Manifold.sphere(radius, segments)
             .translate([x, y, z]);
         spheres.push(sphere);
     }
@@ -27,26 +27,26 @@ export function pipeAlongPath(manifold, path, radius, segments) {
     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]]);
+        const segment = 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_);
+    return Manifold.union(segments_);
 }
 /**
  * Creates a tube along an edge path that extends slightly beyond
  * the endpoints to ensure proper boolean overlap.
  *
- * @param manifold - The initialized Manifold WASM module
+ * @param Manifold - The Manifold class with static constructors
  * @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(manifold, path, radius, extensionFactor = 0.1, segments) {
+export function pipeAlongPathExtended(Manifold, path, radius, extensionFactor = 0.1, segments) {
     if (path.length < 2) {
         throw new Error('Path must have at least 2 points');
     }
@@ -72,7 +72,7 @@ export function pipeAlongPathExtended(manifold, path, radius, extensionFactor =
         ...path,
         [end[0] + endDir[0] * ext, end[1] + endDir[1] * ext, end[2] + endDir[2] * ext]
     ];
-    return pipeAlongPath(manifold, extendedPath, radius, segments);
+    return pipeAlongPath(Manifold, extendedPath, radius, segments);
 }
 function normalize(v) {
     const len = Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);

package/dist/wedgeBuilder.d.ts

@@ -5,7 +5,8 @@
  * adjacent face normals. This creates a triangular prism that,
  * when the tube is subtracted, leaves the fillet surface.
  */
-import type { Manifold, ManifoldToplevel } from 'manifold-3d';
+import type { Manifold } from 'manifold-3d';
+import type { ManifoldStatic } from './index';
 import { MeshEdge } from './edgeSelection';
 /**
  * Creates a wedge solid along an edge.
@@ -14,10 +15,10 @@ import { MeshEdge } from './edgeSelection';
  * - Along the edge direction (with small extension)
  * - From the edge outward along both face normals
  *
- * @param manifold - The initialized Manifold WASM module
+ * @param Manifold - The Manifold class with static constructors
  * @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(manifold: ManifoldToplevel, edge: MeshEdge, distance: number, inflate?: number): Manifold;
+export declare function buildWedge(Manifold: ManifoldStatic, edge: MeshEdge, distance: number, inflate?: number): Manifold;

package/dist/wedgeBuilder.js

@@ -13,13 +13,13 @@ import { edgeDirection } from './edgeSelection';
  * - Along the edge direction (with small extension)
  * - From the edge outward along both face normals
  *
- * @param manifold - The initialized Manifold WASM module
+ * @param Manifold - The Manifold class with static constructors
  * @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(manifold, edge, distance, inflate = 0.001) {
+export function buildWedge(Manifold, edge, distance, inflate = 0.001) {
     // Edge vector and direction
     const edgeVec = [
         edge.p1[0] - edge.p0[0],
@@ -84,7 +84,7 @@ export function buildWedge(manifold, edge, distance, inflate = 0.001) {
     // 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);
+    return Manifold.hull(points);
 }
 /**
  * Cross product of two vectors, normalized.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cadit-app/manifold-fillet",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Fillet and round operations for Manifold meshes",
   "type": "module",
   "main": "dist/index.js",