@faicad/faijs-extra 0.16.0

package/dist/extras/text-geometry.js

@@ -0,0 +1,127 @@
+/**
+ * text-geometry — 文字几何创建（mesh 路径）
+ *
+ * 使用 opentype.js + OpenSans Regular 字体（与 BREP 路径统一）。
+ * 字体来源：fontRegistry（通过依赖注入的 FontLoader 加载）。
+ *
+ * 过渡期仍用 THREE.Shape/ExtrudeGeometry，R6 时再替换为 manifold。
+ */
+import * as THREE from 'three';
+import { ensureDefaultFont, getFont as getRegisteredFont } from '@faicad/faijs/brep/text/fontRegistry';
+// ── Font loading ──
+/**
+ * Get the default opentype.js font (OpenSans Regular).
+ *
+ * Fetched from fontRegistry — the same font used by the BREP path
+ * (text-to-solid). The first call triggers a lazy ensureDefaultFont() load.
+ *
+ * @returns a promise resolving to the default opentype.js Font.
+ */
+export async function getOpentypeFont() {
+    await ensureDefaultFont();
+    const font = getRegisteredFont('default');
+    if (!font) {
+        throw new Error('[text-geometry] Default font not loaded. ' +
+            'Call setFontLoader() before using text functions.');
+    }
+    return font;
+}
+// ── Text geometry ──
+/**
+ * Create text geometry centered in X/Z, extruded along +Z.
+ *
+ * Uses opentype.js font.getPath() → THREE.Shape → ExtrudeGeometry.
+ * This is the same font source as the BREP path (text-to-solid),
+ * ensuring glyph consistency between mesh and BREP paths.
+ *
+ * @param text  Text string to render
+ * @param size  Font size in mm
+ * @param depth Extrusion depth in mm
+ * @param font  opentype.js Font object (from fontRegistry)
+ * @returns a promise resolving to the extruded text geometry.
+ */
+export async function createTextGeometry(text, size, depth, font) {
+    // Check for notdef glyphs (missing characters)
+    for (const ch of text) {
+        if (ch === ' ' || ch === '\t' || ch === '\n' || ch === '\r')
+            continue;
+        const glyph = font.charToGlyph(ch);
+        if (glyph.index === 0) {
+            throw new Error(`[text-geometry] Character "${ch}" (U+${ch.codePointAt(0).toString(16).toUpperCase()}) ` +
+                `not found in font. If it is a CJK character, a CJK font must be loaded.`);
+        }
+    }
+    const path = font.getPath(text, 0, 0, size);
+    const geo = opentypePathToGeometry(path, depth);
+    if (!geo) {
+        throw new Error(`[text-geometry] Failed to create geometry from text: "${text}"`);
+    }
+    return geo;
+}
+// ── opentype path → THREE geometry ──
+/**
+ * Convert an opentype.js Path to THREE.BufferGeometry.
+ *
+ * Path commands → THREE.Shape → ExtrudeGeometry.
+ * The result is centered in X and Z (bounding box center → origin).
+ *
+ * Exported for reuse by the CJK text path and 3d_editor preview layer.
+ *
+ * @param path - the opentype.js path to convert.
+ * @param depth - extrusion depth in mm.
+ * @returns the resulting BufferGeometry, or null when the path is empty.
+ */
+export function opentypePathToGeometry(path, depth) {
+    const commands = path.commands;
+    if (commands.length === 0)
+        return null;
+    const shapes = [];
+    let currentShape = null;
+    for (const cmd of commands) {
+        switch (cmd.type) {
+            case 'M':
+                // Implicit closure: opentype.js doesn't always emit 'Z' before a new 'M'.
+                // Push the current shape before starting a new subpath.
+                if (currentShape) {
+                    shapes.push(currentShape);
+                }
+                currentShape = new THREE.Shape();
+                currentShape.moveTo(cmd.x, cmd.y);
+                break;
+            case 'L':
+                currentShape?.lineTo(cmd.x, cmd.y);
+                break;
+            case 'C':
+                currentShape?.bezierCurveTo(cmd.x1, cmd.y1, cmd.x2, cmd.y2, cmd.x, cmd.y);
+                break;
+            case 'Q':
+                currentShape?.quadraticCurveTo(cmd.x1, cmd.y1, cmd.x, cmd.y);
+                break;
+            case 'Z':
+                if (currentShape) {
+                    shapes.push(currentShape);
+                    currentShape = null;
+                }
+                break;
+        }
+    }
+    // Handle final unclosed subpath (opentype.js doesn't always emit 'Z')
+    if (currentShape) {
+        shapes.push(currentShape);
+    }
+    if (shapes.length === 0)
+        return null;
+    const geo = new THREE.ExtrudeGeometry(shapes, {
+        depth,
+        bevelEnabled: false,
+        curveSegments: 6,
+    });
+    geo.computeBoundingBox();
+    if (geo.boundingBox) {
+        const cx = (geo.boundingBox.max.x + geo.boundingBox.min.x) / 2;
+        const cz = (geo.boundingBox.max.z + geo.boundingBox.min.z) / 2;
+        geo.translate(-cx, -geo.boundingBox.min.y, -cz);
+    }
+    return geo;
+}
+//# sourceMappingURL=text-geometry.js.map

package/dist/extras/text-geometry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-geometry.js","sourceRoot":"","sources":["../../src/extras/text-geometry.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,EAAE,iBAAiB,EAAE,OAAO,IAAI,iBAAiB,EAAE,MAAM,sCAAsC,CAAA;AAEtG,qBAAqB;AAErB;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,eAAe;IACnC,MAAM,iBAAiB,EAAE,CAAA;IACzB,MAAM,IAAI,GAAG,iBAAiB,CAAC,SAAS,CAAC,CAAA;IACzC,IAAI,CAAC,IAAI,EAAE,CAAC;QACV,MAAM,IAAI,KAAK,CACb,2CAA2C;YAC3C,mDAAmD,CACpD,CAAA;IACH,CAAC;IACD,OAAO,IAAI,CAAA;AACb,CAAC;AAED,sBAAsB;AAEtB;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,KAAK,UAAU,kBAAkB,CACtC,IAAY,EACZ,IAAY,EACZ,KAAa,EACb,IAAU;IAEV,+CAA+C;IAC/C,KAAK,MAAM,EAAE,IAAI,IAAI,EAAE,CAAC;QACtB,IAAI,EAAE,KAAK,GAAG,IAAI,EAAE,KAAK,IAAI,IAAI,EAAE,KAAK,IAAI,IAAI,EAAE,KAAK,IAAI;YAAE,SAAQ;QACrE,MAAM,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC,CAAA;QAClC,IAAI,KAAK,CAAC,KAAK,KAAK,CAAC,EAAE,CAAC;YACtB,MAAM,IAAI,KAAK,CACb,8BAA8B,EAAE,QAAQ,EAAE,CAAC,WAAW,CAAC,CAAC,CAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,WAAW,EAAE,IAAI;gBACzF,yEAAyE,CAC1E,CAAA;QACH,CAAC;IACH,CAAC;IAED,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,CAAA;IAC3C,MAAM,GAAG,GAAG,sBAAsB,CAAC,IAAI,EAAE,KAAK,CAAC,CAAA;IAC/C,IAAI,CAAC,GAAG,EAAE,CAAC;QACT,MAAM,IAAI,KAAK,CAAC,yDAAyD,IAAI,GAAG,CAAC,CAAA;IACnF,CAAC;IACD,OAAO,GAAG,CAAA;AACZ,CAAC;AAED,uCAAuC;AAEvC;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,sBAAsB,CACpC,IAAU,EACV,KAAa;IAEb,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAyB,CAAA;IAC/C,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAA;IAEtC,MAAM,MAAM,GAAkB,EAAE,CAAA;IAChC,IAAI,YAAY,GAAuB,IAAI,CAAA;IAE3C,KAAK,MAAM,GAAG,IAAI,QAAQ,EAAE,CAAC;QAC3B,QAAQ,GAAG,CAAC,IAAI,EAAE,CAAC;YACjB,KAAK,GAAG;gBACN,0EAA0E;gBAC1E,wDAAwD;gBACxD,IAAI,YAAY,EAAE,CAAC;oBACjB,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,CAAA;gBAC3B,CAAC;gBACD,YAAY,GAAG,IAAI,KAAK,CAAC,KAAK,EAAE,CAAA;gBAChC,YAAY,CAAC,MAAM,CAAC,GAAG,CAAC,CAAE,EAAE,GAAG,CAAC,CAAE,CAAC,CAAA;gBACnC,MAAK;YACP,KAAK,GAAG;gBACN,YAAY,EAAE,MAAM,CAAC,GAAG,CAAC,CAAE,EAAE,GAAG,CAAC,CAAE,CAAC,CAAA;gBACpC,MAAK;YACP,KAAK,GAAG;gBACN,YAAY,EAAE,aAAa,CAAC,GAAG,CAAC,EAAG,EAAE,GAAG,CAAC,EAAG,EAAE,GAAG,CAAC,EAAG,EAAE,GAAG,CAAC,EAAG,EAAE,GAAG,CAAC,CAAE,EAAE,GAAG,CAAC,CAAE,CAAC,CAAA;gBAC/E,MAAK;YACP,KAAK,GAAG;gBACN,YAAY,EAAE,gBAAgB,CAAC,GAAG,CAAC,EAAG,EAAE,GAAG,CAAC,EAAG,EAAE,GAAG,CAAC,CAAE,EAAE,GAAG,CAAC,CAAE,CAAC,CAAA;gBAChE,MAAK;YACP,KAAK,GAAG;gBACN,IAAI,YAAY,EAAE,CAAC;oBACjB,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,CAAA;oBACzB,YAAY,GAAG,IAAI,CAAA;gBACrB,CAAC;gBACD,MAAK;QACT,CAAC;IACH,CAAC;IAED,sEAAsE;IACtE,IAAI,YAAY,EAAE,CAAC;QACjB,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,CAAA;IAC3B,CAAC;IAED,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAA;IAEpC,MAAM,GAAG,GAAG,IAAI,KAAK,CAAC,eAAe,CAAC,MAAM,EAAE;QAC5C,KAAK;QACL,YAAY,EAAE,KAAK;QACnB,aAAa,EAAE,CAAC;KACjB,CAAC,CAAA;IACF,GAAG,CAAC,kBAAkB,EAAE,CAAA;IACxB,IAAI,GAAG,CAAC,WAAW,EAAE,CAAC;QACpB,MAAM,EAAE,GAAG,CAAC,GAAG,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,GAAG,GAAG,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAA;QAC9D,MAAM,EAAE,GAAG,CAAC,GAAG,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,GAAG,GAAG,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAA;QAC9D,GAAG,CAAC,SAAS,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAA;IACjD,CAAC;IACD,OAAO,GAAG,CAAA;AACZ,CAAC","sourcesContent":["/**\n * text-geometry — 文字几何创建（mesh 路径）\n *\n * 使用 opentype.js + OpenSans Regular 字体（与 BREP 路径统一）。\n * 字体来源：fontRegistry（通过依赖注入的 FontLoader 加载）。\n *\n * 过渡期仍用 THREE.Shape/ExtrudeGeometry，R6 时再替换为 manifold。\n */\n\nimport * as THREE from 'three'\nimport type { Font, Path, PathCommand } from 'opentype.js'\nimport { ensureDefaultFont, getFont as getRegisteredFont } from '@faicad/faijs/brep/text/fontRegistry'\n\n// ── Font loading ──\n\n/**\n * Get the default opentype.js font (OpenSans Regular).\n *\n * Fetched from fontRegistry — the same font used by the BREP path\n * (text-to-solid). The first call triggers a lazy ensureDefaultFont() load.\n *\n * @returns a promise resolving to the default opentype.js Font.\n */\nexport async function getOpentypeFont(): Promise<Font> {\n  await ensureDefaultFont()\n  const font = getRegisteredFont('default')\n  if (!font) {\n    throw new Error(\n      '[text-geometry] Default font not loaded. ' +\n      'Call setFontLoader() before using text functions.',\n    )\n  }\n  return font\n}\n\n// ── Text geometry ──\n\n/**\n * Create text geometry centered in X/Z, extruded along +Z.\n *\n * Uses opentype.js font.getPath() → THREE.Shape → ExtrudeGeometry.\n * This is the same font source as the BREP path (text-to-solid),\n * ensuring glyph consistency between mesh and BREP paths.\n *\n * @param text  Text string to render\n * @param size  Font size in mm\n * @param depth Extrusion depth in mm\n * @param font  opentype.js Font object (from fontRegistry)\n * @returns a promise resolving to the extruded text geometry.\n */\nexport async function createTextGeometry(\n  text: string,\n  size: number,\n  depth: number,\n  font: Font,\n): Promise<THREE.BufferGeometry> {\n  // Check for notdef glyphs (missing characters)\n  for (const ch of text) {\n    if (ch === ' ' || ch === '\\t' || ch === '\\n' || ch === '\\r') continue\n    const glyph = font.charToGlyph(ch)\n    if (glyph.index === 0) {\n      throw new Error(\n        `[text-geometry] Character \"${ch}\" (U+${ch.codePointAt(0)!.toString(16).toUpperCase()}) ` +\n        `not found in font. If it is a CJK character, a CJK font must be loaded.`,\n      )\n    }\n  }\n\n  const path = font.getPath(text, 0, 0, size)\n  const geo = opentypePathToGeometry(path, depth)\n  if (!geo) {\n    throw new Error(`[text-geometry] Failed to create geometry from text: \"${text}\"`)\n  }\n  return geo\n}\n\n// ── opentype path → THREE geometry ──\n\n/**\n * Convert an opentype.js Path to THREE.BufferGeometry.\n *\n * Path commands → THREE.Shape → ExtrudeGeometry.\n * The result is centered in X and Z (bounding box center → origin).\n *\n * Exported for reuse by the CJK text path and 3d_editor preview layer.\n *\n * @param path - the opentype.js path to convert.\n * @param depth - extrusion depth in mm.\n * @returns the resulting BufferGeometry, or null when the path is empty.\n */\nexport function opentypePathToGeometry(\n  path: Path,\n  depth: number,\n): THREE.BufferGeometry | null {\n  const commands = path.commands as PathCommand[]\n  if (commands.length === 0) return null\n\n  const shapes: THREE.Shape[] = []\n  let currentShape: THREE.Shape | null = null\n\n  for (const cmd of commands) {\n    switch (cmd.type) {\n      case 'M':\n        // Implicit closure: opentype.js doesn't always emit 'Z' before a new 'M'.\n        // Push the current shape before starting a new subpath.\n        if (currentShape) {\n          shapes.push(currentShape)\n        }\n        currentShape = new THREE.Shape()\n        currentShape.moveTo(cmd.x!, cmd.y!)\n        break\n      case 'L':\n        currentShape?.lineTo(cmd.x!, cmd.y!)\n        break\n      case 'C':\n        currentShape?.bezierCurveTo(cmd.x1!, cmd.y1!, cmd.x2!, cmd.y2!, cmd.x!, cmd.y!)\n        break\n      case 'Q':\n        currentShape?.quadraticCurveTo(cmd.x1!, cmd.y1!, cmd.x!, cmd.y!)\n        break\n      case 'Z':\n        if (currentShape) {\n          shapes.push(currentShape)\n          currentShape = null\n        }\n        break\n    }\n  }\n\n  // Handle final unclosed subpath (opentype.js doesn't always emit 'Z')\n  if (currentShape) {\n    shapes.push(currentShape)\n  }\n\n  if (shapes.length === 0) return null\n\n  const geo = new THREE.ExtrudeGeometry(shapes, {\n    depth,\n    bevelEnabled: false,\n    curveSegments: 6,\n  })\n  geo.computeBoundingBox()\n  if (geo.boundingBox) {\n    const cx = (geo.boundingBox.max.x + geo.boundingBox.min.x) / 2\n    const cz = (geo.boundingBox.max.z + geo.boundingBox.min.z) / 2\n    geo.translate(-cx, -geo.boundingBox.min.y, -cz)\n  }\n  return geo\n}\n"]}

package/dist/index.d.ts

@@ -0,0 +1,47 @@
+/**
+ * @faicad/faijs-extra — editor extension library for faijs.
+ *
+ * Carries the ops and preview helpers that serve the 3d_editor application but
+ * are not part of the faijs platform surface:
+ *
+ * - A group (editor ops): `fai_drill` / `fai_extrude` / `fai_split`,
+ *   `group` / `assembly`, `copy`, `load`.
+ * - B group (svg / 3D text): `text`, `svgExtrude` plus the preview helpers
+ *   `svgToExtrudedGeometry` / `parseSvgShapes` / `extrudeShapes` /
+ *   `createTextGeometry` / `getOpentypeFont` / `opentypePathToGeometry` /
+ *   `createMixedTextGeometry`.
+ *
+ * Assembly: merge `createEditorNamespace()` over core's `createApiNamespace()`,
+ * register the result as the host's `cad` library, then register the symbol
+ * names and install the mesh providers — see `./namespace`.
+ *
+ * Hosts that must not bundle three's non-basic chain (the weapp worker) use
+ * `@faicad/faijs-extra/editor-ops` instead: the A group only.
+ *
+ * This entry point is environment-agnostic (three + opentype.js only, no
+ * `node:*`); `./browser` is the same surface for browser/worker hosts.
+ */
+export { createEditorNamespace, createEditorCadNamespace, mergeEditorNamespace, registerEditorSymbols, unregisterEditorSymbols, installEditorMeshProviders, uninstallEditorMeshProviders, } from './namespace.js';
+export { ALL_EDITOR_OPS, CREATOR_OPS, EDITOR_OPS, isEditorOp, type CreatorOpName, type EditorOpName, } from './op-names.js';
+export { fai_drill, assertDrillParams } from './ops/fai_drill.js';
+export { fai_extrude, assertExtrudeParams } from './ops/fai_extrude.js';
+export { fai_split } from './ops/fai_split.js';
+export { group, assembly } from './ops/compound.js';
+export type { GroupParams, AssemblyParams, AssemblyBehavior } from './ops/compound.js';
+export { copy } from './ops/copy.js';
+export { load } from './ops/load.js';
+export type { AssemblyConstraint, FaceMateConstraint, FaceMateFace, EntityRef, FaceRef, EdgeRef, AssemblyVec3, MateConstraint, AlignConstraint, CoincidentConstraint, ConcentricConstraint, DistanceConstraint, AngleConstraint, ParallelConstraint, PerpendicularConstraint, FixedConstraint, StructuralConstraint, } from '@faicad/faijs/api/assembly/types';
+export type { AssemblySolveResult } from '@faicad/faijs/api/assembly/solve';
+export { text, assertTextParams } from './ops/text.js';
+export { svgExtrude, assertSvgExtrudeParams } from './ops/svg-extrude.js';
+export { svgToExtrudedGeometry, parseSvgShapes, extrudeShapes, type SvgExtrudeOptions, } from './extras/svg-extrude.js';
+export { createTextGeometry, getOpentypeFont, opentypePathToGeometry, } from './extras/text-geometry.js';
+export { createMixedTextGeometry } from './extras/text-cjk.js';
+export { createEngraveDecorationProvider } from './mesh/engrave-decoration.js';
+export { editorCad } from './mesh/index.js';
+export { splitWithParams, dovetailSplit, dowelSplit, tenonSplit, computeBasisFromNormal, } from './mesh/fai_split.js';
+export { drill } from './mesh/fai_drill.js';
+export { extrude as meshExtrude } from './mesh/fai_extrude.js';
+export { text as meshText, svgExtrude as meshSvgExtrude } from './mesh/primitives.js';
+export type { Shape, Vec3, BoundingBox, FaceDescriptor, TextParams, SvgExtrudeParams, DrillParams, ExtrudeParams, SplitPlane, SplitResult, DovetailSplitParams, DowelSplitParams, TenonSplitParams, } from '@faicad/faijs/mesh/types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,OAAO,EACL,qBAAqB,EAAE,wBAAwB,EAAE,oBAAoB,EACrE,qBAAqB,EAAE,uBAAuB,EAC9C,0BAA0B,EAAE,4BAA4B,GACzD,MAAM,aAAa,CAAA;AACpB,OAAO,EACL,cAAc,EAAE,WAAW,EAAE,UAAU,EAAE,UAAU,EACnD,KAAK,aAAa,EAAE,KAAK,YAAY,GACtC,MAAM,YAAY,CAAA;AAGnB,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AAC9D,OAAO,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAA;AACpE,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAC3C,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAChD,YAAY,EAAE,WAAW,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AACnF,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AACjC,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AACjC,YAAY,EACV,kBAAkB,EAAE,kBAAkB,EAAE,YAAY,EACpD,SAAS,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY,EACzC,cAAc,EAAE,eAAe,EAAE,oBAAoB,EAAE,oBAAoB,EAC3E,kBAAkB,EAAE,eAAe,EAAE,kBAAkB,EAAE,uBAAuB,EAChF,eAAe,EAAE,oBAAoB,GACtC,MAAM,kCAAkC,CAAA;AACzC,YAAY,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAA;AAG3E,OAAO,EAAE,IAAI,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AACnD,OAAO,EAAE,UAAU,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAA;AAGtE,OAAO,EACL,qBAAqB,EAAE,cAAc,EAAE,aAAa,EACpD,KAAK,iBAAiB,GACvB,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EACL,kBAAkB,EAAE,eAAe,EAAE,sBAAsB,GAC5D,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAA;AAC3D,OAAO,EAAE,+BAA+B,EAAE,MAAM,2BAA2B,CAAA;AAG3E,OAAO,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAA;AAClC,OAAO,EACL,eAAe,EAAE,aAAa,EAAE,UAAU,EAAE,UAAU,EAAE,sBAAsB,GAC/E,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAA;AACxC,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAC3D,OAAO,EAAE,IAAI,IAAI,QAAQ,EAAE,UAAU,IAAI,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAClF,YAAY,EACV,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,cAAc,EACxC,UAAU,EAAE,gBAAgB,EAC5B,WAAW,EAAE,aAAa,EAC1B,UAAU,EAAE,WAAW,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,gBAAgB,GACjF,MAAM,0BAA0B,CAAA"}

package/dist/index.js

@@ -0,0 +1,47 @@
+/**
+ * @faicad/faijs-extra — editor extension library for faijs.
+ *
+ * Carries the ops and preview helpers that serve the 3d_editor application but
+ * are not part of the faijs platform surface:
+ *
+ * - A group (editor ops): `fai_drill` / `fai_extrude` / `fai_split`,
+ *   `group` / `assembly`, `copy`, `load`.
+ * - B group (svg / 3D text): `text`, `svgExtrude` plus the preview helpers
+ *   `svgToExtrudedGeometry` / `parseSvgShapes` / `extrudeShapes` /
+ *   `createTextGeometry` / `getOpentypeFont` / `opentypePathToGeometry` /
+ *   `createMixedTextGeometry`.
+ *
+ * Assembly: merge `createEditorNamespace()` over core's `createApiNamespace()`,
+ * register the result as the host's `cad` library, then register the symbol
+ * names and install the mesh providers — see `./namespace`.
+ *
+ * Hosts that must not bundle three's non-basic chain (the weapp worker) use
+ * `@faicad/faijs-extra/editor-ops` instead: the A group only.
+ *
+ * This entry point is environment-agnostic (three + opentype.js only, no
+ * `node:*`); `./browser` is the same surface for browser/worker hosts.
+ */
+export { createEditorNamespace, createEditorCadNamespace, mergeEditorNamespace, registerEditorSymbols, unregisterEditorSymbols, installEditorMeshProviders, uninstallEditorMeshProviders, } from './namespace.js';
+export { ALL_EDITOR_OPS, CREATOR_OPS, EDITOR_OPS, isEditorOp, } from './op-names.js';
+// ── A 组：编辑器 op 定义 ──
+export { fai_drill, assertDrillParams } from './ops/fai_drill.js';
+export { fai_extrude, assertExtrudeParams } from './ops/fai_extrude.js';
+export { fai_split } from './ops/fai_split.js';
+export { group, assembly } from './ops/compound.js';
+export { copy } from './ops/copy.js';
+export { load } from './ops/load.js';
+// ── B 组：svg / 3D 文字 op ──
+export { text, assertTextParams } from './ops/text.js';
+export { svgExtrude, assertSvgExtrudeParams } from './ops/svg-extrude.js';
+// ── B 组：预览辅助函数（宿主交互预览用，不提交几何）──
+export { svgToExtrudedGeometry, parseSvgShapes, extrudeShapes, } from './extras/svg-extrude.js';
+export { createTextGeometry, getOpentypeFont, opentypePathToGeometry, } from './extras/text-geometry.js';
+export { createMixedTextGeometry } from './extras/text-cjk.js';
+export { createEngraveDecorationProvider } from './mesh/engrave-decoration.js';
+// ── mesh 实现聚合（编辑器侧脚本面/预览共用的实现入口）──
+export { editorCad } from './mesh/index.js';
+export { splitWithParams, dovetailSplit, dowelSplit, tenonSplit, computeBasisFromNormal, } from './mesh/fai_split.js';
+export { drill } from './mesh/fai_drill.js';
+export { extrude as meshExtrude } from './mesh/fai_extrude.js';
+export { text as meshText, svgExtrude as meshSvgExtrude } from './mesh/primitives.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,OAAO,EACL,qBAAqB,EAAE,wBAAwB,EAAE,oBAAoB,EACrE,qBAAqB,EAAE,uBAAuB,EAC9C,0BAA0B,EAAE,4BAA4B,GACzD,MAAM,aAAa,CAAA;AACpB,OAAO,EACL,cAAc,EAAE,WAAW,EAAE,UAAU,EAAE,UAAU,GAEpD,MAAM,YAAY,CAAA;AAEnB,sBAAsB;AACtB,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AAC9D,OAAO,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAA;AACpE,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAC3C,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAEhD,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AACjC,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AAUjC,2BAA2B;AAC3B,OAAO,EAAE,IAAI,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AACnD,OAAO,EAAE,UAAU,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAA;AAEtE,iCAAiC;AACjC,OAAO,EACL,qBAAqB,EAAE,cAAc,EAAE,aAAa,GAErD,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EACL,kBAAkB,EAAE,eAAe,EAAE,sBAAsB,GAC5D,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAA;AAC3D,OAAO,EAAE,+BAA+B,EAAE,MAAM,2BAA2B,CAAA;AAE3E,oCAAoC;AACpC,OAAO,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAA;AAClC,OAAO,EACL,eAAe,EAAE,aAAa,EAAE,UAAU,EAAE,UAAU,EAAE,sBAAsB,GAC/E,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAA;AACxC,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAC3D,OAAO,EAAE,IAAI,IAAI,QAAQ,EAAE,UAAU,IAAI,cAAc,EAAE,MAAM,mBAAmB,CAAA","sourcesContent":["/**\n * @faicad/faijs-extra — editor extension library for faijs.\n *\n * Carries the ops and preview helpers that serve the 3d_editor application but\n * are not part of the faijs platform surface:\n *\n * - A group (editor ops): `fai_drill` / `fai_extrude` / `fai_split`,\n *   `group` / `assembly`, `copy`, `load`.\n * - B group (svg / 3D text): `text`, `svgExtrude` plus the preview helpers\n *   `svgToExtrudedGeometry` / `parseSvgShapes` / `extrudeShapes` /\n *   `createTextGeometry` / `getOpentypeFont` / `opentypePathToGeometry` /\n *   `createMixedTextGeometry`.\n *\n * Assembly: merge `createEditorNamespace()` over core's `createApiNamespace()`,\n * register the result as the host's `cad` library, then register the symbol\n * names and install the mesh providers — see `./namespace`.\n *\n * Hosts that must not bundle three's non-basic chain (the weapp worker) use\n * `@faicad/faijs-extra/editor-ops` instead: the A group only.\n *\n * This entry point is environment-agnostic (three + opentype.js only, no\n * `node:*`); `./browser` is the same surface for browser/worker hosts.\n */\nexport {\n  createEditorNamespace, createEditorCadNamespace, mergeEditorNamespace,\n  registerEditorSymbols, unregisterEditorSymbols,\n  installEditorMeshProviders, uninstallEditorMeshProviders,\n} from './namespace'\nexport {\n  ALL_EDITOR_OPS, CREATOR_OPS, EDITOR_OPS, isEditorOp,\n  type CreatorOpName, type EditorOpName,\n} from './op-names'\n\n// ── A 组：编辑器 op 定义 ──\nexport { fai_drill, assertDrillParams } from './ops/fai_drill'\nexport { fai_extrude, assertExtrudeParams } from './ops/fai_extrude'\nexport { fai_split } from './ops/fai_split'\nexport { group, assembly } from './ops/compound'\nexport type { GroupParams, AssemblyParams, AssemblyBehavior } from './ops/compound'\nexport { copy } from './ops/copy'\nexport { load } from './ops/load'\nexport type {\n  AssemblyConstraint, FaceMateConstraint, FaceMateFace,\n  EntityRef, FaceRef, EdgeRef, AssemblyVec3,\n  MateConstraint, AlignConstraint, CoincidentConstraint, ConcentricConstraint,\n  DistanceConstraint, AngleConstraint, ParallelConstraint, PerpendicularConstraint,\n  FixedConstraint, StructuralConstraint,\n} from '@faicad/faijs/api/assembly/types'\nexport type { AssemblySolveResult } from '@faicad/faijs/api/assembly/solve'\n\n// ── B 组：svg / 3D 文字 op ──\nexport { text, assertTextParams } from './ops/text'\nexport { svgExtrude, assertSvgExtrudeParams } from './ops/svg-extrude'\n\n// ── B 组：预览辅助函数（宿主交互预览用，不提交几何）──\nexport {\n  svgToExtrudedGeometry, parseSvgShapes, extrudeShapes,\n  type SvgExtrudeOptions,\n} from './extras/svg-extrude'\nexport {\n  createTextGeometry, getOpentypeFont, opentypePathToGeometry,\n} from './extras/text-geometry'\nexport { createMixedTextGeometry } from './extras/text-cjk'\nexport { createEngraveDecorationProvider } from './mesh/engrave-decoration'\n\n// ── mesh 实现聚合（编辑器侧脚本面/预览共用的实现入口）──\nexport { editorCad } from './mesh'\nexport {\n  splitWithParams, dovetailSplit, dowelSplit, tenonSplit, computeBasisFromNormal,\n} from './mesh/fai_split'\nexport { drill } from './mesh/fai_drill'\nexport { extrude as meshExtrude } from './mesh/fai_extrude'\nexport { text as meshText, svgExtrude as meshSvgExtrude } from './mesh/primitives'\nexport type {\n  Shape, Vec3, BoundingBox, FaceDescriptor,\n  TextParams, SvgExtrudeParams,\n  DrillParams, ExtrudeParams,\n  SplitPlane, SplitResult, DovetailSplitParams, DowelSplitParams, TenonSplitParams,\n} from '@faicad/faijs/mesh/types'\n"]}

package/dist/mesh/drill-hole/DrillHoleCore.d.ts

@@ -0,0 +1,90 @@
+import * as THREE from 'three';
+import type { DrillDirection, DrillHoleParams } from './drill-types.js';
+/**
+ * Build a Z-up hole geometry centered on the origin, with the axial direction
+ * along Z.
+ *
+ * - simple: CylinderGeometry rotated to Z-up
+ * - screw: makeScrew() already returns Z-up
+ *
+ * Tolerance is applied as a radial expansion (tolerance/2 on radius).
+ *
+ * @param params - drill-hole parameters (type, diameter, screw details, tolerance).
+ * @param height - axial length of the hole in millimeters.
+ * @returns the hole geometry as a Z-up BufferGeometry.
+ */
+export declare function buildHoleGeometry(params: DrillHoleParams, height: number): THREE.BufferGeometry;
+/**
+ * Compute the through-hole height by raycasting against the target mesh's
+ * bounding box. Returns { height, center } so the cylinder exactly spans the
+ * model thickness along the drill direction, without extending outside.
+ *
+ * @param position - world-space position of the hole entry point.
+ * @param direction - the drill direction (normalized internally).
+ * @param bbox - world-space bounding box of the target mesh.
+ * @returns the height and world-space center of the through hole.
+ */
+export declare function computeThroughHoleDimensions(position: THREE.Vector3, direction: THREE.Vector3, bbox: THREE.Box3): {
+    height: number;
+    center: THREE.Vector3;
+};
+/**
+ * Compute the blind-hole center: the hole entry is at the click point,
+ * the hole extends inward by `depth`. The cylinder center is at
+ * position + direction * (depth / 2).
+ *
+ * @param position - world-space hole entry point.
+ * @param direction - the drill direction (normalized internally).
+ * @param depth - blind-hole depth in millimeters.
+ * @returns the world-space cylinder center.
+ */
+export declare function computeBlindHoleCenter(position: THREE.Vector3, direction: THREE.Vector3, depth: number): THREE.Vector3;
+/**
+ * Orient and position a Z-up hole geometry (axial along Z) to world space.
+ * Returns a new geometry with the transform baked in.
+ *
+ * @param geo - Z-up hole geometry centered on the origin.
+ * @param direction - world-space axis the hole should point along.
+ * @param center - world-space position of the hole center.
+ * @returns a transformed clone of the input geometry.
+ */
+export declare function positionHoleGeometry(geo: THREE.BufferGeometry, direction: THREE.Vector3, center: THREE.Vector3): THREE.BufferGeometry;
+/**
+ * Resolve the drill direction based on params.direction and the face normal.
+ *
+ * - 'normal': inward direction = negated face normal
+ * - 'x'/'y'/'z': axis-aligned, flipped to point INTO the material
+ *   (i.e. opposite to the face normal)
+ *
+ * @param direction - requested drill-direction reference.
+ * @param faceNormal - face normal at the drill position.
+ * @returns the resolved unit drill direction.
+ */
+export declare function resolveDrillDirection(direction: DrillDirection, faceNormal: THREE.Vector3): THREE.Vector3;
+/**
+ * Drill a hole into a THREE.Mesh in world space, returning the resulting
+ * geometry in the mesh's local space.
+ *
+ * @param targetMesh - the mesh to drill into.
+ * @param params - drill-hole parameters.
+ * @param position - world-space hole entry point.
+ * @param faceNormal - world-space normal of the face at the entry point.
+ * @returns the drilled geometry in mesh-local space.
+ */
+export declare function executeDrillHole(targetMesh: THREE.Mesh, params: DrillHoleParams, position: THREE.Vector3, faceNormal: THREE.Vector3): Promise<THREE.BufferGeometry>;
+/**
+ * Core drill computation that accepts geometry + world matrix directly.
+ *
+ * This avoids the need to temporarily swap mesh.geometry when the mesh
+ * currently has a preview geometry on it. Callers that have the G0 geometry
+ * in a separate BufferGeometry can use this directly.
+ *
+ * @param sourceGeometry - the base geometry to drill (mesh-local space).
+ * @param worldMatrix - world transform of the source geometry.
+ * @param params - drill-hole parameters.
+ * @param position - world-space hole entry point.
+ * @param faceNormal - world-space face normal at the entry point.
+ * @returns the drilled geometry, transformed back into mesh-local space.
+ */
+export declare function executeDrillHoleOnGeometry(sourceGeometry: THREE.BufferGeometry, worldMatrix: THREE.Matrix4, params: DrillHoleParams, position: THREE.Vector3, faceNormal: THREE.Vector3): Promise<THREE.BufferGeometry>;
+//# sourceMappingURL=DrillHoleCore.d.ts.map

package/dist/mesh/drill-hole/DrillHoleCore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DrillHoleCore.d.ts","sourceRoot":"","sources":["../../../src/mesh/drill-hole/DrillHoleCore.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAU9B,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAKpE;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,eAAe,EACvB,MAAM,EAAE,MAAM,GACb,KAAK,CAAC,cAAc,CAkEtB;AAED;;;;;;;;;GASG;AACH,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,KAAK,CAAC,OAAO,EACvB,SAAS,EAAE,KAAK,CAAC,OAAO,EACxB,IAAI,EAAE,KAAK,CAAC,IAAI,GACf;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,KAAK,CAAC,OAAO,CAAA;CAAE,CAqD3C;AAED;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,KAAK,CAAC,OAAO,EACvB,SAAS,EAAE,KAAK,CAAC,OAAO,EACxB,KAAK,EAAE,MAAM,GACZ,KAAK,CAAC,OAAO,CAEf;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAClC,GAAG,EAAE,KAAK,CAAC,cAAc,EACzB,SAAS,EAAE,KAAK,CAAC,OAAO,EACxB,MAAM,EAAE,KAAK,CAAC,OAAO,GACpB,KAAK,CAAC,cAAc,CAWtB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,cAAc,EACzB,UAAU,EAAE,KAAK,CAAC,OAAO,GACxB,KAAK,CAAC,OAAO,CAiBf;AAED;;;;;;;;;GASG;AACH,wBAAsB,gBAAgB,CACpC,UAAU,EAAE,KAAK,CAAC,IAAI,EACtB,MAAM,EAAE,eAAe,EACvB,QAAQ,EAAE,KAAK,CAAC,OAAO,EACvB,UAAU,EAAE,KAAK,CAAC,OAAO,GACxB,OAAO,CAAC,KAAK,CAAC,cAAc,CAAC,CAS/B;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,0BAA0B,CAC9C,cAAc,EAAE,KAAK,CAAC,cAAc,EACpC,WAAW,EAAE,KAAK,CAAC,OAAO,EAC1B,MAAM,EAAE,eAAe,EACvB,QAAQ,EAAE,KAAK,CAAC,OAAO,EACvB,UAAU,EAAE,KAAK,CAAC,OAAO,GACxB,OAAO,CAAC,KAAK,CAAC,cAAc,CAAC,CA6E/B"}

package/dist/mesh/drill-hole/DrillHoleCore.js

@@ -0,0 +1,287 @@
+import * as THREE from 'three';
+import { makeScrew } from '@faicad/faijs/primitives/screw/screw';
+import { getScrewSpec } from '@faicad/faijs/primitives/screw/screw-db';
+import { computeBoolean, geoToManifoldMesh, manifoldMeshToGeo, } from '@faicad/faijs/boolean/csg-backend';
+import { deriveNormals } from '@faicad/faijs/boolean/deriveNormals';
+/** Rotation matrix: +90° around X — converts Y-up vertex data to Z-up. */
+const ROT_Y_TO_Z = new THREE.Matrix4().makeRotationX(Math.PI / 2);
+/**
+ * Build a Z-up hole geometry centered on the origin, with the axial direction
+ * along Z.
+ *
+ * - simple: CylinderGeometry rotated to Z-up
+ * - screw: makeScrew() already returns Z-up
+ *
+ * Tolerance is applied as a radial expansion (tolerance/2 on radius).
+ *
+ * @param params - drill-hole parameters (type, diameter, screw details, tolerance).
+ * @param height - axial length of the hole in millimeters.
+ * @returns the hole geometry as a Z-up BufferGeometry.
+ */
+export function buildHoleGeometry(params, height) {
+    const toleranceRadius = params.tolerance / 2;
+    // ── simple: CylinderGeometry → rotate to Z-up ──
+    if (params.holeType === 'simple') {
+        const r = params.diameter / 2 + toleranceRadius;
+        const geo = new THREE.CylinderGeometry(r, r, height, 32);
+        geo.applyMatrix4(ROT_Y_TO_Z);
+        return geo;
+    }
+    // ── screw: makeScrew() already returns Z-up ──
+    if (params.holeType === 'screw') {
+        const geo = makeScrew({
+            system: params.screwSystem,
+            specIdx: params.screwSpecIdx,
+            thread: params.screwThread,
+            pitchCustom: 0,
+            length: height,
+            head: params.screwHead,
+            nRad: 32,
+        });
+        // Center the screw on origin. makeScrew extends from Z=0 to Z=height
+        // for the body, plus headHeight = spec.dia for the head (if present).
+        // The total length = height + headHeight, so center by half that.
+        const spec = getScrewSpec(params.screwSystem, params.screwSpecIdx);
+        const headHeight = params.screwHead !== 'none' ? spec.dia : 0;
+        const totalLength = height + headHeight;
+        geo.translate(0, 0, -totalLength / 2);
+        // For screw with head: makeScrew places the head at the +Z end (top of
+        // the screw), but for a drill hole the head must be at the -Z end — the
+        // entry point at the surface. Reflect Z to put the head at the entry side,
+        // and reverse triangle winding to maintain correct normals.
+        if (params.screwHead !== 'none') {
+            const pos = geo.getAttribute('position');
+            for (let i = 0; i < pos.count; i++) {
+                pos.setZ(i, -pos.getZ(i));
+            }
+            pos.needsUpdate = true;
+            // Fix winding order: reflection flips triangle orientation
+            const idx = geo.index;
+            const arr = idx.array;
+            for (let i = 0; i < arr.length; i += 3) {
+                const tmp = arr[i + 1];
+                arr[i + 1] = arr[i + 2];
+                arr[i + 2] = tmp;
+            }
+            idx.needsUpdate = true;
+        }
+        // Apply tolerance: scale radially (X and Y in Z-up space)
+        const baseRadius = spec.dia / 2;
+        if (toleranceRadius > 0 && baseRadius > 0) {
+            const scale = 1 + toleranceRadius / baseRadius;
+            geo.scale(scale, scale, 1);
+        }
+        return geo;
+    }
+    // Fallback (should not reach)
+    const geo = new THREE.CylinderGeometry(params.diameter / 2, params.diameter / 2, height, 32);
+    geo.applyMatrix4(ROT_Y_TO_Z);
+    return geo;
+}
+/**
+ * Compute the through-hole height by raycasting against the target mesh's
+ * bounding box. Returns { height, center } so the cylinder exactly spans the
+ * model thickness along the drill direction, without extending outside.
+ *
+ * @param position - world-space position of the hole entry point.
+ * @param direction - the drill direction (normalized internally).
+ * @param bbox - world-space bounding box of the target mesh.
+ * @returns the height and world-space center of the through hole.
+ */
+export function computeThroughHoleDimensions(position, direction, bbox) {
+    const dir = direction.clone().normalize();
+    // Manual slab-method intersection: compute distances along dir to bbox entry/exit.
+    // This handles edge cases where position is exactly on the bbox boundary
+    // (Ray.intersectBox returns null in those cases).
+    const p = position;
+    const d = dir;
+    let tNear = -Infinity;
+    let tFar = Infinity;
+    // X slab
+    if (Math.abs(d.x) > 1e-12) {
+        const t1 = (bbox.min.x - p.x) / d.x;
+        const t2 = (bbox.max.x - p.x) / d.x;
+        tNear = Math.max(tNear, Math.min(t1, t2));
+        tFar = Math.min(tFar, Math.max(t1, t2));
+    }
+    else if (p.x < bbox.min.x || p.x > bbox.max.x) {
+        // Parallel to X slab and outside — no intersection
+        return { height: 0, center: position.clone() };
+    }
+    // Y slab
+    if (Math.abs(d.y) > 1e-12) {
+        const t1 = (bbox.min.y - p.y) / d.y;
+        const t2 = (bbox.max.y - p.y) / d.y;
+        tNear = Math.max(tNear, Math.min(t1, t2));
+        tFar = Math.min(tFar, Math.max(t1, t2));
+    }
+    else if (p.y < bbox.min.y || p.y > bbox.max.y) {
+        return { height: 0, center: position.clone() };
+    }
+    // Z slab
+    if (Math.abs(d.z) > 1e-12) {
+        const t1 = (bbox.min.z - p.z) / d.z;
+        const t2 = (bbox.max.z - p.z) / d.z;
+        tNear = Math.max(tNear, Math.min(t1, t2));
+        tFar = Math.min(tFar, Math.max(t1, t2));
+    }
+    else if (p.z < bbox.min.z || p.z > bbox.max.z) {
+        return { height: 0, center: position.clone() };
+    }
+    // Clamp: if position is inside or on boundary, tNear <= 0 <= tFar
+    // Forward distance = tFar (exit point along +dir)
+    // Backward distance = -tNear (exit point along -dir, i.e. behind us)
+    const forwardDist = tFar > 0 ? tFar : 0;
+    const backwardDist = tNear < 0 ? -tNear : 0;
+    const height = forwardDist + backwardDist;
+    const center = position.clone()
+        .add(dir.clone().multiplyScalar((forwardDist - backwardDist) / 2));
+    return { height, center };
+}
+/**
+ * Compute the blind-hole center: the hole entry is at the click point,
+ * the hole extends inward by `depth`. The cylinder center is at
+ * position + direction * (depth / 2).
+ *
+ * @param position - world-space hole entry point.
+ * @param direction - the drill direction (normalized internally).
+ * @param depth - blind-hole depth in millimeters.
+ * @returns the world-space cylinder center.
+ */
+export function computeBlindHoleCenter(position, direction, depth) {
+    return position.clone().add(direction.clone().normalize().multiplyScalar(depth / 2));
+}
+/**
+ * Orient and position a Z-up hole geometry (axial along Z) to world space.
+ * Returns a new geometry with the transform baked in.
+ *
+ * @param geo - Z-up hole geometry centered on the origin.
+ * @param direction - world-space axis the hole should point along.
+ * @param center - world-space position of the hole center.
+ * @returns a transformed clone of the input geometry.
+ */
+export function positionHoleGeometry(geo, direction, center) {
+    const result = geo.clone();
+    // Rotate Z axis to direction
+    const quat = new THREE.Quaternion().setFromUnitVectors(new THREE.Vector3(0, 0, 1), direction.clone().normalize());
+    result.applyQuaternion(quat);
+    // Translate to center
+    result.translate(center.x, center.y, center.z);
+    return result;
+}
+/**
+ * Resolve the drill direction based on params.direction and the face normal.
+ *
+ * - 'normal': inward direction = negated face normal
+ * - 'x'/'y'/'z': axis-aligned, flipped to point INTO the material
+ *   (i.e. opposite to the face normal)
+ *
+ * @param direction - requested drill-direction reference.
+ * @param faceNormal - face normal at the drill position.
+ * @returns the resolved unit drill direction.
+ */
+export function resolveDrillDirection(direction, faceNormal) {
+    if (direction === 'normal') {
+        return faceNormal.clone().negate().normalize();
+    }
+    // Axis-aligned direction
+    const axisDir = new THREE.Vector3(direction === 'x' ? 1 : 0, direction === 'y' ? 1 : 0, direction === 'z' ? 1 : 0);
+    // Flip to point INTO the material (opposite to face normal)
+    if (axisDir.dot(faceNormal) > 0) {
+        axisDir.negate();
+    }
+    return axisDir;
+}
+/**
+ * Drill a hole into a THREE.Mesh in world space, returning the resulting
+ * geometry in the mesh's local space.
+ *
+ * @param targetMesh - the mesh to drill into.
+ * @param params - drill-hole parameters.
+ * @param position - world-space hole entry point.
+ * @param faceNormal - world-space normal of the face at the entry point.
+ * @returns the drilled geometry in mesh-local space.
+ */
+export async function executeDrillHole(targetMesh, params, position, faceNormal) {
+    targetMesh.updateMatrixWorld();
+    return executeDrillHoleOnGeometry(targetMesh.geometry, targetMesh.matrixWorld, params, position, faceNormal);
+}
+/**
+ * Core drill computation that accepts geometry + world matrix directly.
+ *
+ * This avoids the need to temporarily swap mesh.geometry when the mesh
+ * currently has a preview geometry on it. Callers that have the G0 geometry
+ * in a separate BufferGeometry can use this directly.
+ *
+ * @param sourceGeometry - the base geometry to drill (mesh-local space).
+ * @param worldMatrix - world transform of the source geometry.
+ * @param params - drill-hole parameters.
+ * @param position - world-space hole entry point.
+ * @param faceNormal - world-space face normal at the entry point.
+ * @returns the drilled geometry, transformed back into mesh-local space.
+ */
+export async function executeDrillHoleOnGeometry(sourceGeometry, worldMatrix, params, position, faceNormal) {
+    // 1. Compute drill direction based on params.direction
+    const direction = resolveDrillDirection(params.direction, faceNormal);
+    // 2. Compute bbox from the source geometry (in world space)
+    sourceGeometry.computeBoundingBox();
+    const bbox = sourceGeometry.boundingBox.clone();
+    bbox.applyMatrix4(worldMatrix);
+    const bboxSize = bbox.getSize(new THREE.Vector3());
+    const bboxMax = Math.max(bboxSize.x, bboxSize.y, bboxSize.z);
+    // 3. Clamp depth to valid range: [0, bboxMax]
+    const safeDepth = Math.max(0, Math.min(params.depth, bboxMax));
+    // 4. Compute hole height and center
+    let holeHeight;
+    let holeCenter;
+    if (safeDepth === 0) {
+        // Through hole: clip to bbox
+        const dims = computeThroughHoleDimensions(position, direction, bbox);
+        // Add epsilon on both ends for clean CSG cut
+        holeHeight = dims.height + 0.2; // 0.1mm each side
+        holeCenter = dims.center;
+    }
+    else {
+        // Blind hole
+        holeHeight = safeDepth;
+        holeCenter = computeBlindHoleCenter(position, direction, safeDepth);
+        // For screw with head: the geometry is centered at (height + headHeight)/2,
+        // so the entry (-totalLength/2) must map to position.  Adjust holeCenter
+        // by direction * headHeight/2 to compensate.
+        if (params.holeType === 'screw' && params.screwHead !== 'none') {
+            const spec = getScrewSpec(params.screwSystem, params.screwSpecIdx);
+            const headHeight = spec.dia;
+            holeCenter.add(direction.clone().normalize().multiplyScalar(headHeight / 2));
+        }
+    }
+    // 5. Build hole geometry (Z-up, centered on origin)
+    const holeGeo = buildHoleGeometry(params, holeHeight);
+    // 6. Position hole geometry to world space
+    const holeGeoWorld = positionHoleGeometry(holeGeo, direction, holeCenter);
+    // 7. Clone source geometry and transform to world space
+    const targetGeo = sourceGeometry.clone();
+    targetGeo.applyMatrix4(worldMatrix);
+    // 8. Convert to ManifoldMeshData
+    const targetManifold = geoToManifoldMesh(targetGeo);
+    const holeManifold = geoToManifoldMesh(holeGeoWorld);
+    // 9. Execute CSG subtract
+    const result = await computeBoolean([targetManifold, holeManifold], 'subtract');
+    // 10. Convert back to BufferGeometry
+    const resultGeo = manifoldMeshToGeo(result);
+    // 11. Transform back to mesh local space
+    const invMatrix = new THREE.Matrix4().copy(worldMatrix).invert();
+    resultGeo.applyMatrix4(invMatrix);
+    // Derive creased normals on the committed result so sharp edges stay sharp
+    // (the old computeVertexNormals() averaged on the welded shared-vertex
+    // topology and rounded them off). toCreasedNormals transforms correctly with
+    // applyMatrix4 above, but we re-derive to guarantee the final geometry uses
+    // the unified creased-normal logic regardless of the manifold output topology.
+    const finalGeo = deriveNormals(resultGeo);
+    resultGeo.dispose();
+    // 12. Cleanup
+    holeGeo.dispose();
+    holeGeoWorld.dispose();
+    targetGeo.dispose();
+    return finalGeo;
+}
+//# sourceMappingURL=DrillHoleCore.js.map