@faicad/faijs 0.13.0

package/dist/brep/brep-topology.d.ts

@@ -0,0 +1,63 @@
+/**
+ * BREP 拓扑运行时构建 — 从 OCCT solid 句柄生成 SelectorRuntime + mesh 数据
+ *
+ * 与 STEP 文件导入的拓扑提取使用**同源算法**：
+ *   meshShape + buildAssemblySelectorManifest + buildSelectorRuntime
+ *
+ * 不执行 STEP round-trip（export→import），直接在原始 solid 上运行。
+ * solid 句柄不被释放或修改——由调用方（宿主导出缓存）管理生命周期。
+ *
+ * 同时返回 mesh 数据（positions/normals/indices），用于更新场景几何，
+ * 保证 mesh 三角形与 topology faceRuns 一一对应。
+ */
+import type { BrepHandle, BrepMeshResult } from './engine/types.js';
+import type { BrepEngineApi } from './engine/primitives.js';
+import type { SelectorRuntime } from '../topology/types.js';
+/**
+ * Result of building BREP topology from an OCCT solid: the SelectorRuntime
+ * plus the mesh data produced by the same meshShape call.
+ */
+export interface SolidTopologyResult {
+    /** SelectorRuntime，与 STEP_T 使用同源算法生成 */
+    runtime: SelectorRuntime;
+    /** 与 topology 使用同一个 meshShape 输出的 mesh 数据 */
+    mesh: {
+        positions: Float32Array;
+        normals: Float32Array;
+        indices: Uint32Array;
+    };
+}
+/**
+ * 从已有的三角化结果（meshWithGroups）构建拓扑，不强制重新 meshShape。
+ *
+ * 用于 BREP 路径在场景已有三角化时复用——三角化属于几何数据生成，
+ * 拓扑构建应接收已有结果而非内部重新生成（需求 §2.0/§2.2、验收 3）。
+ *
+ * @param kernel          the OCCT kernel instance.
+ * @param solid           the OCCT solid handle (the shapeHandle for buildAssemblySelectorManifest).
+ * @param meshWithGroups  the existing tessellation result (from kernel.meshShape).
+ * @returns the assembled SelectorRuntime.
+ */
+export declare function buildTopologyFromMesh(kernel: BrepEngineApi, solid: BrepHandle, meshWithGroups: BrepMeshResult): SelectorRuntime;
+/**
+ * 从 OCCT solid 句柄生成 SelectorRuntime + mesh 数据。
+ *
+ * 算法与 STEP 文件导入路径（step-worker.ts → importStepToMesh →
+ * buildAssemblySelectorManifest → buildSelectorRuntime）完全同源，
+ * 区别仅在于 solid 来源是 OCCT 运算而非 STEP 文件导入。
+ *
+ * 三角化参数与显示 mesh 完全一致
+ * （linearDeflection=0.1, angularDeflection=2π/32≈0.196, relative=false）。
+ * 这与 solidToShape 的默认值一致，保证拓扑 faceRuns 与显示 mesh 三角形一一对应。
+ *
+ * 规则 1：拓扑数据生成所使用的 mesh，必须是当前用户看到的 mesh。
+ * 由于 OCCT meshShape 对同一 solid + 同一参数是确定性的，
+ * 此处重新三角化的结果与显示 mesh 完全相同。
+ * 如果已有三角化结果（meshShapeCache），应直接调 buildTopologyFromMesh 以复用。
+ *
+ * @param kernel  the OCCT kernel instance.
+ * @param solid   the OCCT solid handle (never released or modified).
+ * @returns the SelectorRuntime plus the mesh data from the same meshShape call.
+ */
+export declare function buildSolidTopologyRuntime(kernel: BrepEngineApi, solid: BrepHandle): SolidTopologyResult;
+//# sourceMappingURL=brep-topology.d.ts.map

package/dist/brep/brep-topology.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"brep-topology.d.ts","sourceRoot":"","sources":["../../src/brep/brep-topology.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAChE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AACxD,OAAO,KAAK,EAAE,eAAe,EAAoC,MAAM,mBAAmB,CAAA;AAK1F;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAClC,wCAAwC;IACxC,OAAO,EAAE,eAAe,CAAA;IACxB,6CAA6C;IAC7C,IAAI,EAAE;QACJ,SAAS,EAAE,YAAY,CAAA;QACvB,OAAO,EAAE,YAAY,CAAA;QACrB,OAAO,EAAE,WAAW,CAAA;KACrB,CAAA;CACF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,aAAa,EACrB,KAAK,EAAE,UAAU,EACjB,cAAc,EAAE,cAAc,GAC7B,eAAe,CAcjB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,aAAa,EACrB,KAAK,EAAE,UAAU,GAChB,mBAAmB,CA0BrB"}

package/dist/brep/brep-topology.js

@@ -0,0 +1,86 @@
+/**
+ * BREP 拓扑运行时构建 — 从 OCCT solid 句柄生成 SelectorRuntime + mesh 数据
+ *
+ * 与 STEP 文件导入的拓扑提取使用**同源算法**：
+ *   meshShape + buildAssemblySelectorManifest + buildSelectorRuntime
+ *
+ * 不执行 STEP round-trip（export→import），直接在原始 solid 上运行。
+ * solid 句柄不被释放或修改——由调用方（宿主导出缓存）管理生命周期。
+ *
+ * 同时返回 mesh 数据（positions/normals/indices），用于更新场景几何，
+ * 保证 mesh 三角形与 topology faceRuns 一一对应。
+ */
+import { computeEffectiveDeflection } from '../occt-kernel/occtKernel.js';
+import { buildAssemblySelectorManifest } from '../occt-kernel/topologyExt.js';
+import { buildSelectorRuntime } from '../topology/build-selector-runtime.js';
+/**
+ * 从已有的三角化结果（meshWithGroups）构建拓扑，不强制重新 meshShape。
+ *
+ * 用于 BREP 路径在场景已有三角化时复用——三角化属于几何数据生成，
+ * 拓扑构建应接收已有结果而非内部重新生成（需求 §2.0/§2.2、验收 3）。
+ *
+ * @param kernel          the OCCT kernel instance.
+ * @param solid           the OCCT solid handle (the shapeHandle for buildAssemblySelectorManifest).
+ * @param meshWithGroups  the existing tessellation result (from kernel.meshShape).
+ * @returns the assembled SelectorRuntime.
+ */
+export function buildTopologyFromMesh(kernel, solid, meshWithGroups) {
+    // 生成拓扑清单（与 STEP_T 同源：buildAssemblySelectorManifest）
+    const result = buildAssemblySelectorManifest(kernel, [{
+            labelPath: 'o1',
+            shapeHandle: solid,
+            meshWithGroups,
+        }]);
+    // 构建 SelectorRuntime
+    const bundle = {
+        manifest: result.manifest,
+        buffers: result.buffers,
+    };
+    return buildSelectorRuntime(bundle, { scale: 1 });
+}
+/**
+ * 从 OCCT solid 句柄生成 SelectorRuntime + mesh 数据。
+ *
+ * 算法与 STEP 文件导入路径（step-worker.ts → importStepToMesh →
+ * buildAssemblySelectorManifest → buildSelectorRuntime）完全同源，
+ * 区别仅在于 solid 来源是 OCCT 运算而非 STEP 文件导入。
+ *
+ * 三角化参数与显示 mesh 完全一致
+ * （linearDeflection=0.1, angularDeflection=2π/32≈0.196, relative=false）。
+ * 这与 solidToShape 的默认值一致，保证拓扑 faceRuns 与显示 mesh 三角形一一对应。
+ *
+ * 规则 1：拓扑数据生成所使用的 mesh，必须是当前用户看到的 mesh。
+ * 由于 OCCT meshShape 对同一 solid + 同一参数是确定性的，
+ * 此处重新三角化的结果与显示 mesh 完全相同。
+ * 如果已有三角化结果（meshShapeCache），应直接调 buildTopologyFromMesh 以复用。
+ *
+ * @param kernel  the OCCT kernel instance.
+ * @param solid   the OCCT solid handle (never released or modified).
+ * @returns the SelectorRuntime plus the mesh data from the same meshShape call.
+ */
+export function buildSolidTopologyRuntime(kernel, solid) {
+    // 1. 三角化（含 faceGroups）——与显示 mesh 使用相同的 deflection 参数
+    //    solidToShape 默认 angularDeflection = 2π/32 ≈ 0.196
+    const DISPLAY_ANGULAR_DEFLECTION = (2 * Math.PI) / 32;
+    const eff = computeEffectiveDeflection(kernel, solid, {
+        linearDeflection: 0.1,
+        angularDeflection: DISPLAY_ANGULAR_DEFLECTION,
+        relative: false,
+    });
+    const mesh = kernel.meshShape(solid, {
+        linearDeflection: eff.linearDeflection,
+        angularDeflection: eff.angularDeflection,
+    });
+    // 2. 从已有三角化结果构建拓扑（复用 buildTopologyFromMesh）
+    const runtime = buildTopologyFromMesh(kernel, solid, mesh);
+    // 3. 返回 runtime + mesh（同一个 meshShape 输出）
+    return {
+        runtime,
+        mesh: {
+            positions: mesh.positions.slice(),
+            normals: mesh.normals.slice(),
+            indices: mesh.indices.slice(),
+        },
+    };
+}
+//# sourceMappingURL=brep-topology.js.map

package/dist/brep/brep-topology.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"brep-topology.js","sourceRoot":"","sources":["../../src/brep/brep-topology.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAKH,OAAO,EAAE,0BAA0B,EAAE,MAAM,2BAA2B,CAAA;AACtE,OAAO,EAAE,6BAA6B,EAAE,MAAM,4BAA4B,CAAA;AAC1E,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAA;AAiBzE;;;;;;;;;;GAUG;AACH,MAAM,UAAU,qBAAqB,CACnC,MAAqB,EACrB,KAAiB,EACjB,cAA8B;IAE9B,oDAAoD;IACpD,MAAM,MAAM,GAAG,6BAA6B,CAAC,MAAM,EAAE,CAAC;YACpD,SAAS,EAAE,IAAI;YACf,WAAW,EAAE,KAAK;YAClB,cAAc;SACf,CAAC,CAAC,CAAA;IAEH,qBAAqB;IACrB,MAAM,MAAM,GAAmB;QAC7B,QAAQ,EAAE,MAAM,CAAC,QAAuC;QACxD,OAAO,EAAE,MAAM,CAAC,OAAiE;KAClF,CAAA;IACD,OAAO,oBAAoB,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,CAAA;AACnD,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,yBAAyB,CACvC,MAAqB,EACrB,KAAiB;IAEjB,qDAAqD;IACrD,uDAAuD;IACvD,MAAM,0BAA0B,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,EAAE,CAAC,GAAG,EAAE,CAAA;IACrD,MAAM,GAAG,GAAG,0BAA0B,CAAC,MAAM,EAAE,KAAK,EAAE;QACpD,gBAAgB,EAAE,GAAG;QACrB,iBAAiB,EAAE,0BAA0B;QAC7C,QAAQ,EAAE,KAAK;KAChB,CAAC,CAAA;IACF,MAAM,IAAI,GAAmB,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE;QACnD,gBAAgB,EAAE,GAAG,CAAC,gBAAgB;QACtC,iBAAiB,EAAE,GAAG,CAAC,iBAAiB;KACzC,CAAC,CAAA;IAEF,4CAA4C;IAC5C,MAAM,OAAO,GAAG,qBAAqB,CAAC,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,CAAA;IAE1D,yCAAyC;IACzC,OAAO;QACL,OAAO;QACP,IAAI,EAAE;YACJ,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE;YACjC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE;YAC7B,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE;SAC9B;KACF,CAAA;AACH,CAAC","sourcesContent":["/**\n * BREP 拓扑运行时构建 — 从 OCCT solid 句柄生成 SelectorRuntime + mesh 数据\n *\n * 与 STEP 文件导入的拓扑提取使用**同源算法**：\n *   meshShape + buildAssemblySelectorManifest + buildSelectorRuntime\n *\n * 不执行 STEP round-trip（export→import），直接在原始 solid 上运行。\n * solid 句柄不被释放或修改——由调用方（宿主导出缓存）管理生命周期。\n *\n * 同时返回 mesh 数据（positions/normals/indices），用于更新场景几何，\n * 保证 mesh 三角形与 topology faceRuns 一一对应。\n */\n\nimport type { BrepHandle, BrepMeshResult } from './engine/types'\nimport type { BrepEngineApi } from './engine/primitives'\nimport type { SelectorRuntime, SelectorBundle, SelectorManifest } from '../topology/types'\nimport { computeEffectiveDeflection } from '../occt-kernel/occtKernel'\nimport { buildAssemblySelectorManifest } from '../occt-kernel/topologyExt'\nimport { buildSelectorRuntime } from '../topology/build-selector-runtime'\n\n/**\n * Result of building BREP topology from an OCCT solid: the SelectorRuntime\n * plus the mesh data produced by the same meshShape call.\n */\nexport interface SolidTopologyResult {\n  /** SelectorRuntime，与 STEP_T 使用同源算法生成 */\n  runtime: SelectorRuntime\n  /** 与 topology 使用同一个 meshShape 输出的 mesh 数据 */\n  mesh: {\n    positions: Float32Array\n    normals: Float32Array\n    indices: Uint32Array\n  }\n}\n\n/**\n * 从已有的三角化结果（meshWithGroups）构建拓扑，不强制重新 meshShape。\n *\n * 用于 BREP 路径在场景已有三角化时复用——三角化属于几何数据生成，\n * 拓扑构建应接收已有结果而非内部重新生成（需求 §2.0/§2.2、验收 3）。\n *\n * @param kernel          the OCCT kernel instance.\n * @param solid           the OCCT solid handle (the shapeHandle for buildAssemblySelectorManifest).\n * @param meshWithGroups  the existing tessellation result (from kernel.meshShape).\n * @returns the assembled SelectorRuntime.\n */\nexport function buildTopologyFromMesh(\n  kernel: BrepEngineApi,\n  solid: BrepHandle,\n  meshWithGroups: BrepMeshResult,\n): SelectorRuntime {\n  // 生成拓扑清单（与 STEP_T 同源：buildAssemblySelectorManifest）\n  const result = buildAssemblySelectorManifest(kernel, [{\n    labelPath: 'o1',\n    shapeHandle: solid,\n    meshWithGroups,\n  }])\n\n  // 构建 SelectorRuntime\n  const bundle: SelectorBundle = {\n    manifest: result.manifest as unknown as SelectorManifest,\n    buffers: result.buffers as unknown as import('../topology/types').SelectorBuffers,\n  }\n  return buildSelectorRuntime(bundle, { scale: 1 })\n}\n\n/**\n * 从 OCCT solid 句柄生成 SelectorRuntime + mesh 数据。\n *\n * 算法与 STEP 文件导入路径（step-worker.ts → importStepToMesh →\n * buildAssemblySelectorManifest → buildSelectorRuntime）完全同源，\n * 区别仅在于 solid 来源是 OCCT 运算而非 STEP 文件导入。\n *\n * 三角化参数与显示 mesh 完全一致\n * （linearDeflection=0.1, angularDeflection=2π/32≈0.196, relative=false）。\n * 这与 solidToShape 的默认值一致，保证拓扑 faceRuns 与显示 mesh 三角形一一对应。\n *\n * 规则 1：拓扑数据生成所使用的 mesh，必须是当前用户看到的 mesh。\n * 由于 OCCT meshShape 对同一 solid + 同一参数是确定性的，\n * 此处重新三角化的结果与显示 mesh 完全相同。\n * 如果已有三角化结果（meshShapeCache），应直接调 buildTopologyFromMesh 以复用。\n *\n * @param kernel  the OCCT kernel instance.\n * @param solid   the OCCT solid handle (never released or modified).\n * @returns the SelectorRuntime plus the mesh data from the same meshShape call.\n */\nexport function buildSolidTopologyRuntime(\n  kernel: BrepEngineApi,\n  solid: BrepHandle,\n): SolidTopologyResult {\n  // 1. 三角化（含 faceGroups）——与显示 mesh 使用相同的 deflection 参数\n  //    solidToShape 默认 angularDeflection = 2π/32 ≈ 0.196\n  const DISPLAY_ANGULAR_DEFLECTION = (2 * Math.PI) / 32\n  const eff = computeEffectiveDeflection(kernel, solid, {\n    linearDeflection: 0.1,\n    angularDeflection: DISPLAY_ANGULAR_DEFLECTION,\n    relative: false,\n  })\n  const mesh: BrepMeshResult = kernel.meshShape(solid, {\n    linearDeflection: eff.linearDeflection,\n    angularDeflection: eff.angularDeflection,\n  })\n\n  // 2. 从已有三角化结果构建拓扑（复用 buildTopologyFromMesh）\n  const runtime = buildTopologyFromMesh(kernel, solid, mesh)\n\n  // 3. 返回 runtime + mesh（同一个 meshShape 输出）\n  return {\n    runtime,\n    mesh: {\n      positions: mesh.positions.slice(),\n      normals: mesh.normals.slice(),\n      indices: mesh.indices.slice(),\n    },\n  }\n}\n"]}

package/dist/brep/brep-utils.d.ts

@@ -0,0 +1,25 @@
+/**
+ * BREP 通用工具函数
+ */
+import type { BrepHandle } from './engine/types.js';
+import type { BrepEngineApi } from './engine/primitives.js';
+import type { Vec3 } from '../mesh/types.js';
+/**
+ * 获取 solid 的包围盒。
+ *
+ * 浏览器 WASM 环境中，布尔运算（cut/fuse）产生的 compound shape
+ * 可能使 getBoundingBox 抛出异常。此函数提供与 topologyExt.ts
+ * 中 tryGetBoundingBox 一致的容错策略：
+ * 1. 尝试 getBoundingBox(useTriangulation=false)
+ * 2. 尝试 getBoundingBox(useTriangulation=true)
+ * 3. 两者均失败 → console.error + throw（不再静默返回默认 bbox）
+ *
+ * @param kernel  the OCCT kernel instance.
+ * @param solid   the solid whose bounding box to compute.
+ * @returns the solid's bounding box as { min, max } corner vectors.
+ */
+export declare function getSolidBoundingBox(kernel: BrepEngineApi, solid: BrepHandle): {
+    min: Vec3;
+    max: Vec3;
+};
+//# sourceMappingURL=brep-utils.d.ts.map

package/dist/brep/brep-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"brep-utils.d.ts","sourceRoot":"","sources":["../../src/brep/brep-utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAChD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AACxD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAA;AAEzC;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,aAAa,EAAE,KAAK,EAAE,UAAU,GAAG;IAAE,GAAG,EAAE,IAAI,CAAC;IAAC,GAAG,EAAE,IAAI,CAAA;CAAE,CAqBtG"}

package/dist/brep/brep-utils.js

@@ -0,0 +1,42 @@
+/**
+ * BREP 通用工具函数
+ */
+/**
+ * 获取 solid 的包围盒。
+ *
+ * 浏览器 WASM 环境中，布尔运算（cut/fuse）产生的 compound shape
+ * 可能使 getBoundingBox 抛出异常。此函数提供与 topologyExt.ts
+ * 中 tryGetBoundingBox 一致的容错策略：
+ * 1. 尝试 getBoundingBox(useTriangulation=false)
+ * 2. 尝试 getBoundingBox(useTriangulation=true)
+ * 3. 两者均失败 → console.error + throw（不再静默返回默认 bbox）
+ *
+ * @param kernel  the OCCT kernel instance.
+ * @param solid   the solid whose bounding box to compute.
+ * @returns the solid's bounding box as { min, max } corner vectors.
+ */
+export function getSolidBoundingBox(kernel, solid) {
+    try {
+        const bbox = kernel.getBoundingBox(solid, false);
+        return {
+            min: [bbox.xmin, bbox.ymin, bbox.zmin],
+            max: [bbox.xmax, bbox.ymax, bbox.zmax],
+        };
+    }
+    catch {
+        // compound shape 可能需要三角化才能计算 bbox
+    }
+    try {
+        const bbox = kernel.getBoundingBox(solid, true);
+        return {
+            min: [bbox.xmin, bbox.ymin, bbox.zmin],
+            max: [bbox.xmax, bbox.ymax, bbox.zmax],
+        };
+    }
+    catch (err) {
+        // 两种方式都失败 → 上报并抛错（不再静默返回默认 bbox）
+        console.error('[getSolidBoundingBox] both getBoundingBox attempts failed for solid:', err);
+        throw new Error(`[getSolidBoundingBox] failed to compute bounding box for solid`, { cause: err });
+    }
+}
+//# sourceMappingURL=brep-utils.js.map

package/dist/brep/brep-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"brep-utils.js","sourceRoot":"","sources":["../../src/brep/brep-utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAMH;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,mBAAmB,CAAC,MAAqB,EAAE,KAAiB;IAC1E,IAAI,CAAC;QACH,MAAM,IAAI,GAAG,MAAM,CAAC,cAAc,CAAC,KAAK,EAAE,KAAK,CAAC,CAAA;QAChD,OAAO;YACL,GAAG,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC;YACtC,GAAG,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC;SACvC,CAAA;IACH,CAAC;IAAC,MAAM,CAAC;QACP,kCAAkC;IACpC,CAAC;IACD,IAAI,CAAC;QACH,MAAM,IAAI,GAAG,MAAM,CAAC,cAAc,CAAC,KAAK,EAAE,IAAI,CAAC,CAAA;QAC/C,OAAO;YACL,GAAG,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC;YACtC,GAAG,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC;SACvC,CAAA;IACH,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,iCAAiC;QACjC,OAAO,CAAC,KAAK,CAAC,sEAAsE,EAAE,GAAG,CAAC,CAAA;QAC1F,MAAM,IAAI,KAAK,CAAC,gEAAgE,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAA;IACnG,CAAC;AACH,CAAC","sourcesContent":["/**\n * BREP 通用工具函数\n */\n\nimport type { BrepHandle } from './engine/types'\nimport type { BrepEngineApi } from './engine/primitives'\nimport type { Vec3 } from '../mesh/types'\n\n/**\n * 获取 solid 的包围盒。\n *\n * 浏览器 WASM 环境中，布尔运算（cut/fuse）产生的 compound shape\n * 可能使 getBoundingBox 抛出异常。此函数提供与 topologyExt.ts\n * 中 tryGetBoundingBox 一致的容错策略：\n * 1. 尝试 getBoundingBox(useTriangulation=false)\n * 2. 尝试 getBoundingBox(useTriangulation=true)\n * 3. 两者均失败 → console.error + throw（不再静默返回默认 bbox）\n *\n * @param kernel  the OCCT kernel instance.\n * @param solid   the solid whose bounding box to compute.\n * @returns the solid's bounding box as { min, max } corner vectors.\n */\nexport function getSolidBoundingBox(kernel: BrepEngineApi, solid: BrepHandle): { min: Vec3; max: Vec3 } {\n  try {\n    const bbox = kernel.getBoundingBox(solid, false)\n    return {\n      min: [bbox.xmin, bbox.ymin, bbox.zmin],\n      max: [bbox.xmax, bbox.ymax, bbox.zmax],\n    }\n  } catch {\n    // compound shape 可能需要三角化才能计算 bbox\n  }\n  try {\n    const bbox = kernel.getBoundingBox(solid, true)\n    return {\n      min: [bbox.xmin, bbox.ymin, bbox.zmin],\n      max: [bbox.xmax, bbox.ymax, bbox.zmax],\n    }\n  } catch (err) {\n    // 两种方式都失败 → 上报并抛错（不再静默返回默认 bbox）\n    console.error('[getSolidBoundingBox] both getBoundingBox attempts failed for solid:', err)\n    throw new Error(`[getSolidBoundingBox] failed to compute bounding box for solid`, { cause: err })\n  }\n}\n"]}

package/dist/brep/engine/adapters/brep-mock.d.ts

@@ -0,0 +1,24 @@
+/**
+ * engine/adapters/memory — 内存模拟 BREP 引擎（第二引擎，引擎切换验证用）
+ *
+ *
+ * 目的：证明「引擎可切换」——不是生产内核，是注册表机制的验证载体。
+ * 与 occt 适配器（adapters/occt.ts）同构注册；同一段 faijs 代码在
+ * occt / memory 两个引擎下都能执行（构造 → 变换 → 布尔 → 三角化 → 导出），
+ * 通过 mock STEP 文本标记区分当前引擎。
+ *
+ * 实现形态：句柄为自增 number；每条形状记录 { kind, bbox, tag }。
+ * 只实现引擎切换测试所需的方法面（原语/变换/布尔/网格化/导出），
+ * 其余方法抛「not implemented」——缺失即暴露，绝不伪造（§7.5 语义）。
+ */
+import type { BrepEngineApi } from '../primitives.js';
+/** brep-mock engine registration id. */
+export declare const BREP_MOCK_ENGINE_ID = "brep_mock";
+/**
+ * Build an in-memory mock BREP engine (a BrepEngineApi subset).
+ * @returns the mock in-memory BREP engine API.
+ */
+export declare function createBrepMockApi(): BrepEngineApi;
+/** Assemble the brep-mock engine (sync registration — no async init). */
+export declare function registerBrepMockEngine(): void;
+//# sourceMappingURL=brep-mock.d.ts.map

package/dist/brep/engine/adapters/brep-mock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"brep-mock.d.ts","sourceRoot":"","sources":["../../../../src/brep/engine/adapters/brep-mock.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAaH,OAAO,KAAK,EAAE,aAAa,EAAgC,MAAM,eAAe,CAAA;AAEhF,wCAAwC;AACxC,eAAO,MAAM,mBAAmB,cAAc,CAAA;AAoC9C;;;GAGG;AACH,wBAAgB,iBAAiB,IAAI,aAAa,CAsRjD;AAED,yEAAyE;AACzE,wBAAgB,sBAAsB,IAAI,IAAI,CAQ7C"}

package/dist/brep/engine/adapters/brep-mock.js

@@ -0,0 +1,303 @@
+/**
+ * engine/adapters/memory — 内存模拟 BREP 引擎（第二引擎，引擎切换验证用）
+ *
+ *
+ * 目的：证明「引擎可切换」——不是生产内核，是注册表机制的验证载体。
+ * 与 occt 适配器（adapters/occt.ts）同构注册；同一段 faijs 代码在
+ * occt / memory 两个引擎下都能执行（构造 → 变换 → 布尔 → 三角化 → 导出），
+ * 通过 mock STEP 文本标记区分当前引擎。
+ *
+ * 实现形态：句柄为自增 number；每条形状记录 { kind, bbox, tag }。
+ * 只实现引擎切换测试所需的方法面（原语/变换/布尔/网格化/导出），
+ * 其余方法抛「not implemented」——缺失即暴露，绝不伪造（§7.5 语义）。
+ */
+import { registerBrepEngine } from '../registry.js';
+/** brep-mock engine registration id. */
+export const BREP_MOCK_ENGINE_ID = 'brep_mock';
+function bboxOf(kind, size) {
+    const [x, y, z] = size;
+    return { xmin: -x / 2, ymin: -y / 2, zmin: -z / 2, xmax: x / 2, ymax: y / 2, zmax: z / 2 };
+}
+/** 1×1×1 单位盒三角化（8 顶点 / 12 三角形；memory 引擎的 meshShape 输出）。 */
+const UNIT_BOX_POSITIONS = new Float32Array([
+    -0.5, -0.5, -0.5, 0.5, -0.5, -0.5, 0.5, 0.5, -0.5, -0.5, 0.5, -0.5,
+    -0.5, -0.5, 0.5, 0.5, -0.5, 0.5, 0.5, 0.5, 0.5, -0.5, 0.5, 0.5,
+]);
+const UNIT_BOX_INDICES = new Uint32Array([
+    0, 2, 1, 0, 3, 2, 4, 5, 6, 4, 6, 7, 0, 1, 5, 0, 5, 4,
+    1, 2, 6, 1, 6, 5, 2, 3, 7, 2, 7, 6, 3, 0, 4, 3, 4, 7,
+]);
+function unitBoxMesh() {
+    return {
+        positions: new Float32Array(UNIT_BOX_POSITIONS),
+        normals: new Float32Array(24), // 占位法线（切换测试不校验法线）
+        indices: new Uint32Array(UNIT_BOX_INDICES),
+        vertexCount: 8,
+        triangleCount: 12,
+    };
+}
+/**
+ * Build an in-memory mock BREP engine (a BrepEngineApi subset).
+ * @returns the mock in-memory BREP engine API.
+ */
+export function createBrepMockApi() {
+    const shapes = new Map();
+    let nextHandle = 1;
+    const alloc = (shape) => {
+        const h = nextHandle;
+        nextHandle += 1;
+        shapes.set(h, shape);
+        return h;
+    };
+    const need = (h, method) => {
+        const s = shapes.get(h);
+        if (!s)
+            throw new Error(`[brep-mock-engine] ${method}: unknown handle ${h}`);
+        return s;
+    };
+    const unsupported = (method) => {
+        throw new Error(`[brep-mock-engine] ${method}() not implemented — engine-switch test only`);
+    };
+    /** 布尔合并 bbox（fuse/cut/common 的近似包围盒）。 */
+    const mergeBbox = (a, b) => ({
+        xmin: Math.min(a.xmin, b.xmin),
+        ymin: Math.min(a.ymin, b.ymin),
+        zmin: Math.min(a.zmin, b.zmin),
+        xmax: Math.max(a.xmax, b.xmax),
+        ymax: Math.max(a.ymax, b.ymax),
+        zmax: Math.max(a.zmax, b.zmax),
+    });
+    const mockXcafDocument = () => ({
+        addShape: () => undefined,
+        exportSTEP: () => mockStepExport(),
+        close: () => undefined,
+    });
+    const mockStepExport = () => 'brep-mock-engine STEP (mock)\n' +
+        '// Not real STEP — marker of the in-memory mock BREP engine, for engine-switch tests only.\n' +
+        'FILE_DESCRIPTION(("brep-mock-engine"), "2;1");';
+    const primitive = (kind, size, tag) => alloc({ kind, bbox: bboxOf(kind, size), tag });
+    const primitives = {
+        // ── 生命周期 ──
+        release: () => undefined,
+        // ── 实体图元 ──
+        makeBox: (dx, dy, dz) => primitive('box', [dx, dy, dz], `box ${dx}x${dy}x${dz}`),
+        makeBoxFromCorners: (c1, c2) => primitive('box', [Math.abs(c2.x - c1.x), Math.abs(c2.y - c1.y), Math.abs(c2.z - c1.z)], `box (${c1.x},${c1.y},${c1.z})→(${c2.x},${c2.y},${c2.z})`),
+        makeCylinder: (radius, height) => primitive('cylinder', [radius * 2, radius * 2, height], `cylinder r=${radius} h=${height}`),
+        makeSphere: (radius) => primitive('sphere', [radius * 2, radius * 2, radius * 2], `sphere r=${radius}`),
+        makeCone: (r1, r2, height) => primitive('cone', [Math.max(r1, r2) * 2, Math.max(r1, r2) * 2, height], `cone r1=${r1} r2=${r2} h=${height}`),
+        makeRectangle: (width, height) => primitive('face', [width, height, 0], `rectangle ${width}x${height}`),
+        // ── 造型运算 ──
+        extrude: (shape, dx, dy, dz) => {
+            const s = need(shape, 'extrude');
+            return alloc({ kind: 'solid', bbox: { ...s.bbox, xmax: s.bbox.xmax + dx, ymax: s.bbox.ymax + dy, zmax: s.bbox.zmax + dz }, tag: `extrude(${s.tag})` });
+        },
+        loft: () => unsupported('loft'),
+        // ── 倒角与圆角（mock：只重打标签/复制，不做真几何；引擎切换测试覆盖签名面） ──
+        chamfer: (solid, edges, distance) => {
+            const s = need(solid, 'chamfer');
+            return alloc({ kind: 'solid', bbox: { ...s.bbox }, tag: `chamfer(${s.tag},d=${distance},e=${edges.length})` });
+        },
+        chamferDistAngle: (solid, edges, distance, angleDeg) => {
+            const s = need(solid, 'chamferDistAngle');
+            return alloc({ kind: 'solid', bbox: { ...s.bbox }, tag: `chamferDA(${s.tag},d=${distance},a=${angleDeg},e=${edges.length})` });
+        },
+        fillet: (solid, edges, radius) => {
+            const s = need(solid, 'fillet');
+            return alloc({ kind: 'solid', bbox: { ...s.bbox }, tag: `fillet(${s.tag},r=${radius},e=${edges.length})` });
+        },
+        filletVariable: (solid, edge, startRadius, endRadius) => {
+            const s = need(solid, 'filletVariable');
+            return alloc({ kind: 'solid', bbox: { ...s.bbox }, tag: `filletVar(${s.tag},r=${startRadius}-${endRadius},e=1)` });
+        },
+        filletWithHistory: (solid, edges, radius, _hashes, _upper) => {
+            const s = need(solid, 'filletWithHistory');
+            const result = alloc({ kind: 'solid', bbox: { ...s.bbox }, tag: `filletWH(${s.tag},r=${radius},e=${edges.length})` });
+            const evo = { result, modified: [], generated: [], deleted: [] };
+            return evo;
+        },
+        chamferWithHistory: (solid, edges, distance, _hashes, _upper) => {
+            const s = need(solid, 'chamferWithHistory');
+            const result = alloc({ kind: 'solid', bbox: { ...s.bbox }, tag: `chamferWH(${s.tag},d=${distance},e=${edges.length})` });
+            const evo = { result, modified: [], generated: [], deleted: [] };
+            return evo;
+        },
+        // ── 布尔与分割 ──
+        fuse: (a, b) => {
+            const sa = need(a, 'fuse');
+            const sb = need(b, 'fuse');
+            return alloc({ kind: 'solid', bbox: mergeBbox(sa.bbox, sb.bbox), tag: `fuse(${sa.tag},${sb.tag})` });
+        },
+        cut: (a, b) => {
+            const sa = need(a, 'cut');
+            return alloc({ kind: 'solid', bbox: { ...sa.bbox }, tag: `cut(${sa.tag},#${b})` });
+        },
+        common: (a, b) => {
+            const sa = need(a, 'common');
+            const sb = need(b, 'common');
+            return alloc({ kind: 'solid', bbox: mergeBbox(sa.bbox, sb.bbox), tag: `common(${sa.tag},${sb.tag})` });
+        },
+        intersect: (a, b) => {
+            const sa = need(a, 'intersect');
+            const sb = need(b, 'intersect');
+            return alloc({ kind: 'solid', bbox: mergeBbox(sa.bbox, sb.bbox), tag: `intersect(${sa.tag},${sb.tag})` });
+        },
+        section: () => unsupported('section'),
+        fuseAll: (shapesIn) => {
+            let bbox = null;
+            let tag = 'fuseAll(';
+            for (const s of shapesIn) {
+                const rec = need(s, 'fuseAll');
+                bbox = bbox ? mergeBbox(bbox, rec.bbox) : { ...rec.bbox };
+                tag += `${rec.tag},`;
+            }
+            return alloc({ kind: 'solid', bbox: bbox ?? bboxOf('solid', [0, 0, 0]), tag: `${tag})` });
+        },
+        // ── 变换 ──
+        translate: (shape, dx, dy, dz) => {
+            const s = need(shape, 'translate');
+            return alloc({
+                kind: 'solid',
+                bbox: {
+                    xmin: s.bbox.xmin + dx, ymin: s.bbox.ymin + dy, zmin: s.bbox.zmin + dz,
+                    xmax: s.bbox.xmax + dx, ymax: s.bbox.ymax + dy, zmax: s.bbox.zmax + dz,
+                },
+                tag: `translate(${s.tag},${dx},${dy},${dz})`,
+            });
+        },
+        scale: (shape, _center, factor) => {
+            const s = need(shape, 'scale');
+            return alloc({ kind: 'solid', bbox: {
+                    xmin: s.bbox.xmin * factor, ymin: s.bbox.ymin * factor, zmin: s.bbox.zmin * factor,
+                    xmax: s.bbox.xmax * factor, ymax: s.bbox.ymax * factor, zmax: s.bbox.zmax * factor,
+                }, tag: `scale(${s.tag},${factor})` });
+        },
+        transform: (shape, _matrix) => {
+            const s = need(shape, 'transform');
+            return alloc({ kind: 'solid', bbox: { ...s.bbox }, tag: `transform(${s.tag})` });
+        },
+        located: (shape, _matrix) => {
+            const s = need(shape, 'located');
+            return alloc({ kind: 'solid', bbox: { ...s.bbox }, tag: `located(${s.tag})` });
+        },
+        generalTransform: (shape, _matrix) => {
+            const s = need(shape, 'generalTransform');
+            return alloc({ kind: 'solid', bbox: { ...s.bbox }, tag: `generalTransform(${s.tag})` });
+        },
+        copy: (shape) => {
+            const s = need(shape, 'copy');
+            return alloc({ kind: 'solid', bbox: { ...s.bbox }, tag: `copy(${s.tag})` });
+        },
+        // ── 曲线构造 ──
+        makeLineEdge: (start, end) => alloc({ kind: 'edge',
+            bbox: {
+                xmin: Math.min(start.x, end.x), ymin: Math.min(start.y, end.y), zmin: Math.min(start.z, end.z),
+                xmax: Math.max(start.x, end.x), ymax: Math.max(start.y, end.y), zmax: Math.max(start.z, end.z),
+            },
+            tag: `line(${start.x},${start.y},${start.z})→(${end.x},${end.y},${end.z})` }),
+        makeArcEdge: (start, mid, end) => {
+            const xs = [start.x, mid.x, end.x];
+            const ys = [start.y, mid.y, end.y];
+            const zs = [start.z, mid.z, end.z];
+            return alloc({ kind: 'edge', bbox: {
+                    xmin: Math.min(...xs), ymin: Math.min(...ys), zmin: Math.min(...zs),
+                    xmax: Math.max(...xs), ymax: Math.max(...ys), zmax: Math.max(...zs),
+                }, tag: `arc` });
+        },
+        makeBezierEdge: () => alloc({ kind: 'edge', bbox: bboxOf('edge', [1, 1, 1]), tag: 'bezier' }),
+        // ── 拓扑构造 ──
+        makeWire: (edges) => alloc({ kind: 'wire', bbox: edges.length > 0 ? { ...need(edges[0], 'makeWire').bbox } : bboxOf('wire', [0, 0, 0]), tag: `wire(${edges.length})` }),
+        makeFace: (wire) => alloc({ kind: 'face', bbox: { ...need(wire, 'makeFace').bbox }, tag: `face(#${wire})` }),
+        makeCompound: (parts) => {
+            let bbox = null;
+            for (const p of parts) {
+                const rec = need(p, 'makeCompound');
+                bbox = bbox ? mergeBbox(bbox, rec.bbox) : { ...rec.bbox };
+            }
+            return alloc({ kind: 'compound', bbox: bbox ?? bboxOf('compound', [0, 0, 0]), tag: `compound(${parts.length})` });
+        },
+        sewAndSolidify: () => alloc({ kind: 'solid', bbox: bboxOf('solid', [1, 1, 1]), tag: 'sewAndSolidify' }),
+        buildTriFace: () => alloc({ kind: 'face', bbox: bboxOf('face', [1, 1, 0]), tag: 'triFace' }),
+        addHolesInFace: (face) => alloc({ kind: 'face', bbox: { ...need(face, 'addHolesInFace').bbox }, tag: `holedFace(#${face})` }),
+        // ── 三角化（BREP→mesh 唯一出口） ──
+        meshShape: () => unitBoxMesh(),
+        wireframe: () => ({ points: new Float32Array(0), edgeGroups: new Int32Array(0), pointCount: 0, edgeCount: 0 }),
+        // ── 拓扑查询 ──
+        getSubShapes: () => [],
+        queryBatch: (shapesIn) => shapesIn.map(() => ({ area: 0 })),
+        subShapeHashes: () => [],
+        hashCode: (shape) => shape % 2147483647,
+        isSame: (a, b) => a === b,
+        isSolid: () => true,
+        shapeOrientation: () => 'forward',
+        // ── 几何求值 ──
+        curveType: () => 'line',
+        curvePointAtParam: () => ({ x: 0, y: 0, z: 0 }),
+        curveTangent: () => ({ x: 1, y: 0, z: 0 }),
+        curveParameters: () => ({ first: 0, last: 1 }),
+        curveIsClosed: () => false,
+        curveLength: () => 0,
+        surfaceType: () => 'plane',
+        surfaceNormal: () => ({ x: 0, y: 0, z: 1 }),
+        pointOnSurface: () => ({ x: 0, y: 0, z: 0 }),
+        uvBounds: () => ({ uMin: 0, uMax: 1, vMin: 0, vMax: 1 }),
+        getSurfaceCenterOfMass: () => ({ x: 0, y: 0, z: 0 }),
+        getFaceCylinderData: () => null,
+        getNurbsCurveData: () => null,
+        // ── 测量 ──
+        getBoundingBox: (shape) => ({ ...need(shape, 'getBoundingBox').bbox }),
+        getVolume: (shape) => {
+            const b = need(shape, 'getVolume').bbox;
+            return (b.xmax - b.xmin) * (b.ymax - b.ymin) * (b.zmax - b.zmin);
+        },
+        getCenterOfMass: (shape) => {
+            const b = need(shape, 'getCenterOfMass').bbox;
+            return { x: (b.xmin + b.xmax) / 2, y: (b.ymin + b.ymax) / 2, z: (b.zmin + b.zmax) / 2 };
+        },
+        // ── 校验与修复 ──
+        isValid: () => true,
+        unifySameDomain: (shape) => shape,
+        healSolid: (shape) => shape,
+        fixShape: (shape) => shape,
+        fixFaceOrientations: (shape) => shape,
+        removeDegenerateEdges: (shape) => shape,
+        // ── IO ──
+        importStep: () => alloc({ kind: 'solid', bbox: bboxOf('solid', [10, 10, 10]), tag: 'importStep(mock)' }),
+        exportStep: (shape) => {
+            const s = need(shape, 'exportStep');
+            return `brep-mock-engine STEP (mock)\nshape #${shape}: ${s.tag}\nFILE_DESCRIPTION(("brep-mock-engine"), "2;1");`;
+        },
+        importStl: () => alloc({ kind: 'solid', bbox: bboxOf('solid', [10, 10, 10]), tag: 'importStl(mock)' }),
+        fromBREP: () => alloc({ kind: 'solid', bbox: bboxOf('solid', [10, 10, 10]), tag: 'fromBREP(mock)' }),
+        // ── 面演化（可选能力槽：memory 不支持 → 明确缺失暴露） ──
+        cutWithHistory: (a, b, _hashes, _upper) => {
+            const result = primitives.cut(a, b);
+            const evo = { result, modified: [], generated: [], deleted: [] };
+            return evo;
+        },
+        fuseWithHistory: (a, b, _hashes, _upper) => {
+            const result = primitives.fuse(a, b);
+            const evo = { result, modified: [], generated: [], deleted: [] };
+            return evo;
+        },
+        intersectWithHistory: (a, b, _hashes, _upper) => {
+            const result = primitives.intersect(a, b);
+            const evo = { result, modified: [], generated: [], deleted: [] };
+            return evo;
+        },
+        // ── XCAF 装配（mock 文档） ──
+        createXCAFDocument: () => mockXcafDocument(),
+        importXCAFFromSTEP: () => mockXcafDocument(),
+    };
+    return primitives;
+}
+/** Assemble the brep-mock engine (sync registration — no async init). */
+export function registerBrepMockEngine() {
+    registerBrepEngine(BREP_MOCK_ENGINE_ID, async () => ({
+        id: BREP_MOCK_ENGINE_ID,
+        primitives: createBrepMockApi(),
+        capabilities: {
+        // brep-mock lacks evolution/heal/assembly — missing capabilities are exposed (§7.5).
+        },
+    }));
+}
+//# sourceMappingURL=brep-mock.js.map