brep-io-kernel 1.0.0 → 1.0.11

package/dist-kernel/help/search-index.json

@@ -1,464 +0,0 @@
-[
-  {
-    "title": "Angle Constraint",
-    "href": "assembly-constraints__angle-constraint.html",
-    "summary": "Angle Constraint Status: Implemented Angle constraints rotate components until the measured angle between two references matches a specified target. They work on face normals or edge directions and are ideal for setting hinge offsets or mai...",
-    "content": "Angle Constraint Status: Implemented Angle constraints rotate components until the measured angle between two references matches a specified target. They work on face normals or edge directions and are ideal for setting hinge offsets or maintaining draft angles during assembly. Inputs id – solver-assigned identifier (for example ANGL3 ). elements – two selections. Faces use their resolved normals; edges use the edge direction extracted from geometry. angle – desired signed angle in degrees. The implementation normalises the value to the [-360, 360] range before solving. Behaviour Resolves each selection to a component, origin, and direction vector. Faces defer to resolveParallelSelection() , while edges derive a direction from geometry or PMI utilities. Rejects selections that cannot provide a direction, that belong to the same component, or that are not both attached to assembly components. Measures the current signed angle, keeps both radian and degree readings in persistentData , and compares the angular error against either the supplied context.angleTolerance or a tolerance derived from the solver's positional tolerance. Decides how to distribute the correction: if both components can move it splits the delta angle evenly; otherwise the entire adjustment is applied to the movable component. Uses computeRotationTowards() plus the solver rotationGain to cap the per-iteration rotation step (bounded by MAX_ROTATION_PER_ITERATION from the parallel alignment utilities). Records every applied quaternion in lastAppliedRotations for downstream diagnostics. Usage Tips Pair Angle with Coincident or Distance when you need to control both the pivot point and the orientation. Use a smaller rotationGain for stiff systems or when starting far from the target angle; it helps prevent oscillation. If the constraint refuses to solve, confirm both selections resolve to different components and that each exposes a valid direction vector."
-  },
-  {
-    "title": "Coincident Constraint",
-    "href": "assembly-constraints__coincident-constraint.html",
-    "summary": "Coincident Constraint Status: Implemented The coincident constraint brings two references to the same world-space location by translating their owning components. It is the general-purpose mate used for points, edges, faces, or whole compon...",
-    "content": "Coincident Constraint Status: Implemented The coincident constraint brings two references to the same world-space location by translating their owning components. It is the general-purpose mate used for points, edges, faces, or whole components. Inputs id – unique identifier generated by the history; used for UI labels and debugging. elements – exactly two selections (vertex, edge, face, or component). The solver resolves each selection to a world-space point before measuring the gap. applyImmediately – legacy flag populated by the UI; the iterative solver ignores it. faceNormalOpposed – reserved for future expansion and currently unused. Behaviour Rebuilds the world-space representative point for each selection using objectRepresentativePoint() (with a fallback to BaseAssemblyConstraint.getWorldPoint() ). Rejects selections that belong to the same component or that cannot be resolved to assembly components, surfacing status: 'invalid-selection' . Measures the vector between the two points, compares its length to the solver tolerance, and records the current error in persistentData . Splits the correction vector between both components when neither one is fixed; otherwise moves only the movable component. If both components are fixed the constraint reports status: 'blocked' . Applies translations through context.applyTranslation() so the solver can sync back to feature data and accumulate lastAppliedMoves . Usage Tips Pair a Coincident constraint with a Parallel or Angle constraint when you need both contact and orientation control. Lower the solver translationGain when working with very small tolerances to avoid overshooting on dense assemblies. Use the solver's debug hooks to watch lastAppliedMoves if a component fails to move; it usually indicates the part is already fixed or belongs to the same component as the other selection."
-  },
-  {
-    "title": "Distance Constraint",
-    "href": "assembly-constraints__distance-constraint.html",
-    "summary": "Distance Constraint Status: Implemented Distance constraints maintain a target separation between two references. They support point/point, point/edge, point/face, edge/edge, and face/face combinations and will translate components until th...",
-    "content": "Distance Constraint Status: Implemented Distance constraints maintain a target separation between two references. They support point/point, point/edge, point/face, edge/edge, and face/face combinations and will translate components until the measured offset matches the requested distance. Inputs id – unique label used across the solver UI and logs. elements – two references (faces, edges, or vertices). Component references are treated as points at their representative location. distance – desired separation in scene units. Negative input is clamped to zero. opposeNormals – for face-to-face alignment, flips the normal on the second selection before the parallel alignment stage. Behaviour If both selections are faces, the solver first delegates to solveParallelAlignment() to make the faces parallel. It pauses the distance stage while orientation adjustments are pending. Measures the current separation with specialised routines for different selection pairings (for example perpendicular distance for edges or signed offset along the face normal). Records the absolute error in persistentData.error and honours the solver tolerance to decide when the constraint is satisfied. When movement is required, splits the correction between components unless one of them reports isComponentFixed(component) === true . Applies all translations through context.applyTranslation() and keeps a log of moves in lastAppliedMoves (useful for UI tooltips or debugging). In debug mode the constraint emits temporary arrow helpers that show the resolved surface normals being used during the orientation stage. Usage Tips Combine Distance with Parallel when you need to hold two planar faces at a controlled offset. Toggle opposeNormals if the alignment stage happens with both faces pointing the same way when you expected an opposed configuration. Large jumps are easier to converge when you reduce the solver translationGain ; increase it back toward 1.0 for the final tightening iterations."
-  },
-  {
-    "title": "Fixed Constraint",
-    "href": "assembly-constraints__fixed-constraint.html",
-    "summary": "Fixed Constraint Status: Implemented Fixed constraints lock an assembly component in place so other constraints treat it as immovable. They usually provide the reference frame that every other constraint solves against. Inputs id – solver-a...",
-    "content": "Fixed Constraint Status: Implemented Fixed constraints lock an assembly component in place so other constraints treat it as immovable. They usually provide the reference frame that every other constraint solves against. Inputs id – solver-assigned identifier that appears in the constraint list. component – single component selection. No other entity types are accepted. Behaviour Resolves the selection to an assembly component and verifies that it exposes the isAssemblyComponent marker used throughout the solver. Marks the component and its owning feature as fixed ( component.fixed = true and feature.inputParams.isFixed = true ) so downstream calls to isComponentFixed() short-circuit. Stores a friendly component name in persistentData.componentName for UI presentation. Reports whether the component was already fixed so the UI can skip redundant status updates. Usage Tips Always fix at least one component in an assembly; otherwise every constraint will read as blocked because both sides appear movable. Use Fixed constraints for temporary jig components: remove the constraint after the rest of the assembly is solved to free the part again. When importing legacy data, run the solver once—Fixed constraints will refresh feature metadata that older saves might not have populated."
-  },
-  {
-    "title": "Parallel Constraint",
-    "href": "assembly-constraints__parallel-constraint.html",
-    "summary": "Parallel Constraint Status: Implemented Parallel constraints align the directions of two faces, edges, or components. They are the primary orientation tool for planar or cylindrical features that must stay parallel without requiring contact...",
-    "content": "Parallel Constraint Status: Implemented Parallel constraints align the directions of two faces, edges, or components. They are the primary orientation tool for planar or cylindrical features that must stay parallel without requiring contact. Inputs id – unique identifier surfaced in the UI. elements – two selections (faces, edges, or components). Each selection must resolve to a direction vector. applyImmediately – historical flag retained for UI compatibility; the solver always iterates instead of applying a single shot correction. reverse – toggles the stored orientation preference so the constraint can align outward-facing normals instead of inward-facing normals. Behaviour Resolves both selections using the parallel alignment utilities, which gather a world-space origin, direction, and normal sampling metadata. Stores an orientation preference ( persistentData.preferredOppose ) the first time the constraint runs. Subsequent solves reuse that preference until reverse flips it. Delegates the heavy lifting to solveParallelAlignment() in constraintUtils/parallelAlignment.js , which computes the quaternion(s) necessary to make the direction vectors parallel while respecting MAX_ROTATION_PER_ITERATION . Fills persistentData.error and persistentData.errorDeg with the angular difference so the UI can display progress down to very small tolerances. Emits optional debug arrows when the solver runs in debugMode to visualise the directions currently being enforced. Usage Tips Combine Parallel with Distance or Coincident when you need both orientation and translation control. If the constraint keeps flipping between inward and outward normals, toggle the reverse flag to pin the preferred orientation. Keep an eye on lastAppliedRotations ; sustained non-zero rotations usually indicate other constraints are pulling the components out of alignment between iterations."
-  },
-  {
-    "title": "Assembly Constraint Solver",
-    "href": "assembly-constraints__solver.html",
-    "summary": "Assembly Constraint Solver Status: Implemented The assembly constraint solver manages constraint instances attached to an assembly and iteratively applies translations or rotations until every constraint reports that it is satisfied (or unt...",
-    "content": "Assembly Constraint Solver Status: Implemented The assembly constraint solver manages constraint instances attached to an assembly and iteratively applies translations or rotations until every constraint reports that it is satisfied (or until the iteration budget is exhausted). It lives alongside the constraint implementations in src/assemblyConstraints and mirrors the documentation pattern already used for PMI annotations. Key Files src/assemblyConstraints/AssemblyConstraintHistory.js – orchestrates constraint storage, scheduling, and the iterative solve loop. src/assemblyConstraints/AssemblyConstraintRegistry.js – registers built-in constraint classes and resolves aliases. src/assemblyConstraints/BaseAssemblyConstraint.js – base class that exposes shared helpers and metadata conventions for concrete constraints. Runtime Flow Every constraint entry carries a type , inputParams , and persistentData . Defaults come from the constraint's inputParamsSchema , and each entry receives an auto-generated id (for example COIN12 ). AssemblyConstraintHistory.runAll() is the primary entry point. It validates entries, removes disabled constraints, detects duplicates before instantiating anything, and then constructs one runtime instance per constraint. During each iteration the solver calls solve(context) (or run(context) for legacy classes) on every instance. A constraint may mark itself satisfied, request additional adjustments, or block if both components are fixed. When a constraint applies a motion it must call context.applyTranslation(component, vector) or context.applyRotation(component, quaternion) , both of which update the component transform and record that the component needs to be synced back to feature data. The loop stops early if an iteration makes no changes, if all constraints are satisfied, or if an abort signal supplied through the controller is triggered. After the run completes, persistent data (status, message, last applied moves, etc.) is merged back into the stored constraint entries so the UI reflects the latest state. Solver Context Each constraint receives the same runtime context object. The most frequently used fields are: tolerance , translationGain , and rotationGain – clamped values supplied through solver options to moderate how aggressively each constraint moves parts. resolveObject(selection) and resolveComponent(selection) – turn serialized selection info back into scene objects or assembly components. applyTranslation(component, THREE.Vector3) and applyRotation(component, THREE.Quaternion) – helpers that mutate component transforms and keep the solver's bookkeeping in sync. isComponentFixed(component) – reports whether a component is already locked by a Fixed constraint or by feature metadata. renderScene() and viewer – allow constraints or debug hooks to request a redraw between iterations. debugMode – when true, constraint implementations may emit temporary helpers (for example normal arrows). Hooks, Scheduling, and Debugging runAll() accepts an optional controller with an abort signal and hooks object. The solver will attempt to invoke onStart , onIterationStart , onConstraintStart , onConstraintEnd , onConstraintSkipped , onIterationComplete , and onComplete at appropriate times. Adding, removing, or editing constraints schedules an automatic background solve via AssemblyConstraintHistory.#scheduleAutoRun() . The auto-run uses the default tolerance, gain, and iteration count unless the caller overrides them. Duplicate detection ( checkConstraintErrors() and #detectDuplicateConstraints() ) ensures identical selections are not solved twice; duplicates inherit a status: 'duplicate' result and are skipped during the run. Constraint implementations may stash arbitrary data (for example lastAppliedMoves ) inside persistentData ; the solver copies those fields back onto the stored entry after each run so the UI can display progress. Constraint Catalog Built-in constraints are registered in the registry and documented individually: Angle Constraint Coincident Constraint Distance Constraint Fixed Constraint Parallel Constraint Touch Align Constraint Adding Components for Constraints Assembly constraints operate on AssemblyComponent instances, not ad-hoc solids. Add every part to the assembly using the Assembly Component feature first; this inserts the 3MF-backed component into the assembly graph, preserves face/body naming for selections, and exposes the transform that constraints manipulate. Solids added by other modeling features won’t participate in the constraint solver until they’re brought in as assembly components."
-  },
-  {
-    "title": "Touch Align Constraint",
-    "href": "assembly-constraints__touch-align-constraint.html",
-    "summary": "Touch Align Constraint Status: Experimental Touch Align constraints drive two like-kind references into contact while also aligning their orientations. They extend the parallel alignment logic with a translation phase so the selected entiti...",
-    "content": "Touch Align Constraint Status: Experimental Touch Align constraints drive two like-kind references into contact while also aligning their orientations. They extend the parallel alignment logic with a translation phase so the selected entities share the same location in space. Inputs id – solver-generated identifier (for example TALN5 ). elements – two selections of the same kind (face/face, edge/edge, or point/point). Mixed types are rejected. reverse – flips the stored orientation preference, mirroring the behaviour of the Parallel constraint. Behaviour Face to face : runs solveParallelAlignment() to align the surface normals, then translates components along the normal direction until the sampled origins coincide within tolerance. Edge to edge : orients the edges into parallel directions, measures the shortest vector between their supporting lines, and translates components to eliminate the separation. Point to point : alternates between small rotations (about a resolved component midpoint) and translations, using rotationGain and translationGain to gracefully converge even when the points start far apart. Records applied moves and rotations in persistentData.lastAppliedMoves / lastAppliedRotations , along with the most recent error value so the UI can communicate progress. Relies on isComponentFixed() to determine how to split corrections; if both components are fixed the constraint reports status: 'blocked' . Limitations Mixed-type selections (for example face-to-edge) are currently unsupported and will return status: 'unsupported-selection' . Point-to-point mode derives rotation pivots from component bounds; unusually shaped components may require several iterations before the points line up. Debug helpers (normal arrows) are only emitted for face and edge modes when the solver runs with debugMode enabled. Usage Tips Use Touch Align instead of pairing Coincident with Parallel when you want a single constraint to enforce both contact and orientation. If a face-to-face alignment lands on the wrong side, toggle reverse to swap which normals oppose each other before the translation phase starts. Keep an eye on persistentData.pointToPointNextMode when debugging point contacts; it reveals whether the next iteration plans a rotation or translation step."
-  },
-  {
-    "title": "BREP.js Export Map and Usage",
-    "href": "brep-api.html",
-    "summary": "BREP.js Export Map and Usage src/BREP/BREP.js aggregates the modeling API under a single BREP namespace. Import it once and destructure what you need: js import { BREP } from '../src/BREP/BREP.js'; const { Solid, Cube, Sweep, filletSolid, a...",
-    "content": "BREP.js Export Map and Usage src/BREP/BREP.js aggregates the modeling API under a single BREP namespace. Import it once and destructure what you need: js import { BREP } from '../src/BREP/BREP.js'; const { Solid, Cube, Sweep, filletSolid, applyBooleanOperation } = BREP; Core classes THREE — Re-export of the project's bundled three.js. Solid — Authoring + CSG wrapper (see docs/solid-methods.md for full API). Face , Edge , Vertex — Visualization/selection helpers attached during visualize() . Primitive solids Cube , Pyramid , Sphere , Cylinder , Cone , Torus — Parameterized primitives that extend Solid . Tube — Alias of TubeSolid for swept tubes along a polyline. Feature solids Sweep — Sweep a face along a path/axis; one side wall per input edge. Revolve — Revolve a face around an axis for a closed or partial solid. ExtrudeSolid — Translate a face with optional back distance; names caps and side walls. ChamferSolid — Builds bevel geometry along an edge for inset/outset chamfers. Fillet helpers filletSolid(options) — Builds wedge/tube/final fillet solids for an edge; supports inflate , resolution , and showTangentOverlays for debugging. computeFilletCenterline(edgeObj, radius, sideMode) — Returns centerline/tangent/edge polylines plus a closedLoop flag. attachFilletCenterlineAuxEdge(solid, edgeObj, radius, sideMode, name, options) — Adds the centerline as an aux edge on a solid. Boolean and conversion utilities applyBooleanOperation({ op, targets, tools, simplify }) — High-level boolean runner for feature code. MeshToBrep — Wrap an imported mesh as a Solid with face labels. MeshRepairer — Tools to detect and fix mesh issues before conversion/CSG. Assembly helper AssemblyComponent — Groups one or more solids for the assembly constraint system. Quick example js import { BREP } from '../src/BREP/BREP.js'; const box = new BREP.Cube({ x: 10, y: 10, z: 10, name: 'Box' }); const cyl = new BREP.Cylinder({ radius: 3, height: 10, name: 'Hole' }); // Center the cylinder through the box cyl.position.set(5, 5, 0); cyl.bakeTransform(cyl.matrixWorld); // Subtract to make a through-hole const result = box.subtract(cyl); result.name = 'BoxWithHole'; result.visualize();"
-  },
-  {
-    "title": "BREP Kernel Reference",
-    "href": "brep-kernel.html",
-    "summary": "BREP Kernel Reference This page catalogs the core classes and helpers that make up the BREP kernel (everything under src/BREP ). Use it alongside docs/solid-methods.md for Solid details and docs/brep-api.md for the export map. Core types So...",
-    "content": "BREP Kernel Reference This page catalogs the core classes and helpers that make up the BREP kernel (everything under src/BREP ). Use it alongside docs/solid-methods.md for Solid details and docs/brep-api.md for the export map. Core types Solid / Face / Edge / Vertex – Geometry + selection primitives ( Solid API in docs/solid-methods.md ). AssemblyComponent – Groups one or more solids for the assembly constraint solver. Options: { name='Component', fixed=false } . Primitives ( src/BREP/primitives.js ) All extend Solid and immediately generate geometry. Cube({ x=1, y=1, z=1, name }) Pyramid({ bL=1, s=4, h=1, name }) ( s is side count ≥ 3) Sphere({ r=1, resolution=24, name }) Cylinder({ radius=1, height=1, resolution=32, name }) Cone({ r1=0.5, r2=1, h=1, resolution=32, name }) Torus({ mR=2, tR=0.5, resolution=48, arcDegrees=360, name }) Feature solids - ExtrudeSolid – { face, distance=1 | dir:Vector3, distanceBack=0, name='Extrude' } . Sweep – { face, sweepPathEdges=[], distance=1, distanceBack=0, mode='translate', name='Sweep', omitBaseCap=false } . Revolve – { face, axis, angle=360, resolution=64, name='Revolve' } . TubeSolid (Tube) – { points=[], radius=1, innerRadius=0, resolution=32, closed=false, name='Tube' } . - ChamferSolid – { edgeToChamfer, distance=1, sampleCount=50, snapSeamToEdge=true, sideStripSubdiv=8, seamInsetScale=1e-3, direction='INSET'|'OUTSET', inflate=0, flipSide=false, debug=false, debugStride=12 } . OffsetShellSolid.generate(sourceSolid, distance, { newSolidName, featureId='OffsetShell' }) – Static helper to build offset shells. Fillet utilities ( src/BREP/fillets/fillet.js ) - filletSolid({ edgeToFillet, radius, sideMode='INSET'|'OUTSET', inflate=0.1, resolution=32, showTangentOverlays=false, debug=false, name='fillet' }) – Builds wedge/tube helpers and returns { finalSolid, tube, wedge } ; overlays add tangency polylines to the tube for debugging/PMI tagging. computeFilletCenterline(edgeObj, radius, sideMode) – Returns centerline/tangents/edge polylines plus a closedLoop flag. attachFilletCenterlineAuxEdge(solid, edgeObj, radius, sideMode='INSET', name='FILLET_CENTERLINE', options) – Adds centerline as an aux edge; options mirrors Solid.addAuxEdge . Boolean helper - applyBooleanOperation(partHistory, baseSolid, booleanParam, featureID) – Runs UNION|INTERSECT|SUBTRACT between baseSolid and booleanParam.targets (objects or names). Returns { added, removed } . Subtract semantics invert: each target subtracts the new base. Conversion and repair MeshToBrep – new MeshToBrep(geometryOrMesh, faceDeflectionAngle=30, weldTolerance=1e-5) groups triangles into faces based on normal deflection and welds shared vertices. MeshRepairer – Per-geometry repair pipeline: - weldVertices(geometry, epsilon=1e-4) - fixTJunctions(geometry, lineEps=5e-4, gridCell=0.01) - removeOverlappingTriangles(geometry, posEps=1e-6) - fillHoles(geometry) - fixTriangleNormals(geometry) - repairAll(geometry, { weldEps=5e-4, lineEps=5e-4, gridCell=0.01 }) Point cloud wrapper – buildTightPointCloudWrap(rawPoints, { padding=0.02*diag, alphaRadius=0.6*medianKNN }) builds a solid via marching cubes over a density field. Misc helpers MeshToBrep , MeshRepairer , applyBooleanOperation , PointCloudWrap live in src/BREP and are re-exported via BREP.js ( docs/brep-api.md ). SolidMethod docs – docs/solid-methods.md covers all core operations (authoring, cleanup, booleans, export). Example: boolean with primitives js import { BREP } from '../src/BREP/BREP.js'; const box = new BREP.Cube({ x: 20, y: 10, z: 10, name: 'Box' }); const hole = new BREP.Cylinder({ radius: 3, height: 10, name: 'Hole' }); hole.position.set(10, 5, 0); hole.bakeTransform(hole.matrixWorld); const result = box.subtract(hole); result.name = 'BoxWithHole'; result.visualize();"
-  },
-  {
-    "title": "BREP Model and Classes",
-    "href": "brep-model.html",
-    "summary": "BREP Model and Classes Overview BREP combines a triangle mesh with per-triangle face labels. Labels map to globally unique IDs in Manifold so selections survive boolean operations. During manifoldization, triangle windings are made consiste...",
-    "content": "BREP Model and Classes Overview BREP combines a triangle mesh with per-triangle face labels. Labels map to globally unique IDs in Manifold so selections survive boolean operations. During manifoldization, triangle windings are made consistent, outward orientation is enforced, and an optional weld epsilon deduplicates vertices. Visualization builds one mesh per face label and edge polylines for label boundaries, enabling semantic selection in the UI and PMI tooling. Solid Solid is a THREE.Group subclass that handles authoring, CSG, queries, and export. Geometry storage uses _vertProperties (flat positions), _triVerts (triangle indices), and _triIDs (face IDs) plus name-to-ID maps. Key methods include addTriangle , setEpsilon , mirrorAcrossPlane , invertNormals , fixTriangleWindingsByAdjacency , removeTinyBoundaryTriangles , getMesh , getFace , getFaces , getFaceNames , getBoundaryEdgePolylines , visualize , union , subtract , intersect , difference , simplify , setTolerance , volume , surfaceArea , toSTL , and writeSTL . Full per-method descriptions and examples live in docs/solid-methods.md . Face Face is a THREE.Mesh representing all triangles that share a label. Provides getAverageNormal() and surfaceArea() helpers for inspection and downstream logic. Edge Edge instances represent boundary polylines between two face labels and expose metadata describing the adjacent faces. Use edges for PMI dimension snapping, measurement, and preview visualization. Additional implementation details can be explored in src/BREP/BetterSolid.js and related helpers."
-  },
-  {
-    "title": "CONTRIBUTING",
-    "href": "CONTRIBUTING.html",
-    "summary": "Pull requests welcome. Please don't reformat files without a good reason (tabs vs. spaces), as this just adds noise during review. Be sure you comply with the license. Please discuss new dependencies before adding them. We're trying to keep...",
-    "content": "Pull requests welcome. Please don't reformat files without a good reason (tabs vs. spaces), as this just adds noise during review. Be sure you comply with the license. Please discuss new dependencies before adding them. We're trying to keep dependencies to a minimum in this project. The BREP kernel itself is intended to be extracted into a separate npm package, so try not to mix UI and BREP code directly. Tests need to run in both the Node.js environment and on the client side in the browser."
-  },
-  {
-    "title": "Cylindrical Face Radius Embedding",
-    "href": "cylindrical-face-radius-embedding.html",
-    "summary": "Cylindrical Face Radius Embedding This feature adds automatic radius information embedding for cylindrical faces in BREP solids, making the radius values available for downstream operations like dimensioning. How It Works 1. Automatic Radiu...",
-    "content": "Cylindrical Face Radius Embedding This feature adds automatic radius information embedding for cylindrical faces in BREP solids, making the radius values available for downstream operations like dimensioning. How It Works 1. Automatic Radius Embedding When cylindrical faces are created, the system automatically stores radius metadata: javascript // For primitive cylinders const cylinder = new BREP.Cylinder({ radius: 5.0, height: 10.0, name: 'MyCylinder' }); // The side face 'MyCylinder_S' will automatically have metadata: // { // type: 'cylindrical', // radius: 5.0, // height: 10.0, // axis: [0, 1, 0], // center: [0, 5.0, 0] // } 2. Extrude Operations When extruding circular sketches, cylindrical faces are automatically detected and radius metadata is embedded: javascript // If you extrude a circular face with radius 3.0 const extruded = new BREP.ExtrudeSolid({ face: circularFace, distance: 8.0 }); // The side wall will have cylindrical metadata with radius: 3.0 3. Accessing Face Metadata You can retrieve the embedded radius information: javascript // Get metadata for a specific face const metadata = solid.getFaceMetadata('MyCylinder_S'); if (metadata && metadata.type === 'cylindrical') { console.log('Radius:', metadata.radius); console.log('Height:', metadata.height); console.log('Axis:', metadata.axis); console.log('Center:', metadata.center); } 4. Setting Custom Metadata You can also manually set face metadata: javascript solid.setFaceMetadata('CustomFace', { type: 'cylindrical', radius: 7.5, height: 12.0, axis: [1, 0, 0], center: [0, 0, 0] }); Benefits for Dimensioning Radial Dimensions The PMI system automatically uses embedded radius values when creating radial dimensions: Automatic Detection : When you select a cylindrical face for dimensioning, the system first checks for embedded radius metadata Precise Values : Uses the exact radius value from the original geometry instead of approximating from triangle vertices Performance : No need to perform geometric calculations to determine the radius Usage in PMI Mode javascript // In PMI mode, when creating a radial dimension: // 1. Select the cylindrical face edge // 2. The system automatically detects the embedded radius // 3. Displays the correct radius value for dimensioning Metadata Persistence Face metadata is automatically preserved through: Boolean Operations : Union, subtract, intersect operations preserve metadata from both input solids Transformations : Metadata travels with the face through transformations Feature Operations : Fillets, chamfers, and other operations maintain source metadata when possible Supported Face Types Cylindrical : Full circular cylinders with consistent radius Conical : Truncated cones (when top/bottom radii are equal, treated as cylindrical) Future : Spherical, toroidal, and other curved surfaces can be added using the same pattern Implementation Notes The system uses a Map to store face metadata: Key: Face name (string) Value: Metadata object with type, geometric parameters This approach is: Lightweight : Only stores essential geometric information Extensible : Easy to add new face types and metadata Compatible : Works with existing BREP boolean operations Robust : Gracefully handles missing or invalid metadata"
-  },
-  {
-    "title": "Dialog Screenshots",
-    "href": "dialog-screenshots.html",
-    "summary": "Dialog Screenshots Run pnpm dev and open at least one of the capture helper pages: - http://localhost:5173/feature-dialog-capture.html - http://localhost:5173/pmi-dialog-capture.html - http://localhost:5173/assembly-constraint-capture.html....",
-    "content": "Dialog Screenshots Run pnpm dev and open at least one of the capture helper pages: - http://localhost:5173/feature-dialog-capture.html - http://localhost:5173/pmi-dialog-capture.html - http://localhost:5173/assembly-constraint-capture.html With the dev server running, execute pnpm capture to export every dialog screenshot. Outputs land in: - docs/features (feature dialogs) - docs/pmi-annotations (PMI annotations) - docs/assembly-constraints (assembly constraints) For the schema that drives these dialogs (field types, defaults, and selection filters), see Input Params Schema . Configuration Customize the automation with environment variables: CAPTURE_SCOPE=features,pmi limits which capture helpers are processed. CAPTURE_BASE_URL=http://127.0.0.1:5174 points to a dev server running on a different host/port. CAPTURE_URL + CAPTURE_OUTPUT run a one-off capture against any URL. CAPTURE_DEVICE_SCALE_FACTOR=1 (default 2 ) controls the browser’s device pixel ratio for sharper or softer renders. CAPTURE_OUTPUT_SCALE=device keeps the full hi-DPI image size instead of downscaling back to CSS pixels (default css keeps the files small while retaining clarity)."
-  },
-  {
-    "title": "Radius Metadata for Extruded Sketches",
-    "href": "extruded-sketch-radius-embedding.html",
-    "summary": "Radius Metadata for Extruded Sketches This document details how radius metadata is automatically embedded when extruding circular or arc-based sketch elements. How It Works Automatic Detection When extruding a sketch face, the system automa...",
-    "content": "Radius Metadata for Extruded Sketches This document details how radius metadata is automatically embedded when extruding circular or arc-based sketch elements. How It Works Automatic Detection When extruding a sketch face, the system automatically scans all edges in the sketch for circular geometry: Circle Detection : Edges with sketchGeomType: 'circle' and radius/center data Arc Detection : Edges with sketchGeomType: 'arc' and radius/center data (any arc angle) Metadata Application : Cylindrical face metadata is applied to the resulting side walls Edge Data Requirements For automatic detection, sketch edges need this userData structure: Circles javascript edge.userData = { sketchGeomType: 'circle', circleCenter: [x, y, z], // Center point in local coordinates circleRadius: number // Radius value } Arcs javascript edge.userData = { sketchGeomType: 'arc', arcCenter: [x, y, z], // Center point in local coordinates arcRadius: number, // Radius value arcAngle: number // Arc angle in radians (any value) } Generated Metadata Cylindrical Face Metadata Structure javascript { type: 'cylindrical', radius: 6.5, // Original radius from sketch height: 12.0, // Extrusion distance axis: [0, 1, 0], // Extrusion direction (normalized) center: [0, 6.0, 0] // Center point along cylinder axis } Face Naming Convention Side walls are named using the pattern: ${featureName}:${edgeName}_SW Examples: ExtrudedPart:CircleEdge1_SW HousingExtrude:OuterCircle_SW EXTRUDE_001:ArcEdge_SW Coordinate Transformations Local to World Conversion The system properly handles coordinate transformations: Edge Transforms : If the edge has a matrixWorld , center points are transformed Extrusion Direction : Direction vectors are transformed through the edge matrix Final Positioning : Center points are positioned along the extrusion axis Example Transformation javascript // Original sketch data (local coordinates) circleCenter: [5, 0, 3] circleRadius: 2.5 // After transformation and extrusion metadata: { center: [5, 6.0, 3], // Moved to mid-height of extrusion radius: 2.5, // Preserved original radius height: 12.0, // Total extrusion distance axis: [0, 1, 0] // Normalized extrusion direction } Supported Sketch Configurations Single Circle javascript // Sketch with one circular edge edges: [ { userData: { sketchGeomType: 'circle', circleCenter: [0, 0, 0], circleRadius: 5.0 } } ] // Results in one cylindrical face with radius 5.0 Multiple Circles (Ring/Tube) javascript // Sketch with outer and inner circles edges: [ { userData: { sketchGeomType: 'circle', circleRadius: 10.0 } }, // Outer { userData: { sketchGeomType: 'circle', circleRadius: 6.0 } } // Inner ] // Results in two cylindrical faces with different radii Arc Segments javascript // Sketch with arc edges edges: [ { userData: { sketchGeomType: 'arc', arcRadius: 8.0, arcAngle: Math.PI } } ] // Results in cylindrical face with radius 8.0 (angle doesn't matter for extrusion) Mixed Geometry javascript // Sketch with circles, arcs, and lines edges: [ { userData: { sketchGeomType: 'circle', circleRadius: 4.0 } }, { userData: { sketchGeomType: 'arc', arcRadius: 7.0 } }, { userData: { sketchGeomType: 'line' } } // Ignored - not circular ] // Results in two cylindrical faces (4.0 and 7.0 radius) Integration with PMI Dimensions Automatic Radius Detection When creating radial dimensions: Face Selection : User selects any extruded cylindrical face Metadata Lookup : System finds embedded radius from original sketch Precise Measurement : Uses exact radius value instead of geometric approximation Example Usage javascript // Create radial dimension const radialDim = RadialDimension.create(pmiMode); radialDim.cylindricalFaceRef = 'ExtrudedCircle:OuterRing_SW'; // System automatically uses radius: 7.5 from original sketch geometry // No need to specify center points or edge references Error Handling Missing or Invalid Data No sketch geometry : Falls back to geometric calculation from mesh Invalid radius values : Skips metadata embedding for that edge Transform errors : Uses identity transform as fallback Duplicate edges : Each edge gets its own metadata entry Graceful Degradation javascript try { // Attempt metadata embedding this.setFaceMetadata(faceName, metadata); } catch (err) { // Silently continue - dimension system will fall back to geometric calculation } Performance Benefits Computational Efficiency Direct Lookup : O(1) metadata retrieval vs O(n) mesh analysis No Approximation : Exact values from design intent Cached Results : Metadata persists through boolean operations Memory Usage Minimal Overhead : Small metadata objects per cylindrical face Selective Storage : Only circular/arc edges generate metadata Automatic Cleanup : Metadata removed when faces are deleted Future Enhancements Additional Geometry Types Elliptical Arcs : Store major/minor axis information Spline Curves : Store control point and knot data Complex Profiles : Multi-radius and transitional curves Enhanced Metadata javascript // Future expanded metadata structure { type: 'cylindrical', radius: 5.0, height: 10.0, axis: [0, 1, 0], center: [0, 5.0, 0], // Enhanced information sourceSketch: 'Sketch001', sourceEdge: 'Circle1', tolerance: { radius: ±0.1, position: ±0.05 }, materialThickness: 2.0, surfaceFinish: 'machined' } This system provides exact radius information for dimensioning while maintaining backward compatibility with existing geometric calculation methods."
-  },
-  {
-    "title": "Assembly Component",
-    "href": "features__assembly-component.html",
-    "summary": "Assembly Component Status: Implemented Assembly Component inserts a saved 3MF component into the current assembly, optionally fixing it in place and positioning it with a transform gizmo. Inputs componentName – Pick a saved component from t...",
-    "content": "Assembly Component Status: Implemented Assembly Component inserts a saved 3MF component into the current assembly, optionally fixing it in place and positioning it with a transform gizmo. Inputs componentName – Pick a saved component from the library (3MF payload with optional embedded feature history). isFixed – Lock the component so assembly constraints treat it as immobile. transform – Placement transform (position/rotation/scale) applied to the inserted component bodies. Behaviour Loads the selected 3MF, rebuilds solids from meshes (or from embedded feature history when present), and groups them under a single assembly component node. Applies the feature ID prefix to body/face names for stable selections, then visualizes the inserted bodies. Persists the component payload in persistentData so reruns do not depend on local storage or library lookups."
-  },
-  {
-    "title": "Boolean",
-    "href": "features__boolean.html",
-    "summary": "Boolean Status: Implemented Boolean combines existing solids by running Manifold CSG through BREP.applyBooleanOperation . The feature keeps face labels intact so downstream selections survive. Inputs targetSolid – the solid that supplies th...",
-    "content": "Boolean Status: Implemented Boolean combines existing solids by running Manifold CSG through BREP.applyBooleanOperation . The feature keeps face labels intact so downstream selections survive. Inputs targetSolid – the solid that supplies the base body for UNION/INTERSECT operations. boolean.targets – additional solids to use as tools. Duplicate entries are ignored. boolean.operation – UNION , SUBTRACT , or INTERSECT . NONE leaves the scene unchanged. - boolean.simplify – optional. If true , simplifies the boolean result using a tolerance (see below). If a number, it is treated as the tolerance directly. If omitted, a global default may apply. - boolean.simplifyTolerance – optional numeric tolerance to use when simplifying. Takes precedence when provided. Behaviour UNION and INTERSECT treat the target as the base body and remove the original target from the scene once the new solid is created. SUBTRACT unions all tool solids first, then removes that volume from the target so complex multi-tool cuts stay watertight. Each tool and the original target solid is flagged for removal after the operation; only the new solids returned by the kernel remain in the timeline. When simplification is enabled, the output solid(s) are passed through Solid.simplify(tol) . By default, a small global tolerance is used if configured internally; you can override per-feature via boolean.simplify / boolean.simplifyTolerance ."
-  },
-  {
-    "title": "Chamfer",
-    "href": "features__chamfer.html",
-    "summary": "Chamfer Status: Implemented Chamfer builds a bevel on the selected edges of a single solid by cutting (INSET) or unioning (OUTSET) helper solids generated by BREP.ChamferSolid . Inputs edges – select edges directly or pick faces to gather a...",
-    "content": "Chamfer Status: Implemented Chamfer builds a bevel on the selected edges of a single solid by cutting (INSET) or unioning (OUTSET) helper solids generated by BREP.ChamferSolid . Inputs edges – select edges directly or pick faces to gather all of their boundary edges. distance – the single offset distance used for both faces meeting at each edge. inflate – optional expansion of the helper body to avoid sliver leftovers (small values like 0.0005 are typical). direction – INSET subtracts material, OUTSET adds material. AUTO is reserved for internal use. debug – keeps the intermediate helper solids visible for inspection. Behaviour All selected edges must belong to the same solid. When multiple faces are selected the feature expands them into unique edges. The target solid is cloned, each helper body is booleaned in sequence, and the original solid is flagged for removal when the chamfer succeeds. When debug is enabled, helper solids are left in the scene; otherwise only the finished solid is returned."
-  },
-  {
-    "title": "Datium",
-    "href": "features__datium.html",
-    "summary": "Datium Status: Implemented Datium creates an orthogonal datum triad (XY/XZ/YZ planes) for sketching and feature references. Inputs transform – Position, rotation, and scale applied to the datum group. Behaviour Emits a THREE.Group named aft...",
-    "content": "Datium Status: Implemented Datium creates an orthogonal datum triad (XY/XZ/YZ planes) for sketching and feature references. Inputs transform – Position, rotation, and scale applied to the datum group. Behaviour Emits a THREE.Group named after the feature ID containing three selectable planes tagged as PLANE . Planes are oriented like the Plane feature and respond to the supplied transform, making it easy to anchor sketches or construction geometry away from the origin."
-  },
-  {
-    "title": "Datum",
-    "href": "features__datum.html",
-    "summary": "Datum Status: Implemented Datum creates a lightweight reference group that exposes orthogonal XY/XZ/YZ planes for downstream selections. Inputs transform – position, rotation, and scale applied to the three reference planes. Behaviour The f...",
-    "content": "Datum Status: Implemented Datum creates a lightweight reference group that exposes orthogonal XY/XZ/YZ planes for downstream selections. Inputs transform – position, rotation, and scale applied to the three reference planes. Behaviour The feature emits a THREE.Group named after the feature ID with three plane meshes ( XY , XZ , YZ ). No references are inherited from other geometry yet; the datum always starts at the world origin before the supplied transform is applied. Each plane is selectable through the PLANE selection filter so other features (e.g. sketches) can lock to the datum."
-  },
-  {
-    "title": "Extrude",
-    "href": "features__extrude.html",
-    "summary": "Extrude Status: Implemented Extrude offsets a single face or sketch profile along its normal using the BREP.Sweep translator. Draft or directional flips are not yet exposed. Inputs profile – a face or sketch containing a face. When a sketch...",
-    "content": "Extrude Status: Implemented Extrude offsets a single face or sketch profile along its normal using the BREP.Sweep translator. Draft or directional flips are not yet exposed. Inputs profile – a face or sketch containing a face. When a sketch is selected it is removed from the scene after the solid is created. distance – forward distance along the face normal. distanceBack – optional distance in the opposite direction for two-sided extrudes. boolean.operation / boolean.targets – optional union, subtract, or intersect with existing solids. Behaviour The profile is swept in translate mode; the feature automatically nudges subtract/union distances to avoid coplanar artifacts. Circular edges in the profile emit centerlines for downstream constraints. When boolean.operation is NONE the new solid is returned directly. Otherwise the helper applies the requested CSG operation and removes the source sketch/solids that were consumed."
-  },
-  {
-    "title": "Fillet",
-    "href": "features__fillet.html",
-    "summary": "Fillet Status: Implemented Fillet replaces selected edges on a single solid with a constant-radius blend generated by BREP.filletSolid . Inputs edges – pick edges directly or select faces to expand into their boundary edges. radius – consta...",
-    "content": "Fillet Status: Implemented Fillet replaces selected edges on a single solid with a constant-radius blend generated by BREP.filletSolid . Inputs edges – pick edges directly or select faces to expand into their boundary edges. radius – constant radius applied to every edge. resolution – number of segments around the fillet tube; increase for smoother large radii. inflate – offsets tangency curves and end caps to avoid coplanar leftovers; closed loops skip the wedge inset to avoid self‑intersection. direction – INSET cuts material, OUTSET unions material back. combineEdges – OUTSET-only; hulls fillet ends that share a vertex so corner seams stay closed. showTangentOverlays – adds pre-inflate tangency polylines to the helper tube for debugging. debug – keeps helper bodies visible and logs extra diagnostics. Behaviour All selected edges must belong to the same solid; face picks expand to boundary edges before the builder runs. Helper tube/wedge bodies are generated per edge and booleaned in sequence (union for OUTSET, subtract for INSET). When combineEdges is enabled, shared OUTSET corners are hulled together before the boolean to close gaps. Closed-loop paths suppress the wedge inset used for INSET cuts so the cutter does not self-intersect; tangency offsets still keep the fillet slightly inflated to avoid coplanar seams. On success the original solid is replaced by the blended result. Enabling debug leaves the helper tube/wedge (and any corner hulls or tangent overlays) in the scene for inspection."
-  },
-  {
-    "title": "Helix",
-    "href": "features__helix.html",
-    "summary": "Helix Status: Implemented Helix creates a parametric helical curve you can reuse as a path for sweeps, tubes, or thread features. Geometry generation is delegated to the BREP kernel ( buildHelixPolyline ) so the same code can drive downstre...",
-    "content": "Helix Status: Implemented Helix creates a parametric helical curve you can reuse as a path for sweeps, tubes, or thread features. Geometry generation is delegated to the BREP kernel ( buildHelixPolyline ) so the same code can drive downstream operations and maintain consistent handedness/segmenting. Inputs radius – Base radius of the helix. endRadius – Optional end radius for tapering. mode – Choose whether turns or pitch drives total length (height is always applied). pitch – Distance advanced per turn along the axis (editable in pitch mode; derived in turns mode). turns – Number of turns (used in turns mode; derived in pitch mode). height – Total height along the axis. startAngle – Starting angle in degrees. handedness – Choose right- or left-handed winding. resolution – Segments per turn for the preview polyline. placementMode – Use transform or align to an axis + startPoint . axis – Edge selection for the helix axis (when using axis placement). startPoint – Optional start point when using axis placement. transform – Position, rotation, and scale (when using transform placement). Behaviour Computes helix points in the kernel for consistent reuse (threads, path-driven features). Builds an EDGE with world-space polylineLocal data, plus helper axis/endpoint edges. Axis placement derives origin/direction from the selected edge, optionally using a chosen start point. Stores the generated helix data in persistentData.helix for later edits or inspection."
-  },
-  {
-    "title": "Hole",
-    "href": "features__hole.html",
-    "summary": "Hole Status: Implemented Adds drilled-style holes with optional countersink or counterbore. The feature accepts a sketch or one or more vertices as placement inputs and produces separate holes for every point selected (sketch center P0 is i...",
-    "content": "Hole Status: Implemented Adds drilled-style holes with optional countersink or counterbore. The feature accepts a sketch or one or more vertices as placement inputs and produces separate holes for every point selected (sketch center P0 is ignored by default). Inputs Placement (sketch or points) – Pick a sketch (all sketch points except the auto center) or select individual vertices. Each point creates its own hole. Hole type – SIMPLE , COUNTERSINK , or COUNTERBORE . Diameter – Core hole diameter. Depth – Total hole depth (straight portion). For countersink/counterbore, the sink/bore occupies part of this total; the straight leg shortens accordingly. Through all – If enabled, cuts through the entire target; depth is ignored. Countersink diameter / angle – For countersinks. Counterbore diameter / depth – For counterbores. Thread standard / designation – When Hole type is THREADED , choose a standard (ISO, Unified, etc.) and a size (e.g., #10-24 UNC ). Thread modeling – SYMBOLIC (fast preview) or MODELED (helical geometry). Thread radial offset – Clearance offset applied to crest/root. Thread segments/turn – Controls modeled thread tessellation (ignored for symbolic). Boolean – Optional boolean operation (defaults to subtracting from the target solid). Notes When a sketch is selected, the feature automatically gathers its sketch points (except P0) and places one hole per point. Countersink/counterbore depth is part of the total depth: e.g., total depth 4 with counterbore depth 1 yields a 1‑unit bore plus a 3‑unit straight leg. Hole metadata (center, normal, dimensions, and source selection) is stored for PMI hole callouts. Threaded holes: - Symbolic threads cut the minor-diameter cylinder and add dashed overlay rings at the major diameter plus a centerline. This keeps previews lightweight but communicates thread extents. - Modeled threads build helical geometry; for internal threads, the helix extends one pitch beyond both ends to avoid flat terminations. - Thread metadata (standard, designation, pitch, modeled vs symbolic, offsets) is attached to faces for downstream references. Enabling “Debug: show tool solid” visualizes the tool bodies (cylinder/cone/thread core) used for the boolean."
-  },
-  {
-    "title": "Image Heightmap Solid",
-    "href": "features__image-heightmap-solid.html",
-    "summary": "Image Heightmap Solid Status: Implemented Image Heightmap Solid samples a grayscale (or RGB) image and extrudes the pixels into a heightfield solid, with optional simplification and booleans. Inputs fileToImport – PNG heightmap data (file,....",
-    "content": "Image Heightmap Solid Status: Implemented Image Heightmap Solid samples a grayscale (or RGB) image and extrudes the pixels into a heightfield solid, with optional simplification and booleans. Inputs fileToImport – PNG heightmap data (file, data URL, or buffer). If empty, the image editor starts with a blank canvas. editImage – Opens the built-in paint-style editor to tweak the heightmap. heightScale – World units of elevation for a full-intensity pixel (0–255). baseHeight – Baseline Z height added to every pixel. invertHeights – Flip grayscale so dark pixels become tall regions. pixelScale – World units per pixel in X/Y. center – Center the heightmap about the origin before placement. sampleStride – Sample every Nth pixel to reduce triangle count. placementPlane – Optional face or plane that defines the placement plane and normal. simplifyTolerance – Tolerance for Manifold simplify (0 disables). boolean.operation / boolean.targets – Optional boolean with existing solids. Behaviour Decodes the image to a grid, samples with the requested stride, and builds top/bottom meshes offset by baseHeight plus scaled pixel heights (with optional invert). Positions the mesh on the selected plane (or world XY) and centers it if requested. Applies optional simplification, runs the configured boolean, and returns the new solid while flagging consumed inputs for removal."
-  },
-  {
-    "title": "Image to Face",
-    "href": "features__image-to-face.html",
-    "summary": "Image to Face Status: Implemented Image to Face traces a source image into planar geometry that can be placed on any sketch plane or selected face. It is ideal for logos, decorative cutouts, and relief features. Parameters threshold (0-255)...",
-    "content": "Image to Face Status: Implemented Image to Face traces a source image into planar geometry that can be placed on any sketch plane or selected face. It is ideal for logos, decorative cutouts, and relief features. Parameters threshold (0-255) controls how dark a pixel must be to form geometry. invert flips dark and light interpretation for the trace. pixelScale and center adjust the size and placement of the resulting sketch. simplify options reduce jagged edges on the traced outline. placementPlane lets you place the traced sketch onto a selected face or datum plane; otherwise the world origin is used. Edit Image opens the integrated editor. The feature emits a SKETCH group that contains a triangulated face and edge polylines. Downstream features (Extrude, Revolve, Sweep) can consume the face directly. Inline Image Editor Starts with your current image or a default 300x300 white canvas. Dark themed UI renders at 1:1 pixels with device pixel ratio awareness for crisp previews. Tools include Brush, Eraser, Pan (Space), and Paint Bucket with a tolerance slider (0-255). Brush tool offers live cursor outline, multiple shapes (round, square, diamond), and an eraser that respects the selected shape. Bottom-right resize handle lets you expand or crop the canvas while preserving existing strokes. Undo and Redo history, Fit view, Finish (saves back to the feature), and Cancel are available during editing. Use Finish to update the feature image and rerun the timeline, or Cancel to discard any edits."
-  },
-  {
-    "title": "Import 3D Model",
-    "href": "features__import-3d-model.html",
-    "summary": "Import 3D Model Status: Implemented Import 3D Model loads STL or 3MF data, optionally runs a mesh repair pass, and converts the triangles into a BREP.MeshToBrep solid. Inputs fileToImport – STL (ASCII or binary) or 3MF data supplied as a st...",
-    "content": "Import 3D Model Status: Implemented Import 3D Model loads STL or 3MF data, optionally runs a mesh repair pass, and converts the triangles into a BREP.MeshToBrep solid. Inputs fileToImport – STL (ASCII or binary) or 3MF data supplied as a string, data URL, or ArrayBuffer. deflectionAngle – face split angle in degrees used when converting the triangle mesh into analytic faces. meshRepairLevel – NONE , BASIC , or AGGRESSIVE passes through BREP.MeshRepairer . centerMesh – translate the imported geometry so its bounding box center is at the origin before conversion. Behaviour Strings are treated as ASCII STL unless the data begins with a base64 data URL; ArrayBuffers are inspected for ZIP headers ( PK ) to decide between 3MF and binary STL. When a 3MF file is provided, all meshes in the archive are transformed into world space and merged into a single BufferGeometry before conversion. No timeline or feature history is recovered from the source file—the importer always produces a single solid representing the mesh."
-  },
-  {
-    "title": "Features",
-    "href": "features__index.html",
-    "summary": "Features Reference docs for the built-in modeling features. Assembly Component Boolean Chamfer Datium Datum Extrude Fillet Helix Hole Image to Face Image Heightmap Solid Import 3D Model Loft Mirror Offset Shell Pattern Pattern Linear Patter...",
-    "content": "Features Reference docs for the built-in modeling features. Assembly Component Boolean Chamfer Datium Datum Extrude Fillet Helix Hole Image to Face Image Heightmap Solid Import 3D Model Loft Mirror Offset Shell Pattern Pattern Linear Pattern Radial Plane Primitive Cone Primitive Cube Primitive Cylinder Primitive Pyramid Primitive Sphere Primitive Torus Remesh Revolve Sheet Metal Contour Flange Sheet Metal Flange Sheet Metal Tab Sketch Spline Sweep Transform Tube"
-  },
-  {
-    "title": "Loft",
-    "href": "features__loft.html",
-    "summary": "Loft Status: Implemented Loft stitches two or more faces (or sketches containing faces) into a single solid by marching matching loop samples between the profiles. Inputs profiles – ordered list of faces or sketches. Each sketch must contai...",
-    "content": "Loft Status: Implemented Loft stitches two or more faces (or sketches containing faces) into a single solid by marching matching loop samples between the profiles. Inputs profiles – ordered list of faces or sketches. Each sketch must contain a face; the sketch is removed after use. referencePoints – optional vertex selections that provide starting indices per profile. Supply the same number of points as profiles if you need to align loop ordering manually. guideCurves – currently unused; guide curves are planned but not yet consumed by the feature. loftType – interpolation strategy (e.g., ruled vs. smooth). Current implementation accepts the field for compatibility but behaves as a standard smooth loft. reverseFirstLoop – flips the direction of the first profile’s outer loop to help match winding between sections. boolean – optional union/subtract/intersect with existing solids after the loft is generated. Behaviour The first profile drives naming for side faces. Boundary loops (outer + holes) are read from face.userData.boundaryLoopsWorld when available; otherwise edge polylines are sampled. Profiles must share topology (same number of loops and similar tessellation) for reliable results. When loops differ, the feature falls back to nearest-point mapping which may twist surfaces. After the loft solid is built, sketches used as inputs are flagged for removal, and the optional boolean operation runs if configured."
-  },
-  {
-    "title": "Mirror",
-    "href": "features__mirror.html",
-    "summary": "Mirror Status: Implemented Mirror clones the selected solids and reflects the copies across a reference plane or face. Inputs solids – one or more solids to mirror. mirrorPlane – a face or datum plane that supplies the mirror origin and nor...",
-    "content": "Mirror Status: Implemented Mirror clones the selected solids and reflects the copies across a reference plane or face. Inputs solids – one or more solids to mirror. mirrorPlane – a face or datum plane that supplies the mirror origin and normal. Plane meshes use their +Z direction. offsetDistance – optional signed offset applied along the plane normal before mirroring. Behaviour Each source solid is cloned, mirrored via Solid.mirrorAcrossPlane , and retagged so face names remain unique ( ::FeatureID suffix). The original solids are left in place; only the mirrored copies are returned. Use a downstream boolean if you need to join the results."
-  },
-  {
-    "title": "Offset Shell",
-    "href": "features__offset-shell.html",
-    "summary": "Offset Shell Status: Implemented Offset Shell offsets every face of a solid outward or inward by a uniform distance, producing a new shelled solid. It requires selecting a face on the target solid only to identify which solid to process. In...",
-    "content": "Offset Shell Status: Implemented Offset Shell offsets every face of a solid outward or inward by a uniform distance, producing a new shelled solid. It requires selecting a face on the target solid only to identify which solid to process. Inputs faces – One or more faces on the solid to shell (used to pick the parent solid). All faces must belong to the same solid. distance – Signed offset distance. Positive grows the solid; negative shrinks it. Must be non-zero. id – Optional identifier applied to the generated shell and its faces. Behaviour Collects the solid from the selected faces; aborts if selections span multiple solids or no solid is found. Uses OffsetShellSolid.generate to build a new shell solid at the requested offset; leaves the original solid untouched. Names the result <parentName>_<featureID> and visualizes it for downstream selection."
-  },
-  {
-    "title": "Pattern Linear",
-    "href": "features__pattern-linear.html",
-    "summary": "Pattern Linear Status: Implemented Pattern Linear duplicates solids by translating copies along a single offset vector. Inputs solids – solids to duplicate. If you pick faces/edges the owning solid is inferred. count – total number of insta...",
-    "content": "Pattern Linear Status: Implemented Pattern Linear duplicates solids by translating copies along a single offset vector. Inputs solids – solids to duplicate. If you pick faces/edges the owning solid is inferred. count – total number of instances including the original. Values below 1 are clamped. offset – transform gizmo used to set translation between instances. Only offset.position is applied; rotation/scale fields are ignored. Behaviour The feature clones each solid and bakes a translation of offset.position * instanceIndex into the geometry. The source solid is untouched. Face IDs on the copies are remapped and tagged with the feature ID so downstream selections stay unique per instance."
-  },
-  {
-    "title": "Pattern Radial",
-    "href": "features__pattern-radial.html",
-    "summary": "Pattern Radial Status: Implemented Pattern Radial rotates copies of solids about a selected edge axis. Inputs solids – solids to copy. The feature pulls the owning solid when faces or edges are selected. axisRef – an edge whose direction de...",
-    "content": "Pattern Radial Status: Implemented Pattern Radial rotates copies of solids about a selected edge axis. Inputs solids – solids to copy. The feature pulls the owning solid when faces or edges are selected. axisRef – an edge whose direction defines the rotation axis. The feature samples the edge polyline or geometry to recover two points. centerOffset – shift the rotation center along the axis direction before copies are generated. count – total number of instances including the original. totalAngleDeg – angle in degrees spanned by all additional instances. With count = n , each copy is spaced at (totalAngleDeg / n) * index . Behaviour Copies are produced by cloning the solids, rotating them around the computed axis, and baking the transform. The original solid stays in place. Face IDs on each copy are rewritten with a ::FeatureID_instance suffix to keep downstream selections distinct."
-  },
-  {
-    "title": "Pattern (Legacy)",
-    "href": "features__pattern.html",
-    "summary": "Pattern (Legacy) Status: Implemented Pattern is the legacy combined pattern tool that can create either linear or circular arrays of solids, with an option to union instances back into the source. Inputs solids – Solids to pattern. Face/edg...",
-    "content": "Pattern (Legacy) Status: Implemented Pattern is the legacy combined pattern tool that can create either linear or circular arrays of solids, with an option to union instances back into the source. Inputs solids – Solids to pattern. Face/edge selections resolve their owning solid automatically. mode – LINEAR or CIRCULAR . count – Total instances including the original (clamped to ≥1). offset – Transform used for linear patterns; only position is applied between instances. axisRef – Face or datum plane supplying the axis and origin for circular patterns. centerOffset – Distance along the axis from the reference origin to the pattern center. totalAngleDeg – Total sweep angle distributed across circular instances. booleanMode – NONE returns separate bodies; UNION fuses clones into the source and removes the originals. Behaviour Linear mode translates clones by offset.position * instanceIndex ; circular mode rotates clones about the referenced axis and center. When booleanMode is UNION , clones are merged into each source solid and the originals are flagged for removal; otherwise all clones are returned as separate solids. Face names on clones are retagged with the feature ID to keep downstream selections stable even when booleaned together."
-  },
-  {
-    "title": "Plane",
-    "href": "features__plane.html",
-    "summary": "Plane Status: Implemented Plane creates a square construction mesh that can be used as a sketch or measurement reference. Inputs orientation – choose one of the world-aligned bases ( XY , XZ , YZ ). datum – reserved for future datum-based p...",
-    "content": "Plane Status: Implemented Plane creates a square construction mesh that can be used as a sketch or measurement reference. Inputs orientation – choose one of the world-aligned bases ( XY , XZ , YZ ). datum – reserved for future datum-based placement (currently ignored). offset_distance – reserved; the current implementation does not shift the plane. Behaviour A 5×5 mesh is emitted with the selected orientation. The feature ID is assigned to the mesh name and UUID so other features can reference it through PLANE selection filters. Use downstream transform features if you need the plane positioned away from the origin; offsetting directly inside the feature is not yet supported."
-  },
-  {
-    "title": "Primitive Cone",
-    "href": "features__primitive-cone.html",
-    "summary": "Primitive Cone Status: Implemented Primitive Cone builds a frustum aligned to the +Y axis using BREP.Cone . Inputs radiusTop / radiusBottom – radii at the top and base. Setting the top radius to 0 creates a sharp tip. height – distance alon...",
-    "content": "Primitive Cone Status: Implemented Primitive Cone builds a frustum aligned to the +Y axis using BREP.Cone . Inputs radiusTop / radiusBottom – radii at the top and base. Setting the top radius to 0 creates a sharp tip. height – distance along +Y from base to tip. resolution – number of segments around the circumference. transform – optional position/orientation/scale baked into the solid. boolean – optional downstream boolean operation (union/subtract/intersect) applied immediately after creation. Behaviour A centerline is authored along the local Y axis (respecting the transform) so the cone can be reused as an axis reference. When a boolean operation is configured, the helper removes any consumed solids and returns only the boolean results; otherwise the raw cone solid is returned."
-  },
-  {
-    "title": "Primitive Cube",
-    "href": "features__primitive-cube.html",
-    "summary": "Primitive Cube Status: Implemented Primitive Cube builds an axis-aligned rectangular prism rooted at the origin. Inputs sizeX , sizeY , sizeZ – side lengths along the world X/Y/Z axes. transform – optional translation/rotation/scale baked i...",
-    "content": "Primitive Cube Status: Implemented Primitive Cube builds an axis-aligned rectangular prism rooted at the origin. Inputs sizeX , sizeY , sizeZ – side lengths along the world X/Y/Z axes. transform – optional translation/rotation/scale baked into the cube before visualization. boolean – optional CSG operation applied immediately after the cube is created. Behaviour The cube extends in the positive axis directions from (0,0,0) ; use the transform to reposition it in the scene. When a boolean is configured the feature returns the CSG results; otherwise the raw cube solid is emitted."
-  },
-  {
-    "title": "Primitive Cylinder",
-    "href": "features__primitive-cylinder.html",
-    "summary": "Primitive Cylinder Status: Implemented Primitive Cylinder creates a right cylinder aligned to the +Y axis. Inputs radius – cylinder radius. height – distance along +Y. resolution – number of circular segments. transform – optional translati...",
-    "content": "Primitive Cylinder Status: Implemented Primitive Cylinder creates a right cylinder aligned to the +Y axis. Inputs radius – cylinder radius. height – distance along +Y. resolution – number of circular segments. transform – optional translation/rotation/scale baked into the solid. boolean – optional union/subtract/intersect applied after creation. Behaviour A centerline is recorded along the local axis so downstream constraints can re-use it. The base of the cylinder starts at the origin; relocate it with the transform or a later Transform feature."
-  },
-  {
-    "title": "Primitive Pyramid",
-    "href": "features__primitive-pyramid.html",
-    "summary": "Primitive Pyramid Status: Implemented Primitive Pyramid extrudes a regular polygon base to an apex aligned with the +Y axis. Inputs baseSideLength – length of each side on the base polygon. sides – number of sides for the base (minimum 3).....",
-    "content": "Primitive Pyramid Status: Implemented Primitive Pyramid extrudes a regular polygon base to an apex aligned with the +Y axis. Inputs baseSideLength – length of each side on the base polygon. sides – number of sides for the base (minimum 3). height – tip-to-base distance along +Y. transform – optional translation/rotation/scale applied to the solid. boolean – optional boolean operation performed after the pyramid is generated. Behaviour The solid is centered at the origin with the apex at +height/2 and the base at -height/2 . Use the transform input or a downstream transform to reposition it."
-  },
-  {
-    "title": "Primitive Sphere",
-    "href": "features__primitive-sphere.html",
-    "summary": "Primitive Sphere Status: Implemented Primitive Sphere builds a sphere centered at the origin using BREP.Sphere . Inputs radius – sphere radius. resolution – base longitudinal segment count (latitude segments are derived). transform – option...",
-    "content": "Primitive Sphere Status: Implemented Primitive Sphere builds a sphere centered at the origin using BREP.Sphere . Inputs radius – sphere radius. resolution – base longitudinal segment count (latitude segments are derived). transform – optional translation/rotation/scale baked into the solid. boolean – optional boolean operation run after creating the sphere. Behaviour The feature emits a single analytic face representing the sphere. Use the transform to move it before combining with other bodies."
-  },
-  {
-    "title": "Primitive Torus",
-    "href": "features__primitive-torus.html",
-    "summary": "Primitive Torus Status: Implemented Primitive Torus creates a torus (full or partial) around the local Y axis. Inputs majorRadius – distance from the center to the tube centerline. tubeRadius – radius of the tube itself. resolution – segmen...",
-    "content": "Primitive Torus Status: Implemented Primitive Torus creates a torus (full or partial) around the local Y axis. Inputs majorRadius – distance from the center to the tube centerline. tubeRadius – radius of the tube itself. resolution – segment quality around the torus. arc – sweep angle in degrees; values below 360 produce capped ends. transform – optional translation/rotation/scale baked into the solid. boolean – optional boolean operation run after creation. Behaviour A centerline is stored along the revolve axis for reuse. With partial arcs the feature automatically builds end caps so the body stays watertight."
-  },
-  {
-    "title": "Remesh",
-    "href": "features__remesh.html",
-    "summary": "Remesh Status: Implemented Remesh clones a selected solid and refines its triangulation based on a target edge length. Inputs targetSolid – the solid to remesh. The original is flagged for removal after the clone is generated. mode – choose...",
-    "content": "Remesh Status: Implemented Remesh clones a selected solid and refines its triangulation based on a target edge length. Inputs targetSolid – the solid to remesh. The original is flagged for removal after the clone is generated. mode – choose Increase resolution (split long edges) or Simplify (decimate using tolerance). maxEdgeLength – splits any triangle edges longer than this value. maxIterations – number of refinement passes to run. tolerance – simplification tolerance used when mode is set to simplify. Behaviour The feature duplicates the solid, runs solid.remesh({ maxEdgeLength, maxIterations }) , and returns the new solid while marking the source solid for removal. Use upstream booleans or transforms if you need to work on multiple solids; Remesh operates on a single target at a time."
-  },
-  {
-    "title": "Revolve",
-    "href": "features__revolve.html",
-    "summary": "Revolve Status: Implemented Revolve sweeps a face or sketch profile around an edge-defined axis to create lathe-style solids. Inputs profile – a face or sketch containing a face. Sketch parents are removed after the revolve is generated. ax...",
-    "content": "Revolve Status: Implemented Revolve sweeps a face or sketch profile around an edge-defined axis to create lathe-style solids. Inputs profile – a face or sketch containing a face. Sketch parents are removed after the revolve is generated. axis – an edge that defines the rotation axis. The feature samples the edge polyline/geometry in world space. angle – revolution angle in degrees (0–360). Values below 360 create end caps. boolean – optional union/subtract/intersect against other solids. Behaviour Boundary loops are read from the profile’s metadata when available so holes remain aligned; otherwise edge polylines are sampled. The feature builds start/end caps for partial revolves and names side faces using the first profile’s edge labels. After the revolve solid is created the optional boolean helper runs. Consumed sketches and solids are flagged for removal automatically."
-  },
-  {
-    "title": "Sheet Metal Contour Flange",
-    "href": "features__sheet-metal-contour-flange.html",
-    "summary": "Sheet Metal Contour Flange Status: Implemented Contour Flange converts an open sketch (or connected edge chain) into a sheet metal body by sweeping a rectangular strip along the curves. The tool inserts bend radii wherever adjacent segments...",
-    "content": "Sheet Metal Contour Flange Status: Implemented Contour Flange converts an open sketch (or connected edge chain) into a sheet metal body by sweeping a rectangular strip along the curves. The tool inserts bend radii wherever adjacent segments meet so downstream features inherit accurate manufacturing parameters. Inputs path – Open sketch or connected edges describing the contour path. Paths are auto-sorted and filleted. distance – Width of the strip measured perpendicular to the selected path. Negative values flip the strip direction. thickness – Sheet-metal thickness, extruded normal to the sketch plane. bendRadius – Default inside bend radius used to round every sharp joint. reverseSheetSide – Flip which side of the sketch plane receives material (handy when the automatic side is opposite your intent). consumePathSketch – Optional checkbox to remove the driving sketch after the body is created (disable to keep it visible for downstream edits). Behaviour Builds a rectangular sweep profile ( distance × thickness ) anchored to the selected path, then uses BREP.Sweep in pathAlign mode so bends follow the path curvature. Automatically fillets the path with the supplied bend radius (so two-line sketches become manufacturable flanges without extra work). Removes consumed sketch groups once the flange body is generated. Annotates created solids with userData.sheetMetal metadata (base type, thickness, bend radius, sheet side, etc.) for downstream flange/cutout operations."
-  },
-  {
-    "title": "Sheet Metal Flange",
-    "href": "features__sheet-metal-flange.html",
-    "summary": "Sheet Metal Flange Status: Implemented Sheet Metal Flange bends one or more thin side faces away from an existing sheet metal body. It reuses the base face and hinge edge to revolve a bend, offsets it to match typical inside/outside measure...",
-    "content": "Sheet Metal Flange Status: Implemented Sheet Metal Flange bends one or more thin side faces away from an existing sheet metal body. It reuses the base face and hinge edge to revolve a bend, offsets it to match typical inside/outside measurements, and can optionally extend a straight leg past the bend. Inputs faces – Thin side faces that define the bend profile. The feature reads sheet-metal metadata on these faces/solids to recover thickness and default bend radius. angle – Bend angle relative to the parent sheet (clamped 0–180°; 90° is perpendicular). useOppositeCenterline – Reverse which sheet-metal edge (A vs B) is used for the hinge if the default folds the wrong way. flangeLength – Optional straight leg length extruded from the bend end face. Set to 0 to create only the bend. flangeLengthReference – Measurement basis for the straight leg: inside , outside , or web (no adjustment). Inside/outside references subtract bend radius and/or thickness to align with common flange callouts. inset – Positions the bend centerline relative to the source face: material_inside , material_outside (default), or bend_outside . Each preset offsets by the bend radius/thickness before building the bend. offset – Additional manual inset/outset distance applied along the face normal. Negative values cut a matching pocket from the parent sheet; positive values shift the bend outward. bendRadius – Optional override for the bend radius. Defaults to the parent sheet’s stored radius or the inferred thickness when metadata is missing. reliefWidth – Extra clearance added to negative offsets when trimming into the parent sheet to avoid coplanar artifacts. debugSkipUnion – Return raw bend/offset solids without uniting them back into the parent (for debugging). Behaviour Derives sheet thickness and default bend radius from the selected face/solid metadata ( sheetMetalThickness / sheetMetalBendRadius ), falling back to thickness 1 when absent. For each face, picks a hinge line (favoring faces tagged A / B ) and revolves the face by the requested angle. A second pass retunes the hinge offset if the measured bend radius drifts from the target. Applies inset/outset and manual offsets before creating the bend; negative offsets subtract a spacer from the parent sheet when possible, while positive offsets translate the flange outward. When flangeLength is non-zero, extrudes a flat leg from the bend end cap, honoring the selected length reference and any offset translation. Attempts to union every generated flange back into its parent solid, but falls back to returning separate solids if the boolean fails or union is disabled. Tags outputs with userData.sheetMetal ( baseType: FLANGE , thickness, bend radius, angle, inset mode, offsets, etc.) and mirrors the values into the MetadataManager for downstream sheet-metal operations."
-  },
-  {
-    "title": "Sheet Metal Tab",
-    "href": "features__sheet-metal-tab.html",
-    "summary": "Sheet Metal Tab Status: Implemented The Sheet Metal Tab feature creates a base flange by extruding a closed sketch (or face) by a specified thickness. Besides generating geometry via the robust sweep implementation, it records the sheet thi...",
-    "content": "Sheet Metal Tab Status: Implemented The Sheet Metal Tab feature creates a base flange by extruding a closed sketch (or face) by a specified thickness. Besides generating geometry via the robust sweep implementation, it records the sheet thickness so downstream flange/cutout tools can reuse the value. Inputs profile – Closed sketch or face defining the tab footprint. If a sketch is selected it will be removed from the scene once the tab body is generated. thickness – Sheet metal thickness. The feature uses this value for both the physical extrusion distance and the stored sheet metadata. placementMode – Determines how the thickness is applied relative to the sketch plane: forward, reverse, or midplane (symmetric). bendRadius – Captured default bend radius for the part. The geometry ignores this value (tabs are planar) but downstream flange/cutout features reuse it. consumeProfileSketch – Checkbox to remove the driving sketch after the tab is created. Disable to leave the sketch visible for edits or reuse. boolean.operation / boolean.targets – Optional union/subtract/intersect with existing solids. Behaviour Tabs reuse the BREP.Sweep translator to form solids and automatically remove consumed sketches unless consumeProfileSketch is turned off. Every resulting solid receives userData.sheetMetal metadata ( baseType: TAB , thickness , bendRadius , consumeProfileSketch , etc.) plus mirrored entries in the MetadataManager . Thickness must be greater than zero; negative inputs flip the placement automatically unless an explicit mode is chosen."
-  },
-  {
-    "title": "Sketch",
-    "href": "features__sketch.html",
-    "summary": "Sketch Status: Implemented Sketch stores 2D geometry in feature-persistent data and visualises it on a selected plane or face. The sketch mode opens a 2D sketcher environment where you can draft profiles that become the basis for Extrude, R...",
-    "content": "Sketch Status: Implemented Sketch stores 2D geometry in feature-persistent data and visualises it on a selected plane or face. The sketch mode opens a 2D sketcher environment where you can draft profiles that become the basis for Extrude, Revolve, Loft, or Sweep features. Overview Sketch Mode opens the 2D sketcher on a selected plane or face. Geometry is constrained within a local coordinate system, letting you dimension lines, arcs, and splines precisely. When you finish, the sketch remains parametric and updates downstream features as you edit it later. Workflow Choose a plane or datum, then activate Sketch Mode from the feature history Draw with line, rectangle, circle, arc, spline, and text tools Apply constraints and dimensions to lock intent before returning to Modeling Mode Refine profiles with Trim, construction toggles, and spline edits Use the sketch as input for other features like Extrude, Revolve, Sweep, or Loft Tool Icons Sketch Mode uses Unicode icon buttons for quick tool switching. The top toolbar includes: Icon Tool What it does 👆 Select Select and edit sketch points, curves, and constraints. ✂ Trim Trim a curve at the nearest intersection(s) around the click. ⌖ Point Create a point on the sketch plane. / Line Create a line between two points. ☐ Rectangle Create a rectangle from two corner points. ◯ Circle Create a circle from center → radius point. ◠ Arc Create an arc from center → start → end. ∿ Bezier Create a cubic Bezier (end0 → ctrl0 → ctrl1 → end1). 🔗 Link external edge Project edge endpoints into the sketch as fixed points. ↶ Undo Undo the last sketch operation. ↷ Redo Redo the last undone sketch operation. Inputs sketchPlane – face or datum plane that defines the sketch basis. The plane orientation updates automatically when the reference moves. Edit Sketch – opens the in-app sketcher ( viewer.startSketchMode ) so you can add points, curves, and constraints. curveResolution – tessellation setting used when generating circular geometry for downstream features. Behaviour The feature builds a local coordinate frame from the selected plane, saves it in persistent data, and reuses it on every regenerate so the sketch tracks its reference. Sketch geometry is kept as JSON, solved through the ConstraintEngine , and rendered as a SKETCH group containing faces and edges that other features (Extrude, Revolve, Sweep) can consume. External references are projected into sketch space at regenerate time and expression-backed dimensions are evaluated before solving. Constraints Sketch constraints show up as glyphs that use Unicode icons so you can tell them apart at a glance. The solver supports the following set: Symbol Constraint What it does ⏚ Ground Locks a point in place. Used for the origin and any projected references so they cannot be dragged. ━ Horizontal Forces two selected points to share the same y value. │ Vertical Forces two selected points to share the same x value. ≡ Coincident Merges two points so they occupy the same coordinates; downstream coincident groups stay merged. ⟺ Distance Adds a numeric dimension. On lines it fixes the segment length, on arcs/circles it becomes a radius or diameter dimension. ⇌ Equal Distance Makes two segments (or two radii) match length. Works for line pairs or circular features that need equal radii. ∥ Parallel Keeps two lines travelling in the same direction, reusing existing horizontal/vertical locks when possible. ⟂ Perpendicular / Tangent For line pairs it enforces a 90° angle. When applied between a line and a circle/arc it constrains the line to stay tangent by keeping the radius perpendicular at the contact point. ∠ Angle Stores an explicit angle between two segments. The initial value is captured from the current sketch state. ⏛ Point on Line Projects a point onto the line defined by the first two selections, useful for keeping construction points collinear. ⋯ Midpoint Centers the third point midway between the first two and retains equal distances as you edit the sketch. Grouped constraints that touch the same points share a single anchor and render their glyphs side by side so complex regions stay legible. Context Toolbar A floating context toolbar follows the sketch viewport and updates itself based on the active selection. It offers only the constraints and actions that apply to the selected entities, making it quick to add intent without digging through menus. Adaptive constraints – Select two line segments and the toolbar lights up Parallel ∥ , Perpendicular ⟂ , Angle ∠ , and Equal Distance ⇌ . Pick a line and an arc and it switches to the tangent option. Single, double, or triple point selections surface the matching point-based constraints ( H ━ , V │ , Coincident ≡ , Distance ⟺ , Colinear ⏛ , etc.). Radial dimensions – Selecting a single circle or arc reveals Radius and Diameter dimension buttons so you can drop the right measurement without changing tools. Construction toggle – Any time geometry is highlighted the toolbar shows a toggle that flips the selection between regular sketch curves and construction geometry. Construction curves remain in the sketch for constraints but are ignored when profiles are consumed by downstream features. Fix / Unfix – When one or more points are selected the toolbar offers a fast fix toggle, adding or removing ⏚ constraints without opening the constraint picker. Cleanup & delete – The toolbar always offers a cleanup button (🧹) to remove orphan points, and shows delete actions when a selection is active. Context Action Icons Icon Action Notes ◐ Construction toggle Switch selected curves between construction and regular geometry. 🧹 Cleanup Remove orphan points that are unused by geometry and lightly constrained. 🗑 Delete Remove the current selection. R Radius Create a radius dimension on an arc/circle. ⌀ Diameter Create a diameter dimension on an arc/circle. Trim Tool Trim removes the clicked segment of a curve using the closest intersection(s) around the cursor. Activation – Choose the ✂ Trim tool from the top toolbar, then click the curve segment you want to remove. Supported geometry – Lines, arcs, circles, and Bezier splines can be trimmed. Local splitting – Trim only splits at the nearest intersection(s) around the click, not at every intersection along the curve. Closed curves – Circles (and full arcs) keep the segment opposite the clicked section. Degenerate cases – If a curve lies on top of another curve or an endpoint already sits on another curve and no valid trim bounds exist, Trim removes the curve entirely. Constraint preservation – When trimming against a line, the new trim point is constrained colinear to the cutting line (or coincident if it lands on the cutting line endpoint). For arcs/circles, trim points receive an equal‑distance constraint from the center to preserve the radius. Splines currently trim without adding constraints. Spline (Bezier) Editing The sketcher includes direct Bezier editing with construction‑line helpers. Creation – The ∿ tool creates a cubic Bezier using four points: end0 → ctrl0 → ctrl1 → end1. Construction guides – After creation, construction lines connect each endpoint to its adjacent handle so you can constrain handles with regular sketch constraints. Insert point – With the Bezier tool active, clicking near an existing Bezier inserts a new anchor at the closest location. The curve is split using de Casteljau so its shape is preserved, and new handle points plus construction guides are added. Visual Feedback Under‑constrained points – Points that are not fixed and are not referenced by any non‑temporary constraint are rendered in orange to flag areas that still need intent. Solver Settings The sketch sidebar exposes solver settings for iteration count, tolerance, and decimal precision. It also includes: Auto‑remove orphan points (default on) – After delete and trim operations, the sketcher removes points that are not used by any geometry and either have no constraints or only a single coincident/point‑on‑line constraint. This is the same logic used by the 🧹 cleanup action in the context toolbar. Linking External Geometry Sketch Mode can link to edges that live outside the current sketch so profiles stay tied to upstream solids: Switch to the sketch and pick Link external edge on the top toolbar. Click scene edges or face boundaries; each pick projects both endpoints into sketch UV space and adds them as fixed points. The viewer lists every linked edge; selecting a row reselects its projected points, and Unlink removes the pair and their auto-created ground constraints. The sketch feature stores external links as externalRefs in persistent data. On every regenerate it looks up the referenced edge by id or name, reprojects the endpoints into the sketch plane, and reapplies ⏚ constraints so the references remain locked. If the source geometry moves, the sketch updates automatically, keeping downstream features live without requiring you to redraw or manually re-reference the outline."
-  },
-  {
-    "title": "Spline",
-    "href": "features__spline.html",
-    "summary": "Spline Status: Implemented Spline creates a Hermite-style spline curve using an interactive point list widget. The curve is stored as editable spline data and rendered at a configurable resolution. Inputs curveResolution – Samples per segme...",
-    "content": "Spline Status: Implemented Spline creates a Hermite-style spline curve using an interactive point list widget. The curve is stored as editable spline data and rendered at a configurable resolution. Inputs curveResolution – Samples per segment used to draw the spline preview. bendRadius – Controls smoothness between points; smaller values sharpen bends. splinePoints – Editable point list (via the embedded widget) that defines spline anchors and tangents. Behaviour Opens an interactive spline editor inside the dialog to add/reorder/drag control points and tangents. Stores normalized spline data in persistentData.spline so reruns reuse the edited curve. Re-renders the spline preview at the requested resolution whenever points or bend radius change."
-  },
-  {
-    "title": "Sweep",
-    "href": "features__sweep.html",
-    "summary": "Sweep Status: Implemented Sweep extrudes a single profile along one or more connected path edges using BREP.Sweep . Inputs profile – a face or sketch containing a face. Sketch parents are removed once the sweep succeeds. path – one or more....",
-    "content": "Sweep Status: Implemented Sweep extrudes a single profile along one or more connected path edges using BREP.Sweep . Inputs profile – a face or sketch containing a face. Sketch parents are removed once the sweep succeeds. path – one or more edges that define the sweep trajectory. Edges are chained in the order selected. orientationMode – translate keeps the profile orientation fixed; pathAlign attempts to align the profile frame to the path. twistAngle – reserved for future use; the current implementation ignores this value. boolean – optional union/subtract/intersect applied after the sweep solid is built. Behaviour The feature requires a path selection; without it the sweep throws an error to prompt the user. Helper solids remove the input sketch (if any) and run the configured boolean operation, returning only the resulting solids."
-  },
-  {
-    "title": "Transform",
-    "href": "features__transform.html",
-    "summary": "Transform Status: Implemented Transform applies translation, rotation, and scale to selected solids. Inputs solids – solids to transform. Faces/edges are promoted to their owning solids. space – apply translation/rotation in WORLD or LOCAL....",
-    "content": "Transform Status: Implemented Transform applies translation, rotation, and scale to selected solids. Inputs solids – solids to transform. Faces/edges are promoted to their owning solids. space – apply translation/rotation in WORLD or LOCAL space. pivot – ORIGIN or the source solid’s bounding box center. translate , rotateEulerDeg , scale – vector values applied about the chosen pivot. copy – when enabled the original solids remain and transformed copies are added; otherwise originals are replaced. Behaviour Transforms are baked directly into the cloned solid’s geometry, keeping subsequent operations simple. When replacing the original, the new solid inherits the source name; copies receive a _COPY suffix and the originals remain in the scene."
-  },
-  {
-    "title": "Tube Feature",
-    "href": "features__tube.html",
-    "summary": "Tube Feature The Tube feature now builds a sequence of convex hulls between overlapping spheres placed on the path points. Those hulls are united into the final body (with optional hollowing), so even very tight corners stay self-intersecti...",
-    "content": "Tube Feature The Tube feature now builds a sequence of convex hulls between overlapping spheres placed on the path points. Those hulls are united into the final body (with optional hollowing), so even very tight corners stay self-intersection free while keeping a consistent radius. Inputs Path – Select one or more connected EDGE entities. The feature orders the edges into a single polyline; branches are ignored. Sketch edges, face edges, or imported curve edges can all be used. Radius – Outer radius of the tube. Must be positive. Inside Radius – Optional hollow core. Set to 0 (default) for a solid tube. Any positive value smaller than the outer radius produces a hollow tube with open ends and wall thickness radius - insideRadius . Resolution – Number of segments around the tube. Higher values yield smoother cylinders at the cost of more triangles. Boolean – Optional boolean operation against existing solids. Notes Path edges are evaluated in world space, so you can mix sketch geometry with edges from previous features. When multiple edges are selected, the feature automatically chains them end-to-end. Use construction geometry or split edges if you need explicit control over path ordering. Hollow tubes generate inner and outer walls plus ring faces at the ends, keeping the part watertight. Open tubes are trimmed with planes perpendicular to the first and last segments, giving clean ring ends while retaining the rounded outer body. Typical Workflow Create a sketch with the desired centerline, or select edges from existing geometry. Add a Tube feature, select the path edges, and set the outer radius. Optionally set an inside radius to make the tube hollow and adjust the resolution for smoother roundness. Apply boolean operations (Add/Subtract/Intersect) if you need the tube to merge with other solids. This feature is ideal for modelling piping runs, wiring conduits, curved handrails, and other cylindrical geometry that has to follow arbitrary paths."
-  },
-  {
-    "title": "File Formats: Import and Export",
-    "href": "file-formats.html",
-    "summary": "File Formats: Import and Export 3MF (Feature Aware) Export : Generates a 3MF container that includes triangulated geometry plus an embedded copy of the feature history at Metadata/featureHistory.json . PMI views (camera, view settings, and....",
-    "content": "File Formats: Import and Export 3MF (Feature Aware) Export : Generates a 3MF container that includes triangulated geometry plus an embedded copy of the feature history at Metadata/featureHistory.json . PMI views (camera, view settings, and annotations) are part of that history, and when views exist the exporter also writes labeled PNG captures to /views/<view-name>.png with relationships from the package root. Multiple solids export as separate objects in a single file. Units are configurable (default millimeter). Non-manifold solids are skipped with a notification, but the export proceeds. Import : Loads 3MF files and restores the embedded feature history when present. If no history is stored, the geometry imports as editable mesh only. Compatibility : The extra history metadata is ignored by other 3MF viewers, but the file remains valid. STL Export : Writes ASCII STL. If multiple solids are selected, the dialog produces a ZIP archive with one STL per solid. Unit scaling applies at export time. Import : Supports ASCII or binary STL. Imports as geometry only without feature history. OBJ Export : Writes ASCII OBJ (ZIP with one OBJ per solid when multiple bodies are selected). Unit scaling applies at export time. BREP JSON Export : Saves the feature history only as JSON ( .BREP.json ) with no mesh data. Useful for versioning or quick backups. Import : Reloads the saved history and recomputes the model. Implementation Notes 3MF exporter lives at src/exporters/threeMF.js and packages geometry plus attachments through JSZip. Export dialog logic resides in src/UI/toolbarButtons/exportButton.js . Import button handling lives in src/UI/toolbarButtons/importButton.js . Feature history is embedded directly as JSON without XML conversion. Face labels carry through export via per-object BaseMaterials, providing human-readable names in other tools. Materials and textures are not reconstructed on import."
-  },
-  {
-    "title": "Getting Started",
-    "href": "getting-started.html",
-    "summary": "Getting Started Prerequisites: Node.js 18 or newer and pnpm installed. Install dependencies: pnpm install Run the Vite dev server: pnpm dev - Open the printed URL (usually http://localhost:5173 ). Use index.html for sandbox scenes. Run test...",
-    "content": "Getting Started Prerequisites: Node.js 18 or newer and pnpm installed. Install dependencies: pnpm install Run the Vite dev server: pnpm dev - Open the printed URL (usually http://localhost:5173 ). Use index.html for sandbox scenes. Run tests: pnpm test Live testing while editing (Node): pnpm liveTesting"
-  },
-  {
-    "title": "Highlights",
-    "href": "highlights.html",
-    "summary": "Highlights Feature history pipeline with a compact UI to add, edit, and replay features. Robust CSG powered by manifold-3d with face-label provenance that survives booleans. Mesh-to-BREP conversion groups triangles into faces using normal d...",
-    "content": "Highlights Feature history pipeline with a compact UI to add, edit, and replay features. Robust CSG powered by manifold-3d with face-label provenance that survives booleans. Mesh-to-BREP conversion groups triangles into faces using normal deflection so selections make sense. Mesh repair pipeline includes weld, T-junction fix, overlap removal, hole fill, and normal cleanup. Import and export support STL, OBJ, and feature-aware 3MF (with embedded history). Primitive solids (cube, sphere, cylinder, cone, torus, pyramid) and common CAD features (sketch/extrude, sweep, loft, revolve, fillet, chamfer, mirror, booleans). Modular toolbar with Save, Zoom to Fit, Wireframe toggle, Import/Export, About, and Selection Filter access. Browser test runner captures per-test canvas snapshots and shows them in the log dialog. Simple plugin system lets you import plugins from GitHub repositories."
-  },
-  {
-    "title": "History Systems",
-    "href": "history-systems.html",
-    "summary": "History Systems BREP keeps several independent “history” timelines so modeling, PMI, and assembly constraint editing can all replay their steps deterministically. Each history owns the data it needs to recompute results but follows a shared...",
-    "content": "History Systems BREP keeps several independent “history” timelines so modeling, PMI, and assembly constraint editing can all replay their steps deterministically. Each history owns the data it needs to recompute results but follows a shared pattern: store a list of entries, redo work by iterating through that list, and serialize just the declarative inputs plus any persistent outputs. Shared building blocks ListEntityBase ( src/core/entities/ListEntityBase.js ) standardizes the three buckets found across every history entry: inputParams (user-editable data), persistentData (saved outputs), and runtimeAttributes (ephemeral session state). HistoryCollectionBase ( src/core/entities/HistoryCollectionBase.js ) provides the minimal scaffolding for history managers: it keeps the entries array, an entityClassRegistry , listener bookkeeping, and a monotonically increasing _idCounter . PMI annotations inherit from this base directly, while the other histories implement the same shape manually for flexibility. Registries translate user-facing strings into constructors. Modeling relies on FeatureRegistry , PMI uses AnnotationRegistry , and assembly uses AssemblyConstraintRegistry . Every registry exposes tolerant lookups ( getSafe ) so importing legacy files or plugins does not blow up the run loop. Each history exposes toSerializable / toJSON style helpers that deep-clone fields suitable for storage (3MF metadata, .BREP.json dumps, etc.) and matching load/replace helpers so the UI can restore state without bespoke glue. Part History (Modeling) PartHistory ( src/PartHistory.js:20 ) is the backbone of modeling mode. It wires together the feature registry, the shared Three.js scene, PMI views, metadata, and the assembly constraint history. Constructor duties include initializing features , scene , registries, PMIViewsManager , and a default expression scratchpad ( src/PartHistory.js:20-38 ). The class also injects a soft override on scene.add/remove so debugging geometry churn is possible. runHistory() iterates over features , lazily instantiates the correct feature class, sanitizes inputs, tracks “dirty” state, runs the feature, and records timestamps plus error metadata ( src/PartHistory.js:120-280 ). Clearing happens up front so each rerun rebuilds the scene from a clean slate. newFeature() allocates the declarative entry object { type, inputParams, persistentData } , seeds defaults via extractDefaultValues , and assigns a unique id produced by generateId() ( src/PartHistory.js:642-654 ). sanitizeInputParams() later evaluates expressions, resolves reference selections back into live scene objects, and normalizes booleans, vectors, transforms, or boolean-operation payloads ( src/PartHistory.js:665-758 ). Dialog field types, defaults, and selection filters come from each entry’s inputParamsSchema ; see Input Params Schema for every widget option. toJSON() exports the bare inputs for every feature, expression code, PMI views, metadata, and a snapshot of the assembly constraint history ( src/PartHistory.js:426-455 ). fromJSON() performs the inverse and forwards constraint payloads into AssemblyConstraintHistory.replaceAll() so the solver can pick up where it left off ( src/PartHistory.js:457-478 ). File manager save/load uses the JSON helper to embed the complete part history (including PMI and constraints) inside a 3MF metadata entry ( src/UI/fileManagerWidget.js:248-320 ), ensuring a single file captures all three timelines. PMI Annotation History PMI mode keeps its own list of annotations per saved PMI view. AnnotationHistory ( src/UI/pmi/AnnotationHistory.js:9 ) extends HistoryCollectionBase so it inherits the listener set, _idCounter , and serializable entry helpers. On construction, it registers every available annotation handler with the underlying registry and remembers the active PMIMode viewer ( src/UI/pmi/AnnotationHistory.js:9-20 ). PMIMode wires this up whenever a PMI view is opened so annotation changes stay scoped to that view ( src/UI/pmi/PMIMode.js:66-88 ). load() and toSerializable() deep-clone the stored annotation descriptors, strip runtime-only flags (like accordion open state), and keep the declarative input payloads tiny for 3MF persistence ( src/UI/pmi/AnnotationHistory.js:23-55 ). createAnnotation() looks up the handler via AnnotationRegistry , merges schema defaults with the caller-provided seed, assigns a generated ID, and marks runtime flags like __open or enabled ( src/UI/pmi/AnnotationHistory.js:95-129 ). Because annotations subclass ListEntityBase , they expose a run() method that PMIMode calls when rebuilding temporary geometry, but only their inputs/persistent data get serialized. Helpers such as setAnnotationEnabled() , moveUp()/moveDown() , and clear() are thin wrappers around entries mutations that also emit listener events to refresh the PMI widget ( src/UI/pmi/AnnotationHistory.js:84-159 ). Assembly Constraint History AssemblyConstraintHistory ( src/assemblyConstraints/AssemblyConstraintHistory.js:168-188 ) mirrors the modeling history but focuses on constraint records and solver execution. The constructor receives the owning PartHistory plus a registry and sets up arrays, listeners, and auto-run bookkeeping. Internally it normalizes constraint IDs, links runtime attributes (open state, entity references), and keeps constraintClass pointers on each entry so the solver can call static helpers like applyParams . snapshot() and replaceAll() provide the serialization surface. snapshot() deep-clones type , inputParams , and persistentData so PartHistory.toJSON() can embed the full constraint set ( src/assemblyConstraints/AssemblyConstraintHistory.js:512-546 ). replaceAll() rebuilds the constraints array from imported JSON, copies schema defaults, rehydrates runtime links, and rebuilds the ID counter before notifying listeners ( src/assemblyConstraints/AssemblyConstraintHistory.js:512-620 ). generateId() encodes the constraint type into the prefix (e.g., DISTANCE1 ) so UI rows remain human-readable even after reordering ( src/assemblyConstraints/AssemblyConstraintHistory.js:741-748 ). runAll() is the high-level solver. It pulls the active PartHistory , crawls the scene to resolve constraint selections, applies translation/rotation corrections with configurable gains, and emits viewer render hooks for debugging ( src/assemblyConstraints/AssemblyConstraintHistory.js:749-860 ). The helper integrates with controller hooks so UI widgets can report progress or cancel iterations. Error checking ( checkConstraintErrors() ), duplicate detection, and auto-run scheduling keep the timeline responsive; listener callbacks keep the assembly constraint widget UI synchronized whenever entries change. Using the histories together Part history is the orchestrator: it owns the Three.js scene and instantiates both PMI and assembly histories. Each PMI view stores a serialized annotation history entry, and every part export bundles feature inputs + annotation descriptors + constraint graph. Because all three systems follow the same entry/persistent-data conventions, plugins or new tools can treat them uniformly—populate inputParams , call the relevant history manager, and rely on the shared JSON helpers to persist the result."
-  },
-  {
-    "title": "How It Works",
-    "href": "how-it-works.html",
-    "summary": "How It Works Solid authoring uses flat arrays for triangles and per-triangle face labels. Windings are made consistent and orientation is fixed by signed volume before building a Manifold. manifold-3d produces robust manifold meshes while p...",
-    "content": "How It Works Solid authoring uses flat arrays for triangles and per-triangle face labels. Windings are made consistent and orientation is fixed by signed volume before building a Manifold. manifold-3d produces robust manifold meshes while propagating face IDs through CSG, keeping selections stable after unions, differences, and intersections. Faces and edges are visualized with Three.js helpers. Face names remain accessible for downstream feature logic and PMI annotations."
-  },
-  {
-    "title": "[BREP](https://github.com/mmiscool/BREP)",
-    "href": "index.html",
-    "summary": "BREP Source repo https://github.com/mmiscool/BREP A feature-based modeling playground experimenting with BREP-style workflows on top of triangle meshes. It combines robust manifold CSG (via the Manifold library) with a simple face and edge....",
-    "content": "BREP Source repo https://github.com/mmiscool/BREP A feature-based modeling playground experimenting with BREP-style workflows on top of triangle meshes. It combines robust manifold CSG (via the Manifold library) with a simple face and edge representation, a history pipeline, and Three.js visualization. Import meshes (STL), repair and group them into faces, then perform boolean operations, fillets, chamfers, sweeps, lofts, and more. This project is actively evolving; expect rough edges while APIs settle. Documentation Map Highlights What's New Getting Started UI Overview (Browser) How It Works History Systems Input Params Schema BREP Model and Classes BREP API (BREP.js exports) BREP Kernel (core classes & helpers) File Formats: Import and Export Plugins and Examples Recent Inspector Improvements Inspector Dialog Screenshots See Dialog Screenshots for the capture helpers, output locations, and configuration options. Run Local Dev Environment # clone repo and cd to the folder pnpm install pnpm dev Produce Static build # clone repo and cd to the folder pnpm install pnpm build Generating a static build will create a dist folder containing a static build suitable for hosting on a CDN or just being copied to a web server. Application Mode Guides Modeling Mode Sketch Mode PMI Mode Assembly Constraint Solver Modeling Features Primitive Cube — Implemented Primitive Cylinder — Implemented Primitive Cone — Implemented Primitive Sphere — Implemented Primitive Torus — Implemented Primitive Pyramid — Implemented Plane — Implemented Datum — Implemented Sketch — Implemented Helix — Implemented Extrude — Implemented Sweep — Implemented Tube — Implemented Loft — Implemented Revolve — Implemented Mirror — Implemented Boolean — Implemented Fillet — Implemented Chamfer — Implemented Hole — Implemented Offset Shell — Implemented Remesh — Implemented Import 3D Model (STL or 3MF) — Implemented Image Heightmap Solid — Implemented Image to Face (image trace) — Implemented Transform (move, rotate, scale) — Implemented Pattern Linear — Implemented Pattern Radial — Implemented Pattern (legacy combined) — Implemented Assembly Component — Implemented Sheet Metal Tab — Implemented Sheet Metal Contour Flange — Implemented Sheet Metal Flange — Implemented Assembly Constraints Assemblies can be constrained with the iterative solver described in Assembly Constraint Solver . Each constraint instance stores clear selections plus persistent solve data so runs resume quickly after edits. The constraint registry currently ships with: Coincident – mates two datum points or implicit origins. Distance – fixes an offset between reference points along a chosen axis or free space. Angle – enforces a target angle between two axes or faces. Parallel – locks component axes or normals into parallel alignment. Touch Align – slides surfaces until they touch and optionally shares tangency. Fixed – anchors a component so downstream constraints treat it as immobile. Adding, removing, or editing any of these entries queues an automatic background solve, and the UI exposes constraint status plus debugging messages pulled from each persistentData record. PMI annotations PMI mode focuses on downstream manufacturing communication. Annotating the model augments the saved .brep history and the embedded 3MF metadata. The PMI tools mirror the dialog capture pages in docs/pmi-annotations : Linear Dimension – measures distances between vertices with alignment, offsets, and extension controls. Radial Dimension – reports diameter/radius for arcs, circles, and cylinders. Angle Dimension – dimension angular relationships across edges or faces. Leader – callouts with free-form text, arrowhead placement, and captured drag offsets. Note – rich-text style annotations tied to PMI views without leader geometry. Explode Body – stores exploded-view offsets per component for presentation layouts. Hole Callout – leader-style callout that reports hole feature parameters (diameters, depths, countersink/counterbore). Each annotation stores associative references and view metadata so reloading a part restores the PMI viewport, label placement, and formatting settings. Using as an npm package (not completed yet. Will change and is not currently working) Install: - pnpm add brep-io-kernel Import options: - import { BREP, PartHistory } from 'brep-io-kernel'; - import { BREP } from 'brep-io-kernel/BREP'; - import { PartHistory } from 'brep-io-kernel/PartHistory'; - import { AssemblyConstraintHistory, AssemblyConstraintRegistry } from 'brep-io-kernel'; License See LICENSE.md . This project uses a dual-licensing strategy managed by Autodrop3d LLC. Contributing See CONTRIBUTING.md for guidelines on submitting pull requests, reporting issues, and participating in discussions. Documentation Angle Constraint Coincident Constraint Distance Constraint Fixed Constraint Parallel Constraint Assembly Constraint Solver Touch Align Constraint BREP.js Export Map and Usage BREP Kernel Reference BREP Model and Classes CONTRIBUTING Cylindrical Face Radius Embedding Dialog Screenshots Radius Metadata for Extruded Sketches Assembly Component Boolean Chamfer Datium Datum Extrude Fillet Helix Hole Image Heightmap Solid Image to Face Import 3D Model Features Loft Mirror Offset Shell Pattern Linear Pattern Radial Pattern (Legacy) Plane Primitive Cone Primitive Cube Primitive Cylinder Primitive Pyramid Primitive Sphere Primitive Torus Remesh Revolve Sheet Metal Contour Flange Sheet Metal Flange Sheet Metal Tab Sketch Spline Sweep Transform Tube Feature File Formats: Import and Export Getting Started Highlights History Systems How It Works Input Params Schema Recent Inspector Improvements Inspector LICENSE Modeling Mode PMI Mode Sketch Mode Plugins and Examples Angle Dimension Explode Body (View Transform) Hole Callout PMI Annotations Leader Linear Dimension Note Radial Dimension Simplified Radial Dimension Interface Solid Methods Reference UI Overview (Browser) What's New This project's license Copyright 2026 Autodrop3d LLC https://autodrop3d.com Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. Licenses Report of libraries used in this package 55 packages • 9 license types (MIT AND Zlib) 1 package pako 1 version zlib port to javascript - fast, modularized, with browser support Repo / Homepage (MIT OR GPL-3.0-or-later) 1 package jszip 1 version Create, read and edit .zip files with JavaScript http://stuartk.com/jszip Author: Stuart Knightley Repo / Homepage (MPL-2.0 OR Apache-2.0) 1 package dompurify 1 version DOMPurify is a DOM-only, super-fast, uber-tolerant XSS sanitizer for HTML, MathML and SVG. It's written in JavaScript and works in all modern browsers (Safari, Opera (15+), Internet Explorer (10+), Firefox and Chrome - as well as almost anything else using Blink or WebKit). DOMPurify is written by security people who have vast background in web attacks and XSS. Fear not. Author: Dr.-Ing. Mario Heiderich, Cure53 Repo / Homepage Apache-2.0 5 packages @img/sharp-linux-x64 1 version Prebuilt sharp for use with Linux (glibc) x64 Author: Lovell Fuller Repo / Homepage @img/sharp-linuxmusl-x64 1 version Prebuilt sharp for use with Linux (musl) x64 Author: Lovell Fuller Repo / Homepage detect-libc 1 version Node.js module to detect the C standard library (libc) implementation family and version Author: Lovell Fuller Repo / Homepage manifold-3d 1 version Geometry library for topological robustness Repo / Homepage sharp 1 version High performance Node.js image processing, the fastest module to resize JPEG, PNG, WebP, GIF, AVIF and TIFF images Author: Lovell Fuller Repo / Homepage bsd-2-clause 1 package esbuild-plugin-text-replace 1 version Replace Text with Regex in files before bundling. Author: Andreas Heissenberger Repo / Homepage ISC 2 packages inherits 1 version Browser-friendly inheritance fully compatible with standard node.js inherits() Repo / Homepage semver 1 version The semantic version parser used by npm. Author: GitHub Inc. Repo / Homepage LGPL-3.0-or-later 2 packages @img/sharp-libvips-linux-x64 1 version Prebuilt libvips and dependencies for use with sharp on Linux (glibc) x64 Author: Lovell Fuller Repo / Homepage @img/sharp-libvips-linuxmusl-x64 1 version Prebuilt libvips and dependencies for use with sharp on Linux (musl) x64 Author: Lovell Fuller Repo / Homepage MIT 41 packages @gltf-transform/core 1 version glTF 2.0 SDK for JavaScript and TypeScript, on Web and Node.js. Author: Don McCurdy Repo / Homepage @gltf-transform/extensions 1 version Adds extension support to @gltf-transform/core Author: Don McCurdy Repo / Homepage @gltf-transform/functions 1 version Functions for common glTF modifications, written using the core API Author: Don McCurdy Repo / Homepage @img/colour 1 version The ESM-only 'color' package made compatible for use with CommonJS runtimes Repo / Homepage @jridgewell/resolve-uri 1 version Resolve a URI relative to an optional base URI Author: Justin Ridgewell Repo / Homepage @jridgewell/sourcemap-codec 1 version Encode/decode sourcemap mappings Author: Justin Ridgewell Repo / Homepage @jridgewell/trace-mapping 1 version Trace the original position through a source map Author: Justin Ridgewell Repo / Homepage @jscadui/3mf-export 1 version 3mf export @tarikjabiri/dxf 1 version A JavaScript interface to Dxf written in TypeScript. Author: Tarik EL JABIRI Repo / Homepage @types/ndarray 1 version TypeScript definitions for ndarray Repo / Homepage @types/trusted-types 1 version TypeScript definitions for trusted-types Repo / Homepage commander 1 version the complete solution for node.js command-line programs Author: TJ Holowaychuk Repo / Homepage convert-source-map 1 version Converts a source-map from/to different formats and allows adding/changing properties. Author: Thorsten Lorenz Repo / Homepage core-js 1 version Standard library Author: Denis Pushkarev Repo / Homepage core-util-is 1 version The `util.is*` functions introduced in Node v0.12. Author: Isaac Z. Schlueter Repo / Homepage cwise-compiler 1 version cwise's internal compiler Author: Mikola Lysenko Repo / Homepage esbuild-wasm 1 version The cross-platform WebAssembly binary for esbuild, a JavaScript bundler. Repo / Homepage fflate 1 version High performance (de)compression in an 8kB package Author: Arjun Barrett Repo / Homepage immediate 1 version A cross browser microtask library Repo / Homepage iota-array 1 version Generates an array of consecutive integers starting at 0 Author: Mikola Lysenko Repo / Homepage is-buffer 1 version Determine if an object is a Buffer Author: Feross Aboukhadijeh Repo / Homepage isarray 1 version Array#isArray for older browsers Author: Julian Gruber Repo / Homepage ktx-parse 1 version KTX 2.0 (.ktx2) parser and serializer. Author: Don McCurdy Repo / Homepage lie 1 version A basic but performant promise implementation Repo / Homepage marked 1 version A markdown parser built for speed Author: Christopher Jeffrey Repo / Homepage monaco-editor 1 version A browser based code editor Author: Microsoft Corporation Repo / Homepage ndarray 1 version Multidimensional Arrays Author: Mikola Lysenko Repo / Homepage ndarray-lanczos 1 version Resize an ndarray with Lanczos resampling Author: Don McCurdy Repo / Homepage ndarray-ops 1 version Common operations for ndarray arrays Author: Mikola Lysenko Repo / Homepage ndarray-pixels 1 version ndarray-pixels Author: Don McCurdy Repo / Homepage process-nextick-args 1 version process.nextTick but always with args Repo / Homepage property-graph 1 version Base for creating objects that behave like a Property Graph. Author: Don McCurdy Repo / Homepage readable-stream 1 version Streams3, a user-land copy of the stream library from Node.js Repo / Homepage safe-buffer 1 version Safer Node.js Buffer API Author: Feross Aboukhadijeh Repo / Homepage setimmediate 1 version A shim for the setImmediate efficient script yielding API Author: YuzuJS Repo / Homepage string_decoder 1 version The string_decoder module from Node core Repo / Homepage three 1 version JavaScript 3D library Author: mrdoob Repo / Homepage three-mesh-bvh 1 version A BVH implementation to speed up raycasting against three.js meshes. Author: Garrett Johnson Repo / Homepage ts-replace-all 1 version Repo / Homepage uniq 1 version Removes duplicates from a sorted array in place Author: Mikola Lysenko Repo / Homepage util-deprecate 1 version The Node.js `util.deprecate()` function with browser support Author: Nathan Rajlich Repo / Homepage SGI-B-2.0 1 package tess2 1 version GLU tesselator ported to Javascript, performs polygon boolean operations and triangulation Author: Matt DesLauriers Repo / Homepage Generated from pnpm licenses list --prod --long --json"
-  },
-  {
-    "title": "Input Params Schema",
-    "href": "input-params-schema.html",
-    "summary": "Input Params Schema Feature, PMI annotation, and assembly constraint dialogs are rendered from an inputParamsSchema object by SchemaForm ( src/UI/featureDialogs.js ). Each key in the schema corresponds to a param entry; the widget type and....",
-    "content": "Input Params Schema Feature, PMI annotation, and assembly constraint dialogs are rendered from an inputParamsSchema object by SchemaForm ( src/UI/featureDialogs.js ). Each key in the schema corresponds to a param entry; the widget type and its options are driven by the definition object. js const inputParamsSchema = { distance: { type: 'number', label: 'Distance', default_value: 10, // Optional step: 0.1, // Optional min: 0, // Optional }, profile: { type: 'reference_selection', label: 'Profile', selectionFilter: ['FACE', 'SKETCH'], multiple: false, // Optional }, }; SchemaForm clones default_value when seeding params ; when a default is omitted it falls back to false for booleans, '' for most text/select fields, null for single reference selections, { position:[0,0,0], rotationEuler:[0,0,0], scale:[1,1,1] } for transforms, and [0,0,0] for vec3. Keys id and featureID are reserved and not rendered. You can override rendering with renderWidget or widgetRenderer (a function that receives { ui, key, def, id, controlWrap, row } ). PMI annotations also honor defaultResolver({ pmimode, handler }) for dynamic defaults. Selection filters for references reference_selection widgets call SelectionFilter.SetSelectionTypes(def.selectionFilter) . Valid tokens come from SelectionFilter.TYPES : SOLID , COMPONENT , FACE , PLANE , SKETCH , EDGE , LOOP , VERTEX , or ALL (to allow any scene pick). Widget types string Required: type: 'string' , label Optional: default_value , hint Behavior: single-line text box. Example: js title: { type: 'string', label: 'Title', default_value: 'My feature', // Optional hint: 'Shown in the tree', // Optional } textarea Required: type: 'textarea' , label Optional: default_value , hint , rows , placeholder Behavior: multi-line text area with optional placeholder. Example: js note: { type: 'textarea', label: 'Note', rows: 3, // Optional placeholder: 'Enter notes…', // Optional } number Required: type: 'number' , label Optional: default_value , hint , step , min , max Behavior: numeric input that flips to text when the value looks like an expression. Example: js distance: { type: 'number', label: 'Distance', default_value: 5, // Optional step: 0.01, // Optional min: 0, // Optional max: 100, // Optional } boolean Required: type: 'boolean' , label Optional: default_value , hint Behavior: checkbox storing a boolean. Example: js copy: { type: 'boolean', label: 'Create copy', default_value: false, // Optional hint: 'Duplicates instead of replacing', // Optional } options Required: type: 'options' , label , options (array of string values) Optional: default_value , hint Behavior: <select> with provided options; stored value is the selected string. Example: js mode: { type: 'options', label: 'Space', options: ['WORLD', 'LOCAL'], default_value: 'WORLD', // Optional hint: 'Choose frame', // Optional } reference_selection Required: type: 'reference_selection' , label , selectionFilter (see tokens above) Optional: default_value , hint , multiple , minSelections , maxSelections , placeholder Behavior: single-select shows a button with clear control; multi-select shows chips plus a hidden input. Values are normalized reference names; multi-select stores an array. minSelections / maxSelections enforce counts when chips render. Example: js profile: { type: 'reference_selection', label: 'Profile', selectionFilter: ['FACE', 'SKETCH'], multiple: false, // Optional default_value: null, // Optional hint: 'Pick a face or sketch', // Optional placeholder: 'Click then pick…', // Optional }, targets: { type: 'reference_selection', label: 'Targets', selectionFilter: ['SOLID'], multiple: true, // Optional minSelections: 1, // Optional maxSelections: 4, // Optional default_value: [], // Optional placeholder: 'Pick solids…', // Optional hint: 'Set boolean targets', // Optional } transform Required: type: 'transform' , label Optional: default_value , hint Behavior: launches the transform gizmo plus numeric grid. Value shape { position:[x,y,z], rotationEuler:[rx,ry,rz], scale:[sx,sy,sz] } . Example: js transform: { type: 'transform', label: 'Placement', hint: 'Use the gizmo', // Optional default_value: { position: [0, 0, 0], rotationEuler: [0, 0, 0], scale: [1, 1, 1], }, // Optional } vec3 Required: type: 'vec3' , label Optional: default_value , hint , step , uniformToggle , uniformDefault , uniformLockLabel Behavior: three-number row; when uniformToggle is true a checkbox can lock all three values together. Example: js scale: { type: 'vec3', label: 'Scale', default_value: [1, 1, 1], // Optional step: 0.1, // Optional uniformToggle: true, // Optional uniformDefault: true, // Optional uniformLockLabel: 'Uniform scale', // Optional hint: 'Set per-axis scale', // Optional } boolean_operation Required: type: 'boolean_operation' , label Optional: default_value (expects { targets: [], operation: 'NONE' } ), options (operation list), hint Behavior: dropdown of operations plus a multi-reference chip list fixed to SOLID selection filtering. Example: js boolean: { type: 'boolean_operation', label: 'Boolean', default_value: { targets: [], operation: 'NONE' }, // Optional options: ['NONE', 'UNION', 'SUBTRACT', 'INTERSECT'], // Optional hint: 'Apply a CSG operation', // Optional } file Required: type: 'file' , label Optional: hint , accept Behavior: hidden <input type=\"file\"> paired with a trigger button; selected file is stored as a data URL. accept is forwarded to the file input. Example: js texture: { type: 'file', label: 'Pick image…', accept: '.png,image/png', // Optional hint: 'PNG files only', // Optional } button Required: type: 'button' , label Optional: hint , actionFunction(ctx) Behavior: no value is stored; clicking runs actionFunction (receives { featureID, key, viewer, partHistory, feature, params, schemaDef } ) or falls back to onAction supplied to SchemaForm . Example: js preview: { type: 'button', label: 'Preview', hint: 'Run without saving', // Optional actionFunction: ({ feature }) => feature?.rerun?.(), // Optional } component_selector Required: type: 'component_selector' , label Optional: hint , buttonLabel , dialogTitle , onSelect(ctx, record) Behavior: opens the component library modal and writes the chosen component name into the param; onSelect can stash extra payload (see AssemblyComponentFeature ). Example: js componentName: { type: 'component_selector', label: 'Component', buttonLabel: 'Select…', // Optional dialogTitle: 'Select Component', // Optional onSelect: (ctx, record) => handleSelection(ctx, record), // Optional hint: 'Pull from component library', // Optional } fallback Any unknown type (or omitted type ) renders a plain text input via renderDefaultField . Use this for quick string fields or to prototype a custom widget before registering one."
-  },
-  {
-    "title": "Recent Inspector Improvements",
-    "href": "inspector-improvements.html",
-    "summary": "Recent Inspector Improvements Face area display shows surface area with formatted units. Edge length measurement reports lengths with formatted units. Objects display the owning feature ( Created by: FeatureID ). Lazy loading defers heavy t...",
-    "content": "Recent Inspector Improvements Face area display shows surface area with formatted units. Edge length measurement reports lengths with formatted units. Objects display the owning feature ( Created by: FeatureID ). Lazy loading defers heavy triangle and point data until the section expands, improving performance on complex models. Inspector sections for triangles, vertices, and points expand on demand to avoid freezing the UI."
-  },
-  {
-    "title": "Inspector",
-    "href": "inspector.html",
-    "summary": "Inspector The Inspector is a diagnostic window for answering “What exactly did I just click?” . It is meant for troubleshooting mesh issues, confirming the owning feature of a face, or exporting precise coordinates for support requests. The...",
-    "content": "Inspector The Inspector is a diagnostic window for answering “What exactly did I just click?” . It is meant for troubleshooting mesh issues, confirming the owning feature of a face, or exporting precise coordinates for support requests. The 🧪 button on the main toolbar toggles the panel. The window floats near the lower-left corner, can be dragged or resized, and stays on top of the viewport so you can keep modeling. When the panel opens it shows a placeholder message. Click any entity in the scene (face, edge, or solid) and the Inspector immediately refreshes with the latest selection. The header contains Download JSON for a full dump of the current payload (including data that is truncated in the UI) and Hide to close the window without clearing the cached selection. Reading the panel Each selection is rendered with the Object Inspector tree component, so you can: Expand or collapse sections, or use the search box to filter by key/path. Copy the visible JSON or download a complete copy for offline debugging. Watch for formatted helpers such as Created by: FeatureID , 123 units² , or 123 units at the top level for quick glances. > Many expensive sections (triangles, points, vertex lists) are lazily computed and only fetched when you expand them. When a preview lists “Truncated”, click Download JSON to export everything. Data per selection type Faces Triangles – summarized counts with normals and areas. Expanding streams a capped list for UI safety; the download contains the entire face mesh. Edges – the loops bordering the face, including whether an edge is a closed loop, its approximate length, and the names of neighboring faces. Unique vertices – lazily generated set of world-space coordinates extracted from the triangle list. Metrics – formatted surface area, average normal, bounding-box preview, and the owning feature id when available. Neighbors and boundary loops – lists of adjacent faces plus optional hole/outer-loop polygons supplied by face metadata. Edges Length + closure – precise length read via the edge object plus a closedLoop flag when the edge wraps on itself. Adjacent faces – the names (or ids) of touching faces, useful when debugging history or PMI layers. Sample points – world-space polylines used to draw the edge, fetched only when the section expands. Solids Face roster – first 10 faces with their triangle counts plus a total count so you can spot unexpectedly dense solids. Mesh stats – vertex count, triangle count, and the source of the data (either Manifold’s mesh or the authoring arrays). Bounding boxes are computed from the raw vertex positions. Triangle preview – capped list of triangle data (indices, positions, normals, owning face id/name) with lazy evaluation; the download button produces the full, uncapped dataset. Topology diagnostics – manifold/boundary checks that report degenerate triangles, edges used by fewer or more than two faces, and isolated vertices so you can locate bad imports. Volume & surface area – when the underlying SOLID exposes volume() or surfaceArea() the panel surfaces the numeric values for quick measurements. Usage tips Keep the Inspector open while modeling; every click refreshes instantly, so you can inspect multiple faces without re-opening the window. Use the panel in tandem with the Selection Filter to temporarily expose PMI references, sketches, or assembly items and confirm their metadata. When reporting an issue, include the JSON downloaded from the Inspector so maintainers receive the same diagnostic snapshot you saw in the UI."
-  },
-  {
-    "title": "LICENSE",
-    "href": "LICENSE.html",
-    "summary": "Copyright 2026 Autodrop3d LLC https://autodrop3d.com Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restrict...",
-    "content": "Copyright 2026 Autodrop3d LLC https://autodrop3d.com Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE."
-  },
-  {
-    "title": "Modeling Mode",
-    "href": "modes__modeling.html",
-    "summary": "Modeling Mode Modeling Mode is the default workspace for solid construction. The scene shows the active history tree, 3D viewport, and main toolbar controls. Add primitives, booleans, and editing features to the timeline, then drag or edit....",
-    "content": "Modeling Mode Modeling Mode is the default workspace for solid construction. The scene shows the active history tree, 3D viewport, and main toolbar controls. Add primitives, booleans, and editing features to the timeline, then drag or edit them to re-run the part. Selection filters and gizmos in this mode operate directly on bodies, faces, and edges to drive feature inputs. Key tools: Main toolbar (Save, Zoom to Fit, Wireframe, Import/Export, About) Feature history panel for creating primitives, sketches, and operations Inspector for per-face metrics like area and owning feature Use Modeling Mode to position solids, apply patterns, and manage global transforms before switching to specialized modes."
-  },
-  {
-    "title": "PMI Mode",
-    "href": "modes__pmi.html",
-    "summary": "PMI Mode PMI (Product Manufacturing Information) Mode focuses on annotations, dimensions, and callouts. Activate it to place linear, radial, angular, and leader dimensions that communicate manufacturing intent without altering the underlyin...",
-    "content": "PMI Mode PMI (Product Manufacturing Information) Mode focuses on annotations, dimensions, and callouts. Activate it to place linear, radial, angular, and leader dimensions that communicate manufacturing intent without altering the underlying solid. Capabilities: Place linear, radial, and angular dimensions with associative snapping to faces or edges Add leader annotations that reference points, faces, or datums Configure formatting through the PMI inspector and label overlay panels Stage exploded views with view-specific transforms that leave the model untouched Export PMI views as labeled PNGs directly from the PMI Views panel Use PMI Mode after modeling is complete to capture critical tolerances, notes, and inspection data directly on the 3D model. Views and Export Capture a PMI view from the PMI Views panel to store the current camera, display settings, and its annotation list. Click Export Images in the same panel to render labeled PNGs for every saved view; the exporter replays each view, applies its stored annotations, and grabs a canvas snapshot for you. When you export a 3MF file, the view definitions ride along inside Metadata/featureHistory.json , and the generated PNGs are attached under /views/<view-name>.png in the archive so downstream tools can inspect or relink them. Annotation Library Linear Dimension Radial Dimension Angle Dimension Hole Callout Leader Note Explode Body (View Transform)"
-  },
-  {
-    "title": "Sketch Mode",
-    "href": "modes__sketch.html",
-    "summary": "Sketch Mode For complete documentation on Sketch functionality, workflow, and technical details, see: → Sketch Feature Documentation This page covers the complete Sketch feature including: Overview and workflow Input parameters and behavior...",
-    "content": "Sketch Mode For complete documentation on Sketch functionality, workflow, and technical details, see: → Sketch Feature Documentation This page covers the complete Sketch feature including: Overview and workflow Input parameters and behavior 2D sketching tools and constraints Integration with other features (Extrude, Revolve, Loft, Sweep) Tool icon legend (Unicode toolbar buttons) Recent Sketcher Additions Trim tool for line/arc/circle/Bezier editing with local intersection-based trimming Bezier editing improvements (insert points and construction guides) Under‑constrained point highlight and quick Fix/Unfix toggle in the context toolbar Orphan point cleanup button and auto‑cleanup option in Solver Settings"
-  },
-  {
-    "title": "Plugins and Examples",
-    "href": "plugins.html",
-    "summary": "Plugins and Examples Example plugin repository: https://github.com/mmiscool/BREPpluginExample Example plugin README: https://github.com/mmiscool/BREPpluginExample/blob/master/README.md Entrypoint: https://github.com/mmiscool/BREPpluginExamp...",
-    "content": "Plugins and Examples Example plugin repository: https://github.com/mmiscool/BREPpluginExample Example plugin README: https://github.com/mmiscool/BREPpluginExample/blob/master/README.md Entrypoint: https://github.com/mmiscool/BREPpluginExample/blob/master/plugin.js Feature example: https://github.com/mmiscool/BREPpluginExample/blob/master/exampleFeature.js Use the plugin system to extend BREP with custom features, toolbar buttons, or automation pipelines sourced from GitHub. When adding dialogs for your feature, follow the shared inputParamsSchema format described in Input Params Schema to pick field types, defaults, and reference-selection rules."
-  },
-  {
-    "title": "Angle Dimension",
-    "href": "pmi-annotations__angle-dimension.html",
-    "summary": "Angle Dimension Status: Implemented Angle dimensions measure the sweep between two faces or edges and display the result on the active PMI sheet. Use them for chamfers, draft checks, and assembly alignment callouts. Inputs annotationID – op...",
-    "content": "Angle Dimension Status: Implemented Angle dimensions measure the sweep between two faces or edges and display the result on the active PMI sheet. Use them for chamfers, draft checks, and assembly alignment callouts. Inputs annotationID – optional identifier retained in PMI exports. decimals – decimal precision; defaults to the PMI angleDecimals preference. elementARefName / elementBRefName – face or edge selections that define the angle. planeRefName – optional face or datum to override the projection plane. reverseElementOrder – flips the measured side when the automatic choice is not desired. angleType – choose acute , obtuse , or reflex sweep to control value formatting. isReference – encloses the output in parentheses and signals downstream reference handling. Behaviour Derives edge or face directions, constructs a local 2D basis, and draws an arc with adjustable radius. Arrowheads, witness lines, and arc radius scale in screen space to remain readable while zooming. Labels can be dragged; the world-space location is persisted and reused on reload. Responds to PMI formatting callbacks so custom units or tolerancing schemes propagate to the label text. Usage Tips Provide a projection plane when measuring between non-parallel faces to control which cross-section drives the angle. Toggle reverseElementOrder if the drawn arc lands on the wrong side of the intersection. Use the reflex option to call out angles greater than 180° without recomputing geometry."
-  },
-  {
-    "title": "Explode Body (View Transform)",
-    "href": "pmi-annotations__explode-body.html",
-    "summary": "Explode Body (View Transform) Status: Implemented Explode Body annotations reposition solids inside a PMI view without touching the master model. They are ideal for exploded assemblies, service manuals, and view-specific storyboards. Inputs...",
-    "content": "Explode Body (View Transform) Status: Implemented Explode Body annotations reposition solids inside a PMI view without touching the master model. They are ideal for exploded assemblies, service manuals, and view-specific storyboards. Inputs annotationID – optional persistent identifier. targets – one or more solid selections that will be repositioned. transform – translation and rotation applied to the selected solids; edited through the PMI transform gizmo. showTraceLine – toggles dashed trace lines from the original location to the displaced position. Behaviour Captures the original placement for every targeted solid and reapplies it automatically when you leave PMI mode. Composes successive edits so you can tweak the displacement without accumulating transform drift. Draws trace lines that update live as you drag the gizmo, helping viewers understand the exploded direction. Shares infrastructure with other PMI annotations, so undo/redo, history, and persistence all work consistently. Usage Tips Create separate Explode Body annotations per PMI view to stage unique assembly moments without impacting the base model. Toggle trace lines off for clean presentation shots or on to emphasize motion. Pair with leader or note annotations to explain the purpose of each displaced component."
-  },
-  {
-    "title": "Hole Callout",
-    "href": "pmi-annotations__hole-callout.html",
-    "summary": "Hole Callout Status: Implemented Creates a leader-style note that reports hole parameters from the hole feature. Inputs Target – Select a hole edge/vertex/face (or its stored centerline). The callout snaps to the specific hole the selection...",
-    "content": "Hole Callout Status: Implemented Creates a leader-style note that reports hole parameters from the hole feature. Inputs Target – Select a hole edge/vertex/face (or its stored centerline). The callout snaps to the specific hole the selection came from. Quantity – Optional “×” multiplier for identical holes. Anchor Position – Preferred label alignment. Display Uses the global PMI leader styling (line/arrow/dot sizes and colors). Shows core diameter and depth ( ↧ depth when not Through All, otherwise “THRU ALL”). For countersink: shows sink diameter and angle ⌵ ⌀D × A° . For counterbore: shows bore diameter and depth ⌴ ⌀D ↧ depth . Tips Holes carry metadata (center, normal, type, diameters, depths) from the Hole feature. Pick the actual hole geometry to bind the callout to that specific hole. Depth matches the Hole feature’s total depth; Through All skips depth text."
-  },
-  {
-    "title": "PMI Annotations",
-    "href": "pmi-annotations__index.html",
-    "summary": "PMI Annotations Reference docs for built-in PMI annotations. Leader Note Linear Dimension Radial Dimension Angle Dimension Hole Callout Explode Body",
-    "content": "PMI Annotations Reference docs for built-in PMI annotations. Leader Note Linear Dimension Radial Dimension Angle Dimension Hole Callout Explode Body"
-  },
-  {
-    "title": "Leader",
-    "href": "pmi-annotations__leader.html",
-    "summary": "Leader Status: Implemented Leader annotations attach custom text to one or more points, providing flexible callouts for notes, GD&T, or assembly instructions inside PMI mode. Inputs annotationID – optional identifier for downstream consumpt...",
-    "content": "Leader Status: Implemented Leader annotations attach custom text to one or more points, providing flexible callouts for notes, GD&T, or assembly instructions inside PMI mode. Inputs annotationID – optional identifier for downstream consumption. target – one or more vertex selections to anchor the leader. text – multiline body shown in the label; defaults to the PMI leaderText preference when provided. anchorPosition – preferred label alignment (Left/Right × Top/Middle/Bottom). endStyle – choose an arrow head or dot terminator for the leader tail. Behaviour Resolves the selected vertices, averages them, and builds approach lines that fan out vertically to avoid overlap. Shoulder length and arrow size scale with screen space for consistent visual weight. Labels are persisted in world space so your layout survives mode switches and document reloads. Text passes through PMI formatting hooks, enabling automatic reference tags or unit decorations. Usage Tips Use multiple targets to annotate bolt groups or pattern features with a single note. Switch the anchor position when the label overlaps other callouts; PMI reflows the leader shoulder automatically. Toggle to dot end style when calling out surface areas or datum points that do not require arrowheads."
-  },
-  {
-    "title": "Linear Dimension",
-    "href": "pmi-annotations__linear-dimension.html",
-    "summary": "Linear Dimension Status: Implemented Linear dimensions measure the distance between two vertices and project the result into the active PMI view. Use them to document edge-to-edge spacing and critical offsets without altering model geometry...",
-    "content": "Linear Dimension Status: Implemented Linear dimensions measure the distance between two vertices and project the result into the active PMI view. Use them to document edge-to-edge spacing and critical offsets without altering model geometry. Inputs annotationID – optional identifier stored with the PMI payload. decimals – decimal precision; defaults to the PMI mode dimDecimals preference. aRefName / bRefName – vertex references that define the measured span. planeRefName – optional face or datum plane that controls projection. alignment – lock the dimension to the view plane or one of the global axes (XY, YZ, ZX). offset – distance to shift the dimension line away from the measured span; dragged labels update this value automatically. showExt – toggle extension lines from anchors to the offset dimension line. isReference – wraps the display text in parentheses when set. Behaviour Distance is recomputed whenever anchor geometry updates; labels stay associative. Arrowheads and extension lines scale with screen distance so dimensions remain legible at any zoom. Labels can be dragged; the system captures the world position and extension offset for repeatable layouts. Dimensions respect PMI inspector formatting hooks such as formatReferenceLabel for dual-units or reference styling. Usage Tips Pick a projection plane when the default view alignment produces ambiguous results (e.g., angled faces). Use alignment = view with the PMI triad to quickly dimension sketch-like layouts, or axis alignment to match drawing standards. Combine with reference dimensions to communicate non-driving measurements without cluttering the model."
-  },
-  {
-    "title": "Note",
-    "href": "pmi-annotations__note.html",
-    "summary": "Note Status: Implemented Note annotations drop standalone text markers into a PMI view for general instructions, inspection checkpoints, or revision flags. Inputs annotationID – optional persistent identifier. text – single-line message; de...",
-    "content": "Note Status: Implemented Note annotations drop standalone text markers into a PMI view for general instructions, inspection checkpoints, or revision flags. Inputs annotationID – optional persistent identifier. text – single-line message; defaults to the PMI noteText preference. position – world-space coordinates of the note marker. Behaviour Renders a screen-space dot at the saved position and displays the note text as a floating label. Automatically offsets the label from the view normal so it remains legible; dragging the label stores a new world position. Plays nicely with PMI label formatting utilities, enabling consistent text styling across annotations. Usage Tips Use notes for freeform callouts that do not require geometry selection. Combine with leader annotations when you need both a persistent marker and directional leader text. Adjust the label placement by dragging once it appears to avoid overlapping other PMI elements."
-  },
-  {
-    "title": "Radial Dimension",
-    "href": "pmi-annotations__radial-dimension.html",
-    "summary": "Radial Dimension Status: Implemented Radial dimensions expose radii or diameters of cylindrical faces directly in PMI views. They support associative updates to revolved geometry, holes, and rounds. Inputs annotationID – optional persistent...",
-    "content": "Radial Dimension Status: Implemented Radial dimensions expose radii or diameters of cylindrical faces directly in PMI views. They support associative updates to revolved geometry, holes, and rounds. Inputs annotationID – optional persistent identifier. decimals – numeric precision; inherits the PMI mode dimDecimals setting when left blank. cylindricalFaceRef – cylindrical face reference used to extract the centerline and radius. planeRef – optional face or datum that defines the projection plane. displayStyle – choose radius or diameter output. alignment – align leader projection to the current view or a principal axis. offset – shifts the label outward from the cylindrical surface; dragging the label updates the stored offset. isReference – formats the value as a reference dimension. Behaviour Automatically computes center point, radial vector, and arrow geometry for both radius and diameter callouts. Maintains associative links to the source cylinder; machining edits update the PMI value on regen. Supports interactive label dragging on the projection plane while preserving trace lines and offsets. Center markers and arrows scale with screen space to stay readable while orbiting. Usage Tips Supply a projection plane when the default view produces misleading offsets, especially for angled holes. Use diameter display style ( Ø ) for holes and radius display ( R ) for fillets to match common drawing conventions. Pair with linear dimensions to fully define hole patterns and bolt circles in a single PMI view."
-  },
-  {
-    "title": "Simplified Radial Dimension Interface",
-    "href": "simplified-radial-dimensions.html",
-    "summary": "Simplified Radial Dimension Interface The radial dimension interface has been significantly simplified to take advantage of embedded radius metadata in cylindrical faces. Users now only need to select the cylindrical face itself, rather tha...",
-    "content": "Simplified Radial Dimension Interface The radial dimension interface has been significantly simplified to take advantage of embedded radius metadata in cylindrical faces. Users now only need to select the cylindrical face itself, rather than manually specifying center points and edges. New Interface Required Input Cylindrical Face : Select any cylindrical face (from primitives, extrusions, etc.) Optional Inputs Projection Plane : Optional face to define the drawing plane for the dimension Display Style : Choose between radius (R) or diameter (⌀) display Alignment : Control dimension orientation (view, XY, YZ, ZX) Offset : Adjust dimension line offset distance Decimals : Number of decimal places to display Reference : Mark as reference dimension (parentheses) Usage Examples Basic Cylindrical Face Selection javascript // Create a radial dimension const radialDim = RadialDimension.create(pmiMode); // Simply select the cylindrical face - that's it! radialDim.cylindricalFaceRef = 'MyCylinder_S'; radialDim.displayStyle = 'radius'; // or 'diameter' // The system automatically: // 1. Extracts radius from face metadata // 2. Determines cylinder center and axis // 3. Creates appropriate dimension geometry With Projection Plane javascript // For dimensions that need specific orientation radialDim.cylindricalFaceRef = 'MyCylinder_S'; radialDim.planeRef = 'WorkPlane_XY'; // Optional projection plane radialDim.displayStyle = 'diameter'; Benefits of the New Interface 1. Simplified Workflow Before : Select center point → Select edge/arc → Configure alignment After : Select cylindrical face → Done! 2. Automatic Precision Uses exact radius values from original geometry No approximation errors from triangle mesh sampling Consistent measurements regardless of mesh resolution 3. Intelligent Detection Automatically works with: - Primitive cylinders ( BREP.Cylinder ) - Extruded circular sketches - Revolved circular profiles - Boolean operation results 4. Robust Behavior Gracefully handles transformations (rotation, scaling, translation) Preserves accuracy through boolean operations Maintains metadata through complex modeling operations Supported Cylindrical Sources Primitive Cylinders javascript const cylinder = new BREP.Cylinder({ radius: 5.0, height: 10.0, name: 'Pipe' }); // Side face 'Pipe_S' automatically gets radius metadata Extruded Circles javascript const extruded = new BREP.ExtrudeSolid({ face: circularSketch, // Circle with radius 3.0 distance: 8.0 }); // Side wall gets cylindrical metadata with radius 3.0 Equal-Radius Cones javascript const cylinder = new BREP.Cone({ r1: 4.0, r2: 4.0, // Equal radii = cylindrical h: 12.0 }); // Treated as cylindrical face with radius 4.0 Technical Implementation Metadata Structure Cylindrical faces store this metadata: javascript { type: 'cylindrical', radius: 5.0, height: 10.0, axis: [0, 1, 0], // Unit vector along cylinder axis center: [0, 5.0, 0] // Center point of cylinder axis } Dimension Calculation Face Selection : User selects cylindrical face Metadata Lookup : System retrieves stored radius value Geometry Computation : Calculates center, axis, and surface points Projection : Applies any plane constraints or alignment rules Rendering : Draws dimension with exact radius value Fallback Behavior If metadata is not available (legacy geometry), the system automatically falls back to geometric calculation from triangle mesh, ensuring backward compatibility. Migration from Old Interface Old Schema (Deprecated) javascript { centerRef: 'CenterVertex', // ❌ No longer needed edgeRef: 'CircularEdge', // ❌ No longer needed planeRef: 'ProjectionFace', // ✓ Still optional // ... other settings } New Schema javascript { cylindricalFaceRef: 'Cylinder_S', // ✓ Simple face selection planeRef: 'ProjectionFace', // ✓ Optional projection plane // ... other settings (unchanged) } Error Handling Invalid Face Selection Non-cylindrical faces : Dimension creation fails gracefully Missing metadata : Falls back to geometric calculation Transformed geometry : Automatically applies transformations Missing References No cylindrical face : Shows error message in UI Invalid plane reference : Uses view alignment as fallback Corrupted metadata : Attempts geometric reconstruction Performance Benefits No geometric analysis : Direct metadata lookup vs mesh processing Reduced computation : Skip center/radius finding algorithms Faster updates : Dimension updates use cached metadata values Lower memory : No need to store intermediate geometric calculations Future Enhancements This simplified interface enables future improvements: Smart Face Detection : Auto-suggest cylindrical faces when tool is activated Multi-Radius Display : Show both inner/outer radii for thick cylinders Tolerance Integration : Display radius tolerances from design intent Parametric Updates : Dimensions update automatically when model changes"
-  },
-  {
-    "title": "Solid Methods Reference",
-    "href": "solid-methods.html",
-    "summary": "Solid Methods Reference Solid lives in src/BREP/BetterSolid.js and extends THREE.Group . Examples below assume: js import { Solid } from '../src/BREP/BetterSolid.js'; const solid = new Solid(); Lifecycle constructor() Initializes empty auth...",
-    "content": "Solid Methods Reference Solid lives in src/BREP/BetterSolid.js and extends THREE.Group . Examples below assume: js import { Solid } from '../src/BREP/BetterSolid.js'; const solid = new Solid(); Lifecycle constructor() Initializes empty authoring buffers, face/edge metadata maps, and flags the manifold cache as dirty. js const s = new Solid(); clone() Creates a lightweight copy of geometry, face/edge metadata, and aux edges (no THREE children or GPU resources). js const copy = solid.clone(); free() Disposes the cached Manifold instance to release wasm memory; the Solid remains usable and will rebuild on demand. js solid.free(); faces (getter) Ensures visualize() has run, then returns FACE children currently attached to the group. js const faceMeshes = solid.faces; Authoring addTriangle(faceName, v1, v2, v3) Appends a CCW triangle labeled with faceName ; vertices are uniqued by exact coordinates. js solid.addTriangle('TOP', [0, 0, 0], [1, 0, 0], [0, 1, 0]); _key([x, y, z]) Internal: builds the exact string key used for vertex deduplication. js const key = solid._key([0, 0, 0]); // \"0,0,0\" _getPointIndex(point) Internal: returns the existing vertex index or appends the point to the authoring buffer. js const idx = solid._getPointIndex([1, 2, 3]); _getOrCreateID(faceName) Internal: maps a face name to a globally unique Manifold ID, creating one if needed. js const faceId = solid._getOrCreateID('SIDE'); addAuxEdge(name, points, options) Stores a helper polyline (e.g., centerline) for visualization alongside the solid. js solid.addAuxEdge('CENTER', [[0, 0, 0], [0, 0, 5]], { closedLoop: false, // render as loop when true polylineWorld: false, // points already in world space? materialKey: 'OVERLAY' // visualization material tag }); addCenterline(a, b, name?, options?) Convenience wrapper that records a two‑point aux edge. js solid.addCenterline([0, 0, 0], [0, 0, 10], 'AXIS', { closedLoop: false, polylineWorld: false, materialKey: 'OVERLAY' }); Metadata setFaceMetadata(faceName, metadata) Attaches arbitrary metadata to a face label (merged if it already exists). js solid.setFaceMetadata('CYL_SIDE', { radius: 5, axis: [0, 0, 1] }); getFaceMetadata(faceName) Reads face metadata; returns {} when unset. js const data = solid.getFaceMetadata('CYL_SIDE'); getFaceNames() Lists all face labels present on the solid. js const names = solid.getFaceNames(); setEdgeMetadata(edgeName, metadata) / getEdgeMetadata(edgeName) Stores or reads metadata for boundary edges (used by PMI and downstream tooling). js solid.setEdgeMetadata('EDGE_A', { tag: 'reference' }); const edgeInfo = solid.getEdgeMetadata('EDGE_A'); _combineFaceMetadata(other) Internal: merges face metadata maps across solids (used during booleans). js const combined = solid._combineFaceMetadata(otherSolid); Transforms and offsets bakeTransform(matrix) Applies a THREE.Matrix4 to authored vertices and aux edges, rebuilding the vertex index map. js const m = new THREE.Matrix4().makeTranslation(0, 0, 10); solid.bakeTransform(m); bakeTRS(trs) Composes and bakes a transform from { t, rDeg, s } using composeTrsMatrixDeg . js solid.bakeTRS({ t: [0, 0, 10], rDeg: [0, 45, 0], s: [1, 1, 1] }); offsetFace(faceName, distance) Moves all vertices of a labeled face along its average normal by distance . js solid.offsetFace('TOP', 2.0); mirrorAcrossPlane(point, normal) Returns a mirrored clone across a plane defined by a point and normal. js const mirrored = solid.mirrorAcrossPlane([0, 0, 0], [1, 0, 0]); pushFace(faceName, distance) Translates a face along its outward normal using current triangle windings. js solid.pushFace('FRONT', 1.5); Manifold, orientation, and welding setEpsilon(epsilon) Sets weld tolerance and optionally welds existing vertices, then fixes triangle winding. js solid.setEpsilon(0.001); _weldVerticesByEpsilon(epsilon) Internal: welds vertices on a grid using epsilon , drops degenerate triangles, and marks dirty. js solid._weldVerticesByEpsilon(0.0005); fixTriangleWindingsByAdjacency() Ensures shared edges have opposite orientation so the mesh is coherently oriented. js solid.fixTriangleWindingsByAdjacency(); _isCoherentlyOrientedManifold() Checks whether every undirected edge is shared by two triangles with opposite directions. js const ok = solid._isCoherentlyOrientedManifold(); invertNormals() Flips all triangles (swaps indices 1 and 2) and rebuilds the manifold cache. js solid.invertNormals(); _manifoldize() Builds or returns the cached Manifold from authored arrays (fixes winding and orientation first). js const manifold = solid._manifoldize(); Mesh cleanup and refinement remesh({ maxEdgeLength, maxIterations }) Splits edges longer than maxEdgeLength , preserving face IDs, and fixes winding after changes. js solid.remesh({ maxEdgeLength: 5, // required threshold maxIterations: 2 // optional passes (default 10) }); removeSmallIslands({ maxTriangles, removeInternal, removeExternal }) Deletes small connected triangle components relative to the largest shell; returns count removed. js const removed = solid.removeSmallIslands({ maxTriangles: 20, // island size threshold removeInternal: true, // drop islands inside main shell removeExternal: true // drop islands outside main shell }); removeSmallInternalIslands(maxTriangles) Convenience wrapper removing only internal islands under the given triangle count. js solid.removeSmallInternalIslands(15); removeTinyBoundaryTriangles(areaThreshold, maxIterations?) Performs edge flips across inter-face boundaries to remove triangles below areaThreshold . js solid.removeTinyBoundaryTriangles(0.001, 3); collapseTinyTriangles(lengthThreshold) Collapses triangles whose shortest edge is below lengthThreshold , then cleans up via a bounding-box intersect; returns number of edge collapses. js const collapses = solid.collapseTinyTriangles(0.05); splitSelfIntersectingTriangles(diagnostics?) Detects intersecting triangle pairs and subdivides them in place while preserving face IDs; returns splits applied. js solid.splitSelfIntersectingTriangles(); removeDegenerateTriangles() Drops triangles with duplicate vertices or near-zero area; returns removed count. js const removed = solid.removeDegenerateTriangles(); removeInternalTriangles() Rebuilds authoring arrays from the manifold’s exterior surface, removing internal faces; returns removed count. js solid.removeInternalTriangles(); removeInternalTrianglesByRaycast() Uses centroid ray tests to cull triangles inside the solid without requiring manifoldization; returns removed count. js solid.removeInternalTrianglesByRaycast(); removeInternalTrianglesByWinding(options?) Uses solid-angle winding numbers at triangle centroids to delete interior triangles; returns removed count. js solid.removeInternalTrianglesByWinding({ offsetScale: 1e-4, // centroid offset relative to bbox diagonal crossingTolerance: 0.05 // tolerance for interior crossing test }); Queries and measurements getMesh() Returns a fresh MeshGL view ( { vertProperties, triVerts, faceID } ) from the cached manifold. js const mesh = solid.getMesh(); console.log(mesh.triVerts.length / 3, 'triangles'); mesh.delete?.(); // cleanup when finished _ensureFaceIndex() Internal: builds a cache mapping face IDs to triangle indices for fast lookups. js solid._ensureFaceIndex(); getFace(name) Returns the triangles for a face label with positions and indices. js const tris = solid.getFace('TOP'); getFaces(includeEmpty?) Enumerates all faces as { faceName, triangles } , optionally including faces with no triangles. js const faces = solid.getFaces(); getBoundaryEdgePolylines() Extracts boundary polylines between differing face labels. js const edges = solid.getBoundaryEdgePolylines(); getTriangleCount() Counts triangles in the current manifold mesh. js const triCount = solid.getTriangleCount(); volume() Computes absolute volume from the manifold mesh. js const vol = solid.volume(); surfaceArea() Computes total surface area from the manifold mesh. js const area = solid.surfaceArea(); Boolean and reconstruction helpers _combineIdMaps(other) Internal: merges face ID → name maps before constructing boolean results. js const mergedMap = solid._combineIdMaps(otherSolid); union(other) / subtract(other) / intersect(other) / difference(other) Runs the corresponding boolean CSG against other , returning a new Solid with merged face labels, metadata, and aux edges. The boolean result also collapses duplicate face IDs that share the same face name so boundaries are generated by label, not by stale IDs. js const united = solid.union(otherSolid); const cut = solid.subtract(toolSolid); const common = solid.intersect(otherSolid); const diff = solid.difference(otherSolid); // alias of subtract setTolerance(tolerance) Returns a new Solid built from Manifold.setTolerance(tolerance) to adjust robustness. js const tolerant = solid.setTolerance(0.02); simplify(tolerance?, updateInPlace?) Calls Manifold.simplify ; when updateInPlace is truthy the current solid is mutated, otherwise a new one is returned. js const simplified = solid.simplify(0.5); // new Solid solid.simplify(0.5, true); // mutate in place _expandTriIDsFromMesh(mesh) (static) Static helper that expands faceID on a MeshGL to a JS array, defaulting to zeros when absent. js const ids = Solid._expandTriIDsFromMesh(mesh); _fromManifold(manifoldObj, idToFaceName) (static) Static constructor that builds a Solid from an existing Manifold plus an ID → face-name map. js const rebuilt = Solid._fromManifold(existingManifold, existingMap); Export and visualization toSTL(name?, precision?) Generates an ASCII STL string from the current manifold mesh. js const stl = solid.toSTL('part', 5); writeSTL(filePath, name?, precision?) Node-only helper that writes the STL string to disk. js await solid.writeSTL('out/part.stl', 'part', 6); visualize(options?) Clears children, builds one Face mesh per face label, and optional boundary Edge polylines; attaches them as children for display. js solid.visualize({ showEdges: true, // include boundary polylines forceAuthoring: false, // force authoring arrays instead of manifold mesh authoringOnly: false // skip manifold path entirely }); scene.add(solid); Feature builders chamfer(options) Asynchronously applies chamfers to named edges, returning a new Solid (union for OUTSET, subtract for INSET). js const chamfered = await solid.chamfer({ distance: 1, // required edgeNames: ['EDGE_0'], // edges to chamfer direction: 'INSET', // or 'OUTSET' inflate: 0.1, // tool inflation (negated for OUTSET) debug: false, featureID: 'CHAMFER', // name prefix sampleCount: undefined, // optional strip sampling override snapSeamToEdge: undefined, // optional seam snapping sideStripSubdiv: undefined, // optional side strip subdivisions seamInsetScale: undefined, // optional seam inset scale flipSide: undefined, // optional side flip debugStride: undefined // optional debug stride }); fillet(options) Applies constant-radius fillets to edges on this Solid (union for OUTSET, subtract for INSET). Accepts edge names or resolved edge objects; OUTSET can optionally hull shared corners into a single tool to avoid gaps. js const filleted = await solid.fillet({ radius: 2, // required edgeNames: ['EDGE_0'], // or edges: [edgeObj] direction: 'OUTSET', // or 'INSET' resolution: 48, // segments around the tube inflate: 0.05, // tangency/cap offset; closed loops skip the wedge inset combineEdges: true, // OUTSET only; hulls fillets that share endpoints showTangentOverlays: false, // add tangency overlays on the helper tube (debug-friendly) debug: false, featureID: 'FILLET' // name prefix });"
-  },
-  {
-    "title": "Table of Contents",
-    "href": "table-of-contents.html",
-    "summary": "Table of Contents - BREP Help Home &middot; Table of Contents &middot; GitHub Clear Table of Contents Complete documentation structure with all available pages. Main Documentation Angle Constraint Angle Dimension Assembly Component Assembly...",
-    "content": "Table of Contents - BREP Help Home &middot; Table of Contents &middot; GitHub Clear Table of Contents Complete documentation structure with all available pages. Main Documentation Angle Constraint Angle Dimension Assembly Component Assembly Constraint Solver Boolean BREP Kernel Reference BREP Model and Classes BREP.js Export Map and Usage Chamfer Coincident Constraint CONTRIBUTING Cylindrical Face Radius Embedding Datium Datum Dialog Screenshots Distance Constraint Explode Body (View Transform) Extrude Features File Formats: Import and Export Fillet Fixed Constraint Getting Started Helix Highlights History Systems Hole Hole Callout How It Works Image Heightmap Solid Image to Face Import 3D Model Input Params Schema Inspector Leader LICENSE Linear Dimension Loft Mirror Modeling Mode Note Offset Shell Parallel Constraint Pattern (Legacy) Pattern Linear Pattern Radial Plane Plugins and Examples PMI Annotations PMI Mode Primitive Cone Primitive Cube Primitive Cylinder Primitive Pyramid Primitive Sphere Primitive Torus Radial Dimension Radius Metadata for Extruded Sketches Recent Inspector Improvements Remesh Revolve Sheet Metal Contour Flange Sheet Metal Flange Sheet Metal Tab Simplified Radial Dimension Interface Sketch Sketch Mode Solid Methods Reference Spline Sweep Touch Align Constraint Transform Tube Feature UI Overview (Browser) What's New"
-  },
-  {
-    "title": "UI Overview (Browser)",
-    "href": "ui-overview.html",
-    "summary": "UI Overview (Browser) Top toolbar - Save stores the current model in browser storage and integrates with the File Manager. - Zoom to Fit frames all visible geometry without changing orientation. - Wireframe toggles mesh wireframe rendering....",
-    "content": "UI Overview (Browser) Top toolbar - Save stores the current model in browser storage and integrates with the File Manager. - Zoom to Fit frames all visible geometry without changing orientation. - Wireframe toggles mesh wireframe rendering for inspection. - About opens the third-party license report. - Import opens a file picker for 3MF (with optional history) or BREP JSON. Export dialog offers 3MF, STL, OBJ, or BREP JSON output. Selection Filter now lives in the toolbar (right side) for quick changes; press Escape to clear selection."
-  },
-  {
-    "title": "What's New",
-    "href": "whats-new.html",
-    "summary": "What's New 3D Model Import Improvements Import button favors 3MF with embedded feature history and falls back to geometry-only files when needed. BREP JSON remains supported for history-only import. Import 3D Model feature auto-detects STL....",
-    "content": "What's New 3D Model Import Improvements Import button favors 3MF with embedded feature history and falls back to geometry-only files when needed. BREP JSON remains supported for history-only import. Import 3D Model feature auto-detects STL versus 3MF from strings, data URLs, or ArrayBuffers. 3MFs merge to a single editable mesh; STLs import as geometry only. File Manager save and load now use compact 3MF with embedded feature history and a thumbnail. Legacy JSON stays compatible for older saves. Image to Face and Image Editor \"Edit Image\" opens an in-app paint-style editor. If no image is set, it starts with a 300 x 300 white canvas. Editor UI prefers dark mode, renders at true 1:1 pixels with device pixel ratio awareness, and appears immediately on open. Resize handle on the bottom-right expands or crops the canvas while preserving edits. Brush improvements include live cursor outline, multiple shapes (round, square, diamond), and an eraser that respects the selected shape. Paint Bucket tool with tolerance slider (0-255) fills contiguous regions based on the composited image and applies paint only to the draw layer. Finish saves the edits back to the feature and triggers a recompute; Cancel discards edits."
-  }
-]