@faicad/cq-compat 0.16.1 → 0.17.0

package/dist/workplane.js

@@ -9,12 +9,12 @@
  * Design doc: docs/plans/2026-09-06-cadquery-compat-and-multifile-faijs.md
  */
 import { createApiNamespace } from '@faicad/faijs/api/api-namespace';
-import { brepjsCompat } from '@faicad/faijs/api';
-import { borrowBrepjsShape, adoptBrepjsProduct } from '@faicad/faijs/api/internal/l3-bridge';
 import { fromHandle } from '@faicad/faijs/sdk';
 import { brepOf, isShape } from '@faicad/faijs/shape';
 import { setName, nameOf } from '@faicad/faijs';
 import { getKernel } from '@faicad/faijs/occt-kernel/occtKernel';
+import { getBrepApi } from '@faicad/faijs/brep/handle-bridge';
+import { applyMatrixBrep } from '@faicad/faijs/api/brep-mirror/topologyFns';
 // ── cad namespace singleton (created once at module load) ──────────────────
 const cad = createApiNamespace();
 // ── compatOp 提升边界归一（GOTCHA：borrowDeep 把实参 Shape 换成借用视图）──
@@ -33,9 +33,9 @@ const cad = createApiNamespace();
 //
 // 所有权：归一出的新 Shape 与原 part Shape 的 slot 指向同一 OCCT 句柄，但 slot
 // 按 Shape 对象各自持有（fromBrep 写的是新 Shape 的 slot），无共享释放路径——
-// 与 vendored 投影的 adoptBrepjsProduct 收编模式同构，不引入双重释放。
+// 与 core fromHandle 收编模式同构，不引入双重释放。
 // 视图 `.wrapped` 是 OcctWasmHandle 对象（{ id, type, __occtWasm }），内核只收
-// 数字 id → 解包方式与 l3-bridge.adoptBrepjsProduct 一致（`'id' in wrapped` 分支）。
+// 数字 id → 解包方式与 core fromHandle 一致。
 const borrowedShapeCache = new WeakMap();
 /**
  * 把可能是借用视图的几何输入归一为真实 faijs Shape（见上方注释）。
@@ -215,17 +215,37 @@ function unwrapBrepResult(result) {
     }
     return result;
 }
-/** Call a `brepjsCompat` member by name (namespace is typed loosely here). */
-function compatFn(name) {
-    const fn = brepjsCompat[name];
-    if (!fn)
-        throw new Error(`[cq-compat] brepjsCompat.${name} is not available`);
-    return fn;
+/** core 直连 helpers（cq-compat 改写：vendored 兼容面 → getBrepApi/getKernel，裁决 3）。 */
+function kern() {
+    return getBrepApi();
+}
+function ownHandle(shape) {
+    return brepOf(shape);
+}
+function toShape(h) {
+    return fromHandle(h);
+}
+function vec3(p) {
+    if (Array.isArray(p))
+        return { x: p[0], y: p[1], z: p[2] };
+    return p;
+}
+function polygonShape(pts) {
+    const k = getKernel();
+    const edges = pts.map((p, i) => k.makeLineEdge(vec3(p), vec3(pts[(i + 1) % pts.length])));
+    const w = k.makeWire(edges);
+    const f = k.makeFace(w);
+    return fromHandle(f);
+}
+function faceWithHoles(outer, holes) {
+    const f = toShape(kern().makeFace(outer));
+    if (holes.length > 0)
+        kern().addHolesInFace(brepOf(f), holes);
+    return f;
 }
 /** Merge same-domain faces/edges after a boolean (CadQuery `clean=True`). */
 async function cleanShapes(shape) {
-    const simplified = unwrapBrepResult(compatFn('simplify')(borrowBrepjsShape(shape)));
-    return adoptBrepjsProduct(simplified);
+    return toShape(getKernel().simplify(ownHandle(shape)));
 }
 /**
  * Fuse two shapes into ONE solid via the vendored brepjs fuse.
@@ -237,8 +257,7 @@ async function cleanShapes(shape) {
  * stays a single solid. See docs/analysis/2026-09-08-cq-compat-union-compound-bug.md.
  */
 async function fuseShapes(a, b, clean = true) {
-    const product = unwrapBrepResult(compatFn('fuse')(borrowBrepjsShape(a), borrowBrepjsShape(b)));
-    const fused = adoptBrepjsProduct(product);
+    const fused = toShape(kern().fuse(ownHandle(a), ownHandle(b)));
     // CadQuery ops take a `clean` flag (default True); clean=False preserves the
     // boolean splitter faces (verified vs 2.8.0: testNoClean wedge vol 10.650718
     // vs testClean 9.079922 — the kernel unify pass is NOT volume-preserving).
@@ -246,13 +265,13 @@ async function fuseShapes(a, b, clean = true) {
 }
 /** Cut a tool shape out of a base shape via the vendored brepjs cut. */
 async function cutShapes(base, tool) {
-    const product = unwrapBrepResult(compatFn('cut')(borrowBrepjsShape(base), borrowBrepjsShape(tool)));
-    return cleanShapes(adoptBrepjsProduct(product));
+    const cutShape = toShape(kern().cut(ownHandle(base), ownHandle(tool)));
+    return cleanShapes(cutShape);
 }
 /** Intersect two shapes via the vendored brepjs intersect. */
 async function intersectShapes(a, b) {
-    const product = unwrapBrepResult(compatFn('intersect')(borrowBrepjsShape(a), borrowBrepjsShape(b)));
-    return cleanShapes(adoptBrepjsProduct(product));
+    const isect = toShape(kern().intersect(ownHandle(a), ownHandle(b)));
+    return cleanShapes(isect);
 }
 /** Get bbox max of a shape (via cad.bboxMax — synchronous). */
 function bboxMax(shape) {
@@ -556,11 +575,11 @@ export async function resolveFaceSelector(shape, sel, centerOption) {
     // Indexed selector — enumerate real faces and sort by bbox center along axis.
     // CadQuery semantics: '>A[k]' ascending, '<A[k]' descending (see doc above).
     const idx = parseInt(idxStr, 10);
-    const faces = compatFn('getFaces')(borrowBrepjsShape(shape));
+    const faces = kern().getSubShapes(ownHandle(shape), 'face');
     const entries = faces.map((f) => {
-        const b = compatFn('getBounds')(f);
+        const b = kern().getBoundingBox(f);
         return {
-            c: [(b.xMin + b.xMax) / 2, (b.yMin + b.yMax) / 2, (b.zMin + b.zMax) / 2],
+            c: [(b.xmin + b.xmax) / 2, (b.ymin + b.ymax) / 2, (b.zmin + b.zmax) / 2],
             bounds: b,
         };
     });
@@ -574,9 +593,9 @@ export async function resolveFaceSelector(shape, sel, centerOption) {
     }
     const fb = entries[pick].bounds;
     const faceCenter = [
-        (fb.xMin + fb.xMax) / 2,
-        (fb.yMin + fb.yMax) / 2,
-        (fb.zMin + fb.zMax) / 2,
+        (fb.xmin + fb.xmax) / 2,
+        (fb.ymin + fb.ymax) / 2,
+        (fb.zmin + fb.zmax) / 2,
     ];
     // Outward normal: away from the shape bbox center along the axis.
     normal[axis] = faceCenter[axis] >= center[axis] ? 1 : -1;
@@ -593,10 +612,10 @@ async function makePolygonPrismAt(wp, poly, length, dir) {
         const a = (2 * Math.PI * i) / poly.n;
         pts.push(localToWorld(wp, Math.cos(a) * (poly.d / 2), Math.sin(a) * (poly.d / 2)));
     }
-    const face = unwrapBrepResult(compatFn('polygon')(pts));
+    const face = polygonShape(pts);
     const vec = [dir[0] * length, dir[1] * length, dir[2] * length];
-    const prism = unwrapBrepResult(compatFn('extrude')(face, vec));
-    return adoptBrepjsProduct(prism);
+    const prism = toShape(kern().extrude(brepOf(face), vec[0], vec[1], vec[2]));
+    return prism;
 }
 /**
  * Rotate a Z-axis-aligned primitive so its local +Z maps to `d` — ANY direction,
@@ -670,8 +689,7 @@ function resolveCentered(c) {
 function makeCompoundShape(shapes) {
     if (shapes.length === 1)
         return shapes[0];
-    const product = unwrapBrepResult(compatFn('makeCompound')(shapes.map((s) => borrowBrepjsShape(s))));
-    return adoptBrepjsProduct(product);
+    return toShape(kern().makeCompound(shapes.map((s) => ownHandle(s))));
 }
 /**
  * Finish an eachpoint-style op (box/sphere/cylinder): `combine=True` (CadQuery
@@ -822,9 +840,9 @@ export async function wedge(wp, dx, dy, dz, xmin, zmin, xmax, zmax, opts) {
     const rectWire = (pts) => {
         const edges = [];
         for (let i = 0; i < 4; i++) {
-            edges.push(unwrapBrepResult(compatFn('makeLine')(pts[i], pts[(i + 1) % 4])));
+            edges.push(kern().makeLineEdge(vec3(pts[i]), v3(pts[(i + 1) % 4])));
         }
-        return unwrapBrepResult(compatFn('assembleWire')(edges));
+        return kern().makeWire(edges);
     };
     const c = resolveCentered(opts?.centered ?? true);
     const ox = c[0] ? -dx / 2 : 0;
@@ -844,7 +862,7 @@ export async function wedge(wp, dx, dy, dz, xmin, zmin, xmax, zmax, opts) {
         p3(ox + xmax, oy + dy, oz + zmax),
         p3(ox + xmin, oy + dy, oz + zmax),
     ]);
-    const solid = adoptBrepjsProduct(unwrapBrepResult(compatFn('loft')([bottom, top], { ruled: true })));
+    const solid = toShape(getKernel().loft([bottom, top], true, true));
     const points = eachPoints(wp);
     const shapes = [];
     for (const [px, py] of points) {
@@ -941,8 +959,7 @@ export async function cylinder(wp, height, radius, opts) {
  * @returns Promise<Workplane> carrying the torus solid.
  */
 export async function torus(wp, d1, d2, opts) {
-    const product = unwrapBrepResult(compatFn('torus')(d1 / 2, d2 / 2));
-    const shape = adoptBrepjsProduct(product);
+    const shape = toShape(kern().makeTorus(d1 / 2, d2 / 2));
     return combineEachpoint(wp, [shape], opts?.combine ?? true);
 }
 /**
@@ -1511,7 +1528,7 @@ export function spline(wp, points, opts) {
         return clone(wp, { currentPoint: end });
     }
     const world = all.map(([x, y]) => localToWorld(wp, x, y));
-    const builtEdge = unwrapBrepResult(compatFn('makeBSplineInterpolation')(world, { periodic: false }));
+    const builtEdge = toShape(getKernel().interpolatePoints(world.map((p) => vec3(p)), false));
     const endTgt = splineEndTangent(builtEdge, wp);
     const edges = [
         ...(wp.pendingEdges ?? []),
@@ -1532,7 +1549,9 @@ function splineEndTangent(edge, wp) {
     // curveTangentAt returns a plain [x, y, z] ARRAY (vendored curveFns →
     // curveOps.curveTangent(...).tangent), not an {x,y,z} vector — indexing it
     // with .x yields undefined → NaN → a corrupt tangent-arc edge downstream.
-    const tRaw = compatFn('curveTangentAt')(edge, 1);
+    const edgeH = brepOf(edge);
+    const cp = kern().curveParameters(edgeH);
+    const tRaw = kern().curveTangent(edgeH, cp.last);
     const t = Array.isArray(tRaw)
         ? { x: tRaw[0], y: tRaw[1], z: tRaw[2] }
         : tRaw;
@@ -1797,8 +1816,8 @@ async function buildProfileWire(wp, w) {
     const n = Array.isArray(pl.normal) ? pl.normal : [0, 0, 1];
     if (w.kind === 'circle') {
         const center = localToWorld(pl, w.cx, w.cy);
-        const edge = unwrapBrepResult(compatFn('makeCircle')(w.radius, center, n));
-        return unwrapBrepResult(compatFn('assembleWire')([edge]));
+        const edge = kern().makeCircleEdge(vec3(center), vec3(n), w.radius);
+        return kern().makeWire([edge]);
     }
     if (w.kind === 'ellipse') {
         const center = localToWorld(pl, w.cx, w.cy);
@@ -1815,8 +1834,8 @@ async function buildProfileWire(wp, w) {
             // Failing loudly instead of silently emitting an approximated ellipse.
             throw new Error('[cq-compat] ellipse: y_radius > x_radius is not reproducible (kernel ellipse is always major-on-X and rotations re-approximate it)');
         }
-        const edge = unwrapBrepResult(compatFn('makeEllipseEdge')(w.majorRadius, w.minorRadius, center, n));
-        return unwrapBrepResult(compatFn('assembleWire')([edge]));
+        const edge = getKernel().makeEllipseEdge(vec3(center), vec3(n), w.majorRadius, w.minorRadius);
+        return kern().makeWire([edge]);
     }
     if (w.kind === 'path') {
         // Drafted ring. When edge descriptors are present (arcs/splines), rebuild
@@ -1832,10 +1851,10 @@ async function buildProfileWire(wp, w) {
             const descs = reorderForWireAssembly(w.edges.filter((e) => e.kind !== 'line' || Math.hypot(e.to[0] - e.from[0], e.to[1] - e.from[1]) >= 1e-9));
             for (const e of descs) {
                 if (e.kind === 'line') {
-                    edges.push(unwrapBrepResult(compatFn('makeLine')(localToWorld(pl, e.from[0], e.from[1]), localToWorld(pl, e.to[0], e.to[1]))));
+                    edges.push(kern().makeLineEdge(v3(localToWorld(pl, e.from[0], e.from[1])), v3(localToWorld(pl, e.to[0], e.to[1]))));
                 }
                 else if (e.kind === 'arc3') {
-                    edges.push(compatFn('makeThreePointArc')(localToWorld(pl, e.from[0], e.from[1]), localToWorld(pl, e.mid[0], e.mid[1]), localToWorld(pl, e.to[0], e.to[1])));
+                    edges.push(getKernel().makeArcEdge(vec3(localToWorld(pl, e.from[0], e.from[1])), vec3(localToWorld(pl, e.mid[0], e.mid[1])), vec3(localToWorld(pl, e.to[0], e.to[1]))));
                 }
                 else if (e.kind === 'tangentArc') {
                     const tLen = Math.hypot(e.tgt[0], e.tgt[1]);
@@ -1844,16 +1863,16 @@ async function buildProfileWire(wp, w) {
                         (pl.xDir[1] * e.tgt[0] + pl.yDir[1] * e.tgt[1]) / tLen,
                         (pl.xDir[2] * e.tgt[0] + pl.yDir[2] * e.tgt[1]) / tLen,
                     ];
-                    edges.push(compatFn('makeTangentArc')(localToWorld(pl, e.from[0], e.from[1]), t, localToWorld(pl, e.to[0], e.to[1])));
+                    edges.push(getKernel().makeTangentArc(vec3(localToWorld(pl, e.from[0], e.from[1])), vec3(t), vec3(localToWorld(pl, e.to[0], e.to[1]))));
                 }
                 else if (e.builtEdge) {
                     // Reuse the edge built at op time (strongly held — see spline()).
-                    edges.push(e.builtEdge);
+                    edges.push(brepOf(e.builtEdge));
                 }
                 else {
                     // spline
                     const world = e.pts.map(([x, y]) => localToWorld(pl, x, y));
-                    edges.push(unwrapBrepResult(compatFn('makeBSplineInterpolation')(world, { periodic: false })));
+                    edges.push(getKernel().interpolatePoints(world.map((p) => vec3(p)), false));
                 }
             }
         }
@@ -1863,12 +1882,12 @@ async function buildProfileWire(wp, w) {
                 const b = w.pts[(i + 1) % w.pts.length];
                 if (Math.hypot(a[0] - b[0], a[1] - b[1]) < 1e-9)
                     continue;
-                edges.push(unwrapBrepResult(compatFn('makeLine')(localToWorld(pl, a[0], a[1]), localToWorld(pl, b[0], b[1]))));
+                edges.push(kern().makeLineEdge(v3(localToWorld(pl, a[0], a[1])), v3(localToWorld(pl, b[0], b[1]))));
             }
         }
         if (edges.length === 0)
             throw new Error('[cq-compat] buildProfileWire: degenerate path wire');
-        return unwrapBrepResult(compatFn('assembleWire')(edges));
+        return kern().makeWire(edges);
     }
     const ring = w.kind === 'rect'
         ? [
@@ -1888,9 +1907,9 @@ async function buildProfileWire(wp, w) {
     for (let i = 0; i < ring.length; i++) {
         const a = ring[i];
         const b = ring[(i + 1) % ring.length];
-        edges.push(unwrapBrepResult(compatFn('makeLine')(localToWorld(pl, a[0], a[1]), localToWorld(pl, b[0], b[1]))));
+        edges.push(kern().makeLineEdge(v3(localToWorld(pl, a[0], a[1])), v3(localToWorld(pl, b[0], b[1]))));
     }
-    return unwrapBrepResult(compatFn('assembleWire')(edges));
+    return kern().makeWire(edges);
 }
 /**
  * Extrude the pending wire LIST: one face per outermost wire, enclosed wires
@@ -1926,10 +1945,9 @@ async function pendingPathPrism(wp, vec, shift) {
         for (const h of g.holes) {
             holeWires.push(await buildProfileWire(wp, shift ? shiftWire(h, wp, shift) : h));
         }
-        const face = unwrapBrepResult(compatFn('makeFace')(outer, holeWires));
-        const prism = unwrapBrepResult(compatFn('extrude')(face, vec));
-        const solid = adoptBrepjsProduct(prism);
-        result = result ? await fuseShapes(result, solid) : solid;
+        const face = faceWithHoles(outer, holeWires);
+        const prism = toShape(kern().extrude(brepOf(face), vec[0], vec[1], vec[2]));
+        result = result ? await fuseShapes(result, prism) : prism;
     }
     if (!result)
         throw new Error('[cq-compat] extrude: no pending wire to extrude');
@@ -1998,7 +2016,7 @@ export async function extrude(wp, height, combine = true, opts) {
             // exact body is sewn from its faces.
             return outwardTaperPrism(wp, base, profile, height, taper, combine);
         }
-        const face = unwrapBrepResult(compatFn('makeFace')(profile));
+        const face = toShape(kern().makeFace(profile));
         const kernel = getKernel();
         const n = Array.isArray(wp.normal) ? wp.normal : [0, 0, 1];
         const raw = kernel.draftPrism(rawShapeId(face), n[0] * height, n[1] * height, n[2] * height, taper);
@@ -2100,8 +2118,8 @@ export async function extrude(wp, height, combine = true, opts) {
                 // (shifted boss \ base) ∩ half-space below the face plane.
                 // Profiles fully inside the base's cross-section can never overhang,
                 // so the cheap bbox test skips the two extra booleans entirely.
-                const bossB = compatFn('getBounds')(borrowBrepjsShape(boss));
-                const baseB = compatFn('getBounds')(borrowBrepjsShape(base));
+                const bossB = kern().getBoundingBox(ownHandle(boss));
+                const baseB = kern().getBoundingBox(ownHandle(base));
                 const PAD_EPS = 1e-6;
                 const axisOf = (v) => Math.abs(v[0]) > 0.5 ? 0 : Math.abs(v[1]) > 0.5 ? 1 : 2;
                 // In-plane axes = the two axes perpendicular to the face normal.
@@ -2117,7 +2135,7 @@ export async function extrude(wp, height, combine = true, opts) {
                     // Slab covering the half-space below the face plane (local z <= 0).
                     const o = Array.isArray(wp.origin) ? wp.origin : [0, 0, 0];
                     const BIG = 2 *
-                        Math.max(baseB.xMax - baseB.xMin, baseB.yMax - baseB.yMin, baseB.zMax - baseB.zMin, bossB.xMax - bossB.xMin, bossB.yMax - bossB.yMin, bossB.zMax - bossB.zMin) +
+                        Math.max(baseB.xmax - baseB.xmin, baseB.ymax - baseB.ymin, baseB.zmax - baseB.zmin, bossB.xmax - bossB.xmin, bossB.ymax - bossB.ymin, bossB.zmax - bossB.zmin) +
                         10;
                     const belowWp = {
                         ...wp,
@@ -2335,10 +2353,9 @@ export async function revolve(wp, angleDegrees = 360, axisStart, axisEnd, combin
         const holeWires = [];
         for (const h of g.holes)
             holeWires.push(await buildProfileWire(wp, h));
-        const face = unwrapBrepResult(compatFn('makeFace')(outer, holeWires));
-        const revolved = unwrapBrepResult(compatFn('revolve')(face, { at: startW, axis: dir, angle: rad }));
-        const solid = adoptBrepjsProduct(revolved);
-        result = result ? await fuseShapes(result, solid) : solid;
+        const face = faceWithHoles(outer, holeWires);
+        const revolved = toShape(kern().revolveVec(brepOf(face), v3(startW), v3(dir), (rad * 180) / Math.PI));
+        result = result ? await fuseShapes(result, revolved) : revolved;
     }
     const base = wp.shape;
     let shape = result;
@@ -2362,7 +2379,7 @@ export async function revolve(wp, angleDegrees = 360, axisStart, axisEnd, combin
 /** True when the carrier holds at least one solid (upstream `findSolid()` gate). */
 function hasSolidBase(shape) {
     try {
-        return brepjsCompat.getSolids(borrowBrepjsShape(shape)).length > 0;
+        return kern().getSubShapes(ownHandle(shape), 'solid').length > 0;
     }
     catch {
         return false;
@@ -2378,9 +2395,9 @@ async function collectLoftSections(wp, sections) {
         // Upstream `Workplane().add(face)...loft()` lofts the stacked faces of
         // wp.shape: each face's outer wire becomes a loft section (holes are
         // intentionally dropped — upstream section extraction is outerWire-only).
-        const shapeFaces = compatFn('getFaces')(borrowBrepjsShape(wp.shape));
+        const shapeFaces = kern().getSubShapes(ownHandle(wp.shape), 'face');
         for (const f of shapeFaces) {
-            sections.push(compatFn('outerWire')(f));
+            sections.push(kern().getSubShapes(f, 'wire')[0]);
         }
     }
 }
@@ -2416,7 +2433,15 @@ export async function loft(wp, ...rest) {
         loftCfg.startPoint = opts.startPoint;
     if (opts?.endPoint)
         loftCfg.endPoint = opts.endPoint;
-    const solid = adoptBrepjsProduct(unwrapBrepResult(compatFn('loft')(sections, loftCfg)));
+    const wireHandles = sections.map((w) => w);
+    const startPt = loftCfg.startPoint !== undefined ? v3(loftCfg.startPoint) : null;
+    const endPt = loftCfg.endPoint !== undefined ? v3(loftCfg.endPoint) : null;
+    const ruled = loftCfg?.ruled ?? false;
+    const startV = startPt !== null ? getKernel().makeVertex(startPt.x, startPt.y, startPt.z) : 0;
+    const endV = endPt !== null ? getKernel().makeVertex(endPt.x, endPt.y, endPt.z) : 0;
+    const solid = (startV !== 0 || endV !== 0
+        ? toShape(getKernel().loftWithVertices(wireHandles, true, ruled, startV, endV))
+        : toShape(getKernel().loft(wireHandles, true, ruled)));
     const base = wp.shape;
     let shape = solid;
     const combine = opts?.combine ?? true;
@@ -2466,7 +2491,7 @@ export async function cutBlind(wp, depth, opts) {
             throw new Error('[cq-compat] cutBlind: taper requires exactly one pending profile wire');
         }
         const profile = await buildProfileWire(wp, solidWires[0]);
-        const face = unwrapBrepResult(compatFn('makeFace')(profile));
+        const face = toShape(kern().makeFace(profile));
         const kernel = getKernel();
         const raw = kernel.draftPrism(rawShapeId(face), invNormal[0] * absDepth, invNormal[1] * absDepth, invNormal[2] * absDepth, opts.taper);
         const tool = fromHandle(raw);
@@ -3231,12 +3256,11 @@ export async function faceCompound(wp, sel) {
         return wp;
     const s = NAMED_VIEW_TO_AXIS[sel.trim().toLowerCase()] ?? sel;
     if (s.trim().toLowerCase() === 'all') {
-        const faces = compatFn('getFaces')(borrowBrepjsShape(wp.shape));
+        const faces = kern().getSubShapes(ownHandle(wp.shape), 'face');
         if (faces.length === 0) {
             throw new Error('[cq-compat] faceCompound "all": shape has no faces');
         }
-        const product = compatFn('makeCompound')(faces);
-        const shape = adoptBrepjsProduct(unwrapBrepResult(product));
+        const shape = toShape(kern().makeCompound(faces));
         return clone(wp, { shape, faceSel: null, edgeSel: null, vertexSel: null });
     }
     const m = /^([<>])([XYZ])(?:\[-?\d+\])?$/.exec(s.trim());
@@ -3245,25 +3269,24 @@ export async function faceCompound(wp, sel) {
     }
     const axis = m[2] === 'X' ? 0 : m[2] === 'Y' ? 1 : 2;
     const sign = m[1] === '>' ? 1 : -1;
-    const bounds = (h) => compatFn('getBounds')(h);
-    const faces = compatFn('getFaces')(borrowBrepjsShape(wp.shape));
+    const bounds = (h) => kern().getBoundingBox(h);
+    const faces = kern().getSubShapes(ownHandle(wp.shape), 'face');
     // DirectionMinMaxSelector: among faces perpendicular to the axis, take ALL
     // faces whose center sits at the extremum (ties included — the two-boxes
     // compound exports BOTH top faces).
     const perp = faces.filter((f) => {
         const b = bounds(f);
-        return [b.xMax - b.xMin, b.yMax - b.yMin, b.zMax - b.zMin][axis] <= 0.1;
+        return [b.xmax - b.xmin, b.ymax - b.ymin, b.zmax - b.zmin][axis] <= 0.1;
     });
     if (perp.length === 0) {
         throw new Error(`[cq-compat] no planar face for selector "${sel}"`);
     }
-    const center = (b) => [(b.xMin + b.xMax) / 2, (b.yMin + b.yMax) / 2, (b.zMin + b.zMax) / 2][axis];
+    const center = (b) => [(b.xmin + b.xmax) / 2, (b.ymin + b.ymax) / 2, (b.zmin + b.zmax) / 2][axis];
     const extremum = perp
         .map((f) => center(bounds(f)))
         .reduce((best, c) => (sign * c > sign * best ? c : best));
     const picked = perp.filter((f) => Math.abs(center(bounds(f)) - extremum) <= 1e-6);
-    const product = compatFn('makeCompound')(picked);
-    const shape = adoptBrepjsProduct(unwrapBrepResult(product));
+    const shape = toShape(kern().makeCompound(picked));
     return clone(wp, { shape, faceSel: null, edgeSel: null, vertexSel: null });
 }
 /**
@@ -3292,15 +3315,14 @@ export async function edgeCompound(wp, sel) {
     }
     const axis = m[2] === 'X' ? 0 : m[2] === 'Y' ? 1 : 2;
     const sign = m[1] === '>' ? 1 : -1;
-    const bounds = (h) => compatFn('getBounds')(h);
-    const edges = compatFn('getEdges')(borrowBrepjsShape(wp.shape));
-    const center = (b) => [(b.xMin + b.xMax) / 2, (b.yMin + b.yMax) / 2, (b.zMin + b.zMax) / 2][axis];
+    const bounds = (h) => kern().getBoundingBox(h);
+    const edges = kern().getSubShapes(ownHandle(wp.shape), 'edge');
+    const center = (b) => [(b.xmin + b.xmax) / 2, (b.ymin + b.ymax) / 2, (b.zmin + b.zmax) / 2][axis];
     const extremum = edges
         .map((e) => center(bounds(e)))
         .reduce((best, c) => (sign * c > sign * best ? c : best));
     const picked = edges.filter((e) => Math.abs(center(bounds(e)) - extremum) <= 1e-6);
-    const product = compatFn('makeCompound')(picked);
-    const shape = adoptBrepjsProduct(unwrapBrepResult(product));
+    const shape = toShape(kern().makeCompound(picked));
     return clone(wp, { shape, faceSel: null, edgeSel: null, vertexSel: null });
 }
 function locNum(v) {
@@ -3510,7 +3532,7 @@ async function applyLocation(shape, loc) {
     //    `moved` (they fold the locations with composeLocations instead).
     const solids = (() => {
         try {
-            return brepjsCompat.getSolids(borrowBrepjsShape(shape)).length;
+            return kern().getSubShapes(ownHandle(shape), 'solid').length;
         }
         catch {
             return 0;
@@ -3526,11 +3548,11 @@ async function applyLocation(shape, loc) {
         }
         return s;
     }
-    const product = unwrapBrepResult(compatFn('applyMatrix')(borrowBrepjsShape(shape), {
+    const product = applyMatrixBrep(shape, {
         linear: rotationMatrixDeg(loc.rot),
         translation: [x, y, z],
-    }));
-    return adoptBrepjsProduct(product);
+    });
+    return toShape(unwrapBrepResult(product));
 }
 /**
  * moved — apply one or more Locations to the carried geometry.
@@ -3562,8 +3584,8 @@ export async function moved(wp, ...locs) {
         // Upstream `_compound_or_shape` groups the copies without any boolean or
         // clean pass — mirroring that keeps the topology (face/solid counts) equal
         // to upstream, which the STEP comparison gates on.
-        const handles = copies.map((c) => borrowBrepjsShape(c));
-        shape = adoptBrepjsProduct(unwrapBrepResult(compatFn('makeCompound')(handles)));
+        const handles = copies.map((c) => ownHandle(c));
+        shape = toShape(kern().makeCompound(handles));
     }
     return clone(wp, {
         shape,
@@ -3654,7 +3676,7 @@ export async function face(wp) {
         for (const h of g.holes) {
             holeWires.push(await buildProfileWire(wp, h));
         }
-        faces.push(adoptBrepjsProduct(unwrapBrepResult(compatFn('makeFace')(outer, holeWires))));
+        faces.push(faceWithHoles(outer, holeWires));
     }
     const shape = faces.length === 1 ? faces[0] : makeCompoundShape(faces);
     return clone(wp, {
@@ -3680,7 +3702,7 @@ export async function face(wp) {
  * @returns Shape holding the vertex
  */
 export function vertex(x = 0, y = 0, z = 0) {
-    return adoptBrepjsProduct(unwrapBrepResult(compatFn('makeVertex')([x, y, z])));
+    return toShape(kern().makeVertex(x, y, z));
 }
 /**
  * compound — upstream module-level `compound(*shapes)` free function: bundle
@@ -3733,7 +3755,7 @@ export async function intersect(wp, other) {
  * is out of scope for this layer.
  */
 function resolveEdgeSelection(shape, sel) {
-    const edges = compatFn('getEdges')(borrowBrepjsShape(shape));
+    const edges = kern().getSubShapes(ownHandle(shape), 'edge');
     if (!sel || sel === '')
         return edges;
     const m = /^\|([XYZ])$/.exec(sel.trim());
@@ -3747,9 +3769,9 @@ function resolveEdgeSelection(shape, sel) {
     // must dominate the two perpendicular extents (which stay padding-sized).
     const PAD = 0.5; // mm — max perpendicular extent for an axis-parallel edge
     return edges.filter((e) => {
-        const b = compatFn('getBounds')(e);
-        const min = [b.xMin, b.yMin, b.zMin];
-        const max = [b.xMax, b.yMax, b.zMax];
+        const b = kern().getBoundingBox(e);
+        const min = [b.xmin, b.ymin, b.zmin];
+        const max = [b.xmax, b.ymax, b.zmax];
         const extents = [max[0] - min[0], max[1] - min[1], max[2] - min[2]];
         const axisExtent = extents[axisIdx];
         return (perp.every((i) => extents[i] <= PAD) &&
@@ -3785,9 +3807,8 @@ export async function fillet(wp, radius) {
     else {
         edges = resolveEdgeSelection(wp.shape, undefined);
     }
-    const result = compatFn('fillet')(borrowBrepjsShape(wp.shape), edges, radius);
-    const product = unwrapBrepResult(result);
-    const shape = adoptBrepjsProduct(product);
+    const product = kern().fillet(ownHandle(wp.shape), edges, radius);
+    const shape = toShape(product);
     return clone(wp, { shape, edgeSel: null, faceSel: null });
 }
 /**
@@ -3822,9 +3843,8 @@ export async function chamfer(wp, length, length2) {
     else {
         edges = resolveEdgeSelection(wp.shape, undefined);
     }
-    const result = compatFn('chamfer')(borrowBrepjsShape(wp.shape), edges, length);
-    const product = unwrapBrepResult(result);
-    const shape = adoptBrepjsProduct(product);
+    const product = kern().chamfer(ownHandle(wp.shape), edges, length);
+    const shape = toShape(product);
     return clone(wp, { shape, edgeSel: null, faceSel: null });
 }
 /**
@@ -3844,16 +3864,16 @@ function resolveFaceEdgeSelection(shape, sel) {
     }
     const axis = m[2] === 'X' ? 0 : m[2] === 'Y' ? 1 : 2;
     const sign = m[1] === '>' || m[1] === '+' ? 1 : -1;
-    const bounds = (h) => compatFn('getBounds')(h);
-    const faces = compatFn('getFaces')(borrowBrepjsShape(shape));
+    const bounds = (h) => kern().getBoundingBox(h);
+    const faces = kern().getSubShapes(ownHandle(shape), 'face');
     const perp = faces.filter((f) => {
         const b = bounds(f);
-        return [b.xMax - b.xMin, b.yMax - b.yMin, b.zMax - b.zMin][axis] <= 0.1;
+        return [b.xmax - b.xmin, b.ymax - b.ymin, b.zmax - b.zmin][axis] <= 0.1;
     });
     if (perp.length === 0) {
         throw new Error(`[cq-compat] no planar face for selector "${sel}"`);
     }
-    const faceCenter = (b) => [(b.xMin + b.xMax) / 2, (b.yMin + b.yMax) / 2, (b.zMin + b.zMax) / 2][axis];
+    const faceCenter = (b) => [(b.xmin + b.xmax) / 2, (b.ymin + b.ymax) / 2, (b.zmin + b.zmax) / 2][axis];
     const target = perp
         .map((f) => ({ f, b: bounds(f) }))
         .reduce((best, cur) => (sign * (faceCenter(cur.b) - faceCenter(best.b)) > 0 ? cur : best));
@@ -3864,11 +3884,11 @@ function resolveFaceEdgeSelection(shape, sel) {
     // padding) and its center coincides with the face center.
     const EDGE_AXIS_MAX = 0.25;
     const EDGE_CENTER_TOL = 0.15;
-    const edges = compatFn('getEdges')(borrowBrepjsShape(shape));
+    const edges = kern().getSubShapes(ownHandle(shape), 'edge');
     return edges.filter((e) => {
         const b = bounds(e);
-        const ext = [b.xMax - b.xMin, b.yMax - b.yMin, b.zMax - b.zMin][axis];
-        const c = [(b.xMin + b.xMax) / 2, (b.yMin + b.yMax) / 2, (b.zMin + b.zMax) / 2][axis];
+        const ext = [b.xmax - b.xmin, b.ymax - b.ymin, b.zmax - b.zmin][axis];
+        const c = [(b.xmin + b.xmax) / 2, (b.ymin + b.ymax) / 2, (b.zmin + b.zmax) / 2][axis];
         return ext <= EDGE_AXIS_MAX && Math.abs(c - fc) <= EDGE_CENTER_TOL;
     });
 }