brepjs 18.6.0 → 18.14.3

package/dist/kernel/brepkit/booleanOps.d.ts

@@ -26,4 +26,26 @@ export declare function buildSolidFromFaces(bk: BrepkitKernel, points: Array<{
     y: number;
     z: number;
 }>, faces: Array<readonly [number, number, number]>, _tolerance: number): KernelShape;
-//# sourceMappingURL=booleanOps.d.ts.map
+/** Co-located factory: returns the boolean+hull slice of {@link KernelAdapter} bound to `bk`. */
+export declare function makeBooleanOps(bk: BrepkitKernel): {
+    fuse: (shape: any, tool: any, options: BooleanOptions | undefined) => any;
+    cut: (shape: any, tool: any, options: BooleanOptions | undefined) => any;
+    intersect: (shape: any, tool: any, options: BooleanOptions | undefined) => any;
+    section: (shape: any, plane: any, approximation: boolean | undefined) => any;
+    fuseAll: (shapes: any[], options: BooleanOptions | undefined) => any;
+    cutAll: (shape: any, tools: any[], options: BooleanOptions | undefined) => any;
+    split: (shape: any, tools: any[]) => any;
+    meshBoolean: (positionsA: number[], indicesA: number[], positionsB: number[], indicesB: number[], op: string, tolerance: number) => KernelMeshResult;
+    checkBoolean: (shape: any, tool: any, op: BooleanOpType) => CheckBooleanResult;
+    hull: (shapes: any[], tolerance: number) => any;
+    hullFromPoints: (points: {
+        x: number;
+        y: number;
+        z: number;
+    }[], tolerance: number) => any;
+    buildSolidFromFaces: (points: {
+        x: number;
+        y: number;
+        z: number;
+    }[], faces: (readonly [number, number, number])[], tolerance: number) => any;
+};

package/dist/kernel/brepkit/brepkitAdapter.d.ts

@@ -1,414 +1,27 @@
-import { BooleanOpType, CheckBooleanResult, KernelAdapter, KernelMeshResult, KernelEdgeMeshResult, DistanceResult, OperationResult, DiagnosticOperationResult, KernelInstance, KernelShape, KernelType, BooleanOptions, ShapeType, SurfaceType, ShapeOrientation, MeshOptions, StepAssemblyPart, NurbsCurveData, NurbsSurfaceData } from '../types.js';
-import { BulkMeasurement } from '../interfaces/measureOps.js';
-import { TransformEntry } from '../interfaces/transformOps.js';
-import { Curve2dHandle, BBox2dHandle } from '../kernel2dTypes.js';
-export declare class BrepkitAdapter implements KernelAdapter {
+import { ConstraintSketchCapability, KernelAdapter, KernelInstance, KernelShape } from '../types.js';
+/**
+ * brepkit-only extensions that live outside `KernelAdapter` and
+ * {@link ConstraintSketchCapability}. Currently just `validationDetails`,
+ * which surfaces the kernel's diagnostic JSON for callers that need the
+ * fine-grained "why is this shape invalid?" trace.
+ */
+interface BrepkitExtensions {
+    validationDetails(shape: KernelShape): string | null;
+}
+export interface BrepkitAdapter extends KernelAdapter, ConstraintSketchCapability, BrepkitExtensions {
+}
+/**
+ * `KernelAdapter` backed by brepkit's WASM kernel.
+ *
+ * All methods are composed from per-domain factories at construction time.
+ * To find a method's implementation, grep for `function <name>` in
+ * `src/kernel/brepkit/*Ops.ts`.
+ */
+export declare class BrepkitAdapter {
     readonly oc: KernelInstance;
     readonly kernelId = "brepkit";
     /** The underlying brepkit WASM kernel instance (typed). */
     private readonly bk;
     constructor(brepkitKernel: KernelInstance);
-    fuse(shape: KernelShape, tool: KernelShape, _options?: BooleanOptions): KernelShape;
-    cut(shape: KernelShape, tool: KernelShape, _options?: BooleanOptions): KernelShape;
-    intersect(shape: KernelShape, tool: KernelShape, _options?: BooleanOptions): KernelShape;
-    section(shape: KernelShape, plane: KernelShape, _approximation?: boolean): KernelShape;
-    fuseAll(shapes: KernelShape[], options?: BooleanOptions): KernelShape;
-    cutAll(shape: KernelShape, tools: KernelShape[], options?: BooleanOptions): KernelShape;
-    split(shape: KernelShape, tools: KernelShape[]): KernelShape;
-    checkBoolean(shape: KernelShape, tool: KernelShape, op: BooleanOpType): CheckBooleanResult;
-    hull(shapes: KernelShape[], _tolerance: number): KernelShape;
-    hullFromPoints(points: Array<{
-        x: number;
-        y: number;
-        z: number;
-    }>, _tolerance: number): KernelShape;
-    buildSolidFromFaces(points: Array<{
-        x: number;
-        y: number;
-        z: number;
-    }>, faces: Array<readonly [number, number, number]>, _tolerance: number): KernelShape;
-    makeVertex(x: number, y: number, z: number): KernelShape;
-    makeEdge(curve: KernelType, start?: number, end?: number): KernelShape;
-    makeWire(edges: KernelShape[]): KernelShape;
-    makeFace(wire: KernelShape, _planar?: boolean): KernelShape;
-    makeBox(width: number, height: number, depth: number): KernelShape;
-    makeRectangle(width: number, height: number): KernelShape;
-    makeCylinder(radius: number, height: number, center?: [number, number, number], direction?: [number, number, number]): KernelShape;
-    makeSphere(radius: number, center?: [number, number, number]): KernelShape;
-    makeCone(radius1: number, radius2: number, height: number, center?: [number, number, number], direction?: [number, number, number]): KernelShape;
-    makeTorus(majorRadius: number, minorRadius: number, center?: [number, number, number], direction?: [number, number, number]): KernelShape;
-    makeEllipsoid(aLength: number, bLength: number, cLength: number): KernelShape;
-    makeLineEdge(p1: [number, number, number], p2: [number, number, number]): KernelShape;
-    makeCircleEdge(center: [number, number, number], normal: [number, number, number], radius: number): KernelShape;
-    makeCircleArc(center: [number, number, number], normal: [number, number, number], radius: number, startAngle: number, endAngle: number): KernelShape;
-    makeArcEdge(p1: [number, number, number], p2: [number, number, number], p3: [number, number, number]): KernelShape;
-    makeEllipseEdge(center: [number, number, number], normal: [number, number, number], majorRadius: number, minorRadius: number, xDir?: [number, number, number]): KernelShape;
-    makeEllipseArc(center: [number, number, number], normal: [number, number, number], majorRadius: number, minorRadius: number, startAngle: number, endAngle: number, xDir?: [number, number, number]): KernelShape;
-    makeBezierEdge(points: [number, number, number][]): KernelShape;
-    makeTangentArc(startPoint: [number, number, number], startTangent: [number, number, number], endPoint: [number, number, number]): KernelShape;
-    makeHelixWire(pitch: number, height: number, radius: number, center?: [number, number, number], _direction?: [number, number, number], leftHanded?: boolean): KernelShape;
-    makeWireFromMixed(items: KernelShape[]): KernelShape;
-    makeCompound(shapes: KernelShape[]): KernelShape;
-    makeBoxFromCorners(p1: [number, number, number], p2: [number, number, number]): KernelShape;
-    solidFromShell(shell: KernelShape): KernelShape;
-    extrude(face: KernelShape, direction: [number, number, number], length: number): KernelShape;
-    revolve(shape: KernelShape, axis: KernelType, angle: number): KernelShape;
-    revolveVec(shape: KernelShape, center: [number, number, number], direction: [number, number, number], angle: number): KernelShape;
-    loft(wires: KernelShape[], _ruled?: boolean, _startShape?: KernelShape, _endShape?: KernelShape): KernelShape;
-    sweep(wire: KernelShape, spine: KernelShape, options?: {
-        transitionMode?: number;
-    }): KernelShape;
-    simplePipe(profile: KernelShape, spine: KernelShape): KernelShape;
-    helicalSweep(profile: KernelShape, axisOrigin: [number, number, number], axisDirection: [number, number, number], radius: number, pitch: number, turns: number): KernelShape;
-    sweepWithOptions(profile: KernelShape, pathEdge: KernelShape, contactMode: string, scaleValues: number[], segments: number): KernelShape;
-    sweepPipeShell(profile: KernelShape, spine: KernelShape, options?: Record<string, unknown>): KernelShape | {
-        shape: KernelShape;
-        firstShape: KernelShape;
-        lastShape: KernelShape;
-    };
-    loftAdvanced(wires: KernelShape[], options?: {
-        solid?: boolean;
-        ruled?: boolean;
-        startVertex?: KernelShape;
-        endVertex?: KernelShape;
-        tolerance?: number;
-    }): KernelShape;
-    buildExtrusionLaw(profile: 'linear' | 's-curve', length: number, endFactor: number): KernelType;
-    draftPrism(shape: KernelShape, face: KernelShape, _baseFace: KernelShape, height: number | null, _angleDeg: number, fuse: boolean): KernelShape;
-    fillet(shape: KernelShape, edges: KernelShape[], radius: number | [number, number] | ((edge: KernelShape) => number | [number, number])): KernelShape;
-    chamfer(shape: KernelShape, edges: KernelShape[], distance: number | [number, number] | ((edge: KernelShape) => number | [number, number])): KernelShape;
-    chamferDistAngle(shape: KernelShape, edges: KernelShape[], distance: number, angleDeg: number): KernelShape;
-    shell(shape: KernelShape, faces: KernelShape[], thickness: number, tolerance?: number): KernelShape;
-    thicken(shape: KernelShape, thickness: number): KernelShape;
-    offset(shape: KernelShape, distance: number, tolerance?: number): KernelShape;
-    filletVariable(shape: KernelShape, spec: string): KernelShape;
-    draft(shape: KernelShape, faces: KernelShape[], pullDirection: [number, number, number], neutralPlane: [number, number, number], angleDeg: number | ((face: KernelShape) => number)): KernelShape;
-    defeature(shape: KernelShape, faces: KernelShape[]): KernelShape;
-    simplify(shape: KernelShape): KernelShape;
-    reverseShape(shape: KernelShape): KernelShape;
-    offsetWire2D(wire: KernelShape, offset: number, _joinType?: number | 'arc' | 'intersection' | 'tangent'): KernelShape;
-    transform(shape: KernelShape, trsf: KernelType): KernelShape;
-    translate(shape: KernelShape, x: number, y: number, z: number): KernelShape;
-    rotate(shape: KernelShape, angle: number, axis?: readonly [number, number, number], center?: readonly [number, number, number]): KernelShape;
-    mirror(shape: KernelShape, origin: readonly [number, number, number], normal: readonly [number, number, number]): KernelShape;
-    scale(shape: KernelShape, center: readonly [number, number, number], factor: number): KernelShape;
-    transformBatch(entries: TransformEntry[]): KernelShape[];
-    generalTransform(shape: KernelShape, linear: readonly [number, number, number, number, number, number, number, number, number], translation: readonly [number, number, number], _isOrthogonal: boolean): KernelShape;
-    generalTransformNonOrthogonal(shape: KernelShape, linear: readonly [number, number, number, number, number, number, number, number, number], translation: readonly [number, number, number]): KernelShape;
-    positionOnCurve(shape: KernelShape, spine: KernelShape, param: number): KernelShape;
-    linearPattern(shape: KernelShape, direction: [number, number, number], spacing: number, count: number): KernelShape[];
-    circularPattern(shape: KernelShape, center: [number, number, number], axis: [number, number, number], angleStep: number, count: number): KernelShape[];
-    gridPattern(shape: KernelShape, directionX: [number, number, number], directionY: [number, number, number], spacingX: number, spacingY: number, countX: number, countY: number): KernelShape;
-    translateWithHistory(shape: KernelShape, x: number, y: number, z: number, inputFaceHashes: number[], hashUpperBound: number): OperationResult;
-    rotateWithHistory(shape: KernelShape, angle: number, inputFaceHashes: number[], hashUpperBound: number, axis?: readonly [number, number, number], center?: readonly [number, number, number]): OperationResult;
-    mirrorWithHistory(shape: KernelShape, origin: readonly [number, number, number], normal: readonly [number, number, number], inputFaceHashes: number[], hashUpperBound: number): OperationResult;
-    scaleWithHistory(shape: KernelShape, center: readonly [number, number, number], factor: number, inputFaceHashes: number[], hashUpperBound: number): OperationResult;
-    generalTransformWithHistory(shape: KernelShape, linear: readonly [number, number, number, number, number, number, number, number, number], translation: readonly [number, number, number], isOrthogonal: boolean, inputFaceHashes: number[], hashUpperBound: number): OperationResult;
-    fuseWithHistory(shape: KernelShape, tool: KernelShape, inputFaceHashes: number[], hashUpperBound: number, options?: BooleanOptions): DiagnosticOperationResult;
-    cutWithHistory(shape: KernelShape, tool: KernelShape, inputFaceHashes: number[], hashUpperBound: number, options?: BooleanOptions): DiagnosticOperationResult;
-    intersectWithHistory(shape: KernelShape, tool: KernelShape, inputFaceHashes: number[], hashUpperBound: number, options?: BooleanOptions): DiagnosticOperationResult;
-    filletWithHistory(shape: KernelShape, edges: KernelShape[], radius: number | [number, number] | ((edge: KernelShape) => number | [number, number]), inputFaceHashes: number[], hashUpperBound: number): OperationResult;
-    chamferWithHistory(shape: KernelShape, edges: KernelShape[], distance: number | [number, number] | ((edge: KernelShape) => number | [number, number]), inputFaceHashes: number[], hashUpperBound: number): OperationResult;
-    shellWithHistory(shape: KernelShape, faces: KernelShape[], thickness: number, inputFaceHashes: number[], hashUpperBound: number, tolerance?: number): OperationResult;
-    thickenWithHistory(shape: KernelShape, thickness: number, inputFaceHashes: number[], hashUpperBound: number): OperationResult;
-    offsetWithHistory(shape: KernelShape, distance: number, inputFaceHashes: number[], hashUpperBound: number, tolerance?: number): OperationResult;
-    draftWithHistory(shape: KernelShape, faces: KernelShape[], pullDirection: [number, number, number], neutralPlane: [number, number, number], angleDeg: number | ((face: KernelShape) => number), inputFaceHashes: number[], hashUpperBound: number): OperationResult;
-    applyComposedTransformWithHistory(shape: KernelShape, transformHandle: KernelType, inputFaceHashes: number[], hashUpperBound: number): OperationResult;
-    composeTransform(ops: Array<{
-        type: 'translate';
-        x: number;
-        y: number;
-        z: number;
-    } | {
-        type: 'rotate';
-        angle: number;
-        axis?: readonly [number, number, number];
-        center?: readonly [number, number, number];
-    }>): {
-        handle: KernelType;
-        dispose: () => void;
-    };
-    mesh(shape: KernelShape, options: MeshOptions): KernelMeshResult;
-    meshEdges(shape: KernelShape, tolerance: number, angularTolerance: number): KernelEdgeMeshResult;
-    hasTriangulation(_shape: KernelShape): boolean;
-    meshShape(_shape: KernelShape, _tolerance: number, _angularTolerance: number): void;
-    exportSTEP(shapes: KernelShape[]): string;
-    exportSTL(shape: KernelShape, binary?: boolean): string | ArrayBuffer;
-    importSTEP(data: string | ArrayBuffer): KernelShape[];
-    importSTL(data: string | ArrayBuffer): KernelShape;
-    exportIGES(shapes: KernelShape[]): string;
-    importIGES(data: string | ArrayBuffer): KernelShape[];
-    exportSTEPAssembly(parts: StepAssemblyPart[], _options?: {
-        unit?: string;
-    }): string;
-    export3MF(shape: KernelShape, tolerance: number): ArrayBuffer;
-    exportGLB(shape: KernelShape, tolerance: number): ArrayBuffer;
-    exportOBJ(shape: KernelShape, tolerance: number): ArrayBuffer;
-    exportPLY(shape: KernelShape, tolerance: number): ArrayBuffer;
-    import3MF(data: ArrayBuffer): KernelShape[];
-    importOBJ(data: ArrayBuffer): KernelShape;
-    importGLB(data: ArrayBuffer): KernelShape;
-    toBREP(shape: KernelShape): string;
-    fromBREP(data: string): KernelShape;
-    createXCAFDocument(shapes: Array<{
-        shape: KernelShape;
-        name: string;
-        color?: [number, number, number, number];
-    }>): KernelType;
-    writeXCAFToSTEP(doc: KernelType, _options?: {
-        unit?: string;
-        modelUnit?: string;
-    }): string;
-    exportSTEPConfigured(shapes: Array<{
-        shape: KernelShape;
-        name?: string;
-        color?: [number, number, number, number];
-    }>, _options?: {
-        unit?: string;
-        modelUnit?: string;
-        schema?: number;
-    }): string;
-    volume(shape: KernelShape): number;
-    area(shape: KernelShape): number;
-    length(shape: KernelShape): number;
-    centerOfMass(shape: KernelShape): [number, number, number];
-    linearCenterOfMass(shape: KernelShape): [number, number, number];
-    boundingBox(shape: KernelShape): {
-        min: [number, number, number];
-        max: [number, number, number];
-    };
-    measureBulk(shape: KernelShape, includeLinear?: boolean): BulkMeasurement;
-    distance(shape1: KernelShape, shape2: KernelShape): DistanceResult;
-    surfaceCurvature(face: KernelShape, u: number, v: number): {
-        gaussian: number;
-        mean: number;
-        max: number;
-        min: number;
-        maxDirection: [number, number, number];
-        minDirection: [number, number, number];
-    };
-    surfaceCenterOfMass(face: KernelShape): [number, number, number];
-    createDistanceQuery(referenceShape: KernelShape): {
-        distanceTo(shape: KernelShape): {
-            value: number;
-            point1: [number, number, number];
-            point2: [number, number, number];
-        };
-        dispose(): void;
-    };
-    iterShapes(shape: KernelShape, type: ShapeType): KernelShape[];
-    iterShapeList(list: KernelShape, callback: (item: KernelShape) => void): void;
-    shapeType(shape: KernelShape): ShapeType;
-    isSame(a: KernelShape, b: KernelShape): boolean;
-    isEqual(a: KernelShape, b: KernelShape): boolean;
-    downcast(shape: KernelShape, _type?: ShapeType): KernelShape;
-    hashCode(shape: KernelShape, upperBound: number): number;
-    isNull(shape: KernelShape): boolean;
-    shapeOrientation(shape: KernelShape): ShapeOrientation;
-    edgeToFaceMap(shape: KernelShape): string;
-    sharedEdges(faceA: KernelShape, faceB: KernelShape): KernelShape[];
-    adjacentFaces(shape: KernelShape, face: KernelShape): KernelShape[];
-    sew(shapes: KernelShape[], tolerance?: number): KernelShape;
-    vertexPosition(vertex: KernelShape): [number, number, number];
-    surfaceType(face: KernelShape): SurfaceType;
-    uvBounds(face: KernelShape): {
-        uMin: number;
-        uMax: number;
-        vMin: number;
-        vMax: number;
-    };
-    outerWire(face: KernelShape): KernelShape;
-    surfaceNormal(face: KernelShape, u: number, v: number): [number, number, number];
-    pointOnSurface(face: KernelShape, u: number, v: number): [number, number, number];
-    uvFromPoint(face: KernelShape, point: [number, number, number]): [number, number] | null;
-    projectPointOnFace(face: KernelShape, point: [number, number, number]): [number, number, number];
-    curveTangent(shape: KernelShape, param: number): {
-        point: [number, number, number];
-        tangent: [number, number, number];
-    };
-    curveParameters(shape: KernelShape): [number, number];
-    curvePointAtParam(shape: KernelShape, param: number): [number, number, number];
-    curveIsClosed(shape: KernelShape): boolean;
-    curveIsPeriodic(shape: KernelShape): boolean;
-    curvePeriod(shape: KernelShape): number;
-    curveType(shape: KernelShape): string;
-    curveDegreeElevate(edge: KernelShape, elevateBy: number): KernelShape;
-    curveKnotInsert(edge: KernelShape, knot: number, times: number): KernelShape;
-    curveKnotRemove(edge: KernelShape, knot: number, tolerance: number): KernelShape;
-    curveSplit(edge: KernelShape, param: number): [KernelShape, KernelShape];
-    approximateSurfaceLspia(coords: number[], rows: number, cols: number, degreeU: number, degreeV: number, numCpsU: number, numCpsV: number, tolerance: number, maxIterations: number): KernelShape;
-    untrimFace(face: KernelShape, samplesPerCurve: number, interiorSamples: number): KernelShape;
-    createCurveAdaptor(shape: KernelShape): KernelType;
-    getBezierPenultimatePole(edge: KernelShape): [number, number, number] | null;
-    getSurfaceCylinderData(surface: KernelType): {
-        radius: number;
-        isDirect: boolean;
-    } | null;
-    reverseSurfaceU(surface: KernelType): KernelType;
-    classifyPointOnFace(face: KernelShape, u: number, v: number, tolerance?: number): 'in' | 'on' | 'out';
-    classifyPointRobust(shape: KernelShape, point: [number, number, number], tolerance: number): string;
-    classifyPointWinding(shape: KernelShape, point: [number, number, number], tolerance: number): string;
-    detectSmallFeatures(shape: KernelShape, areaThreshold: number, tolerance: number): KernelShape[];
-    recognizeFeatures(shape: KernelShape, tolerance: number): string;
-    projectEdges(shape: KernelShape, _cameraOrigin: [number, number, number], _cameraDirection: [number, number, number], _cameraXAxis?: [number, number, number]): {
-        visible: {
-            outline: KernelShape;
-            smooth: KernelShape;
-            sharp: KernelShape;
-        };
-        hidden: {
-            outline: KernelShape;
-            smooth: KernelShape;
-            sharp: KernelShape;
-        };
-    };
-    getNurbsCurveData(_edge: KernelShape): NurbsCurveData | null;
-    getNurbsSurfaceData(_face: KernelShape): NurbsSurfaceData | null;
-    isValid(shape: KernelShape): boolean;
-    isValidStrict(shape: KernelShape): boolean;
-    healSolid(shape: KernelShape): KernelShape | null;
-    healFace(shape: KernelShape): KernelShape;
-    healWire(wire: KernelShape, _face?: KernelShape): KernelShape;
-    fixShape(shape: KernelShape): KernelShape;
-    fixSelfIntersection(wire: KernelShape): KernelShape;
-    mergeCoincidentVertices(shape: KernelShape, tolerance: number): number;
-    removeDegenerateEdges(shape: KernelShape, tolerance: number): number;
-    fixFaceOrientations(shape: KernelShape): number;
-    validationDetails(shape: KernelShape): string | null;
-    makeNonPlanarFace(wire: KernelShape): KernelShape;
-    addHolesInFace(face: KernelShape, holeWires: KernelShape[]): KernelShape;
-    removeHolesFromFace(face: KernelShape): KernelShape;
-    makeFaceOnSurface(_surface: KernelType, wire: KernelShape): KernelShape;
-    bsplineSurface(points: [number, number, number][], rows: number, cols: number): KernelShape;
-    triangulatedSurface(points: [number, number, number][], rows: number, cols: number): KernelShape;
-    buildTriFace(a: [number, number, number], b: [number, number, number], c: [number, number, number]): KernelShape | null;
-    sewAndSolidify(faces: KernelShape[], tolerance: number): KernelShape;
-    interpolatePoints(points: [number, number, number][], options?: {
-        periodic?: boolean;
-        tolerance?: number;
-    }): KernelShape;
-    approximatePoints(points: [number, number, number][], options?: {
-        tolerance?: number;
-        degMin?: number;
-        degMax?: number;
-        smoothing?: [number, number, number] | null;
-    }): KernelShape;
-    createPoint3d(x: number, y: number, z: number): KernelType;
-    createDirection3d(x: number, y: number, z: number): KernelType;
-    createVector3d(x: number, y: number, z: number): KernelType;
-    createAxis1(cx: number, cy: number, cz: number, dx: number, dy: number, dz: number): KernelType;
-    createAxis2(ox: number, oy: number, oz: number, zx: number, zy: number, zz: number, xx?: number, xy?: number, xz?: number): KernelType;
-    createAxis3(ox: number, oy: number, oz: number, zx: number, zy: number, zz: number, xx?: number, xy?: number, xz?: number): KernelType;
-    meshBoolean(positionsA: number[], indicesA: number[], positionsB: number[], indicesB: number[], op: string, tolerance: number): KernelMeshResult;
-    sketchNew(): number;
-    sketchAddPoint(sketch: number, x: number, y: number, fixed: boolean): number;
-    sketchAddArc(sketch: number, centerIdx: number, startIdx: number, endIdx: number): number;
-    sketchAddConstraint(sketch: number, constraintJson: string): void;
-    sketchSolve(sketch: number, maxIterations: number, tolerance: number): string;
-    sketchDof(sketch: number): string;
-    checkpoint(): number;
-    checkpointCount(): number;
-    restoreCheckpoint(cp: number): void;
-    discardCheckpoint(cp: number): void;
-    dispose(_handle: {
-        delete(): void;
-    }): void;
-    executeBatch(json: string): string;
-    createPoint2d(x: number, y: number): KernelType;
-    createDirection2d(x: number, y: number): KernelType;
-    createVector2d(x: number, y: number): KernelType;
-    createAxis2d(px: number, py: number, dx: number, dy: number): KernelType;
-    wrapCurve2dHandle(handle: KernelType): Curve2dHandle;
-    createCurve2dAdaptor(handle: Curve2dHandle): KernelType;
-    makeLine2d(x1: number, y1: number, x2: number, y2: number): Curve2dHandle;
-    makeCircle2d(cx: number, cy: number, radius: number, sense?: boolean): Curve2dHandle;
-    makeArc2dThreePoints(x1: number, y1: number, xm: number, ym: number, x2: number, y2: number): Curve2dHandle;
-    makeArc2dTangent(sx: number, sy: number, tx: number, ty: number, ex: number, ey: number): Curve2dHandle;
-    makeEllipse2d(cx: number, cy: number, major: number, minor: number, xDirX?: number, xDirY?: number, sense?: boolean): Curve2dHandle;
-    makeEllipseArc2d(cx: number, cy: number, major: number, minor: number, start: number, end: number, xDirX?: number, xDirY?: number, sense?: boolean): Curve2dHandle;
-    makeBezier2d(points: [number, number][]): Curve2dHandle;
-    makeBSpline2d(points: [number, number][], _options?: Record<string, unknown>): Curve2dHandle;
-    evaluateCurve2d(curve: Curve2dHandle, param: number): [number, number];
-    evaluateCurve2dD1(curve: Curve2dHandle, param: number): {
-        point: [number, number];
-        tangent: [number, number];
-    };
-    getCurve2dBounds(curve: Curve2dHandle): {
-        first: number;
-        last: number;
-    };
-    getCurve2dType(curve: Curve2dHandle): string;
-    trimCurve2d(curve: Curve2dHandle, start: number, end: number): Curve2dHandle;
-    reverseCurve2d(_curve: Curve2dHandle): void;
-    copyCurve2d(curve: Curve2dHandle): Curve2dHandle;
-    offsetCurve2d(curve: Curve2dHandle, offset: number): Curve2dHandle;
-    translateCurve2d(curve: Curve2dHandle, dx: number, dy: number): Curve2dHandle;
-    rotateCurve2d(curve: Curve2dHandle, angle: number, cx: number, cy: number): Curve2dHandle;
-    scaleCurve2d(curve: Curve2dHandle, factor: number, cx: number, cy: number): Curve2dHandle;
-    mirrorCurve2dAtPoint(curve: Curve2dHandle, cx: number, cy: number): Curve2dHandle;
-    mirrorCurve2dAcrossAxis(curve: Curve2dHandle, ox: number, oy: number, dx: number, dy: number): Curve2dHandle;
-    affinityTransform2d(curve: Curve2dHandle, ox: number, oy: number, dx: number, dy: number, ratio: number): Curve2dHandle;
-    createIdentityGTrsf2d(): KernelType;
-    createAffinityGTrsf2d(ox: number, oy: number, dx: number, dy: number, ratio: number): KernelType;
-    createTranslationGTrsf2d(dx: number, dy: number): KernelType;
-    createMirrorGTrsf2d(cx: number, cy: number, mode: 'point' | 'axis', ox?: number, oy?: number, dx?: number, dy?: number): KernelType;
-    createRotationGTrsf2d(angle: number, cx: number, cy: number): KernelType;
-    createScaleGTrsf2d(factor: number, cx: number, cy: number): KernelType;
-    setGTrsf2dTranslationPart(gtrsf: KernelType, dx: number, dy: number): void;
-    multiplyGTrsf2d(base: KernelType, other: KernelType): void;
-    transformCurve2dGeneral(curve: Curve2dHandle, gtrsf: KernelType): Curve2dHandle;
-    intersectCurves2d(c1: Curve2dHandle, c2: Curve2dHandle, tolerance: number): {
-        points: [number, number][];
-        segments: Curve2dHandle[];
-    };
-    projectPointOnCurve2d(curve: Curve2dHandle, x: number, y: number): {
-        param: number;
-        distance: number;
-    } | null;
-    distanceBetweenCurves2d(c1: Curve2dHandle, c2: Curve2dHandle, p1s: number, p1e: number, p2s: number, p2e: number): number;
-    approximateCurve2dAsBSpline(curve: Curve2dHandle, tol: number, cont: 'C0' | 'C1' | 'C2' | 'C3', maxSeg: number): Curve2dHandle;
-    decomposeBSpline2dToBeziers(curve: Curve2dHandle): Curve2dHandle[];
-    createBoundingBox2d(): BBox2dHandle;
-    addCurveToBBox2d(bbox: BBox2dHandle, curve: Curve2dHandle, tol: number): void;
-    getBBox2dBounds(bbox: BBox2dHandle): {
-        xMin: number;
-        yMin: number;
-        xMax: number;
-        yMax: number;
-    };
-    mergeBBox2d(target: BBox2dHandle, other: BBox2dHandle): void;
-    isBBox2dOut(a: BBox2dHandle, b: BBox2dHandle): boolean;
-    isBBox2dOutPoint(bbox: BBox2dHandle, x: number, y: number): boolean;
-    getCurve2dCircleData(curve: Curve2dHandle): {
-        cx: number;
-        cy: number;
-        radius: number;
-        isDirect: boolean;
-    } | null;
-    getCurve2dEllipseData(curve: Curve2dHandle): {
-        majorRadius: number;
-        minorRadius: number;
-        xAxisAngle: number;
-        isDirect: boolean;
-    } | null;
-    getCurve2dBezierPoles(curve: Curve2dHandle): [number, number][] | null;
-    getCurve2dBezierDegree(curve: Curve2dHandle): number | null;
-    getCurve2dBSplineData(curve: Curve2dHandle): {
-        poles: [number, number][];
-        knots: number[];
-        multiplicities: number[];
-        degree: number;
-        isPeriodic: boolean;
-    } | null;
-    serializeCurve2d(curve: Curve2dHandle): string;
-    deserializeCurve2d(data: string): Curve2dHandle;
-    splitCurve2d(curve: Curve2dHandle, params: number[]): Curve2dHandle[];
-    liftCurve2dToPlane(curve: Curve2dHandle, origin: [number, number, number], planeZ: [number, number, number], planeX: [number, number, number]): KernelShape;
-    buildEdgeOnSurface(curve: Curve2dHandle, surface: KernelType): KernelShape;
-    extractSurfaceFromFace(face: KernelShape): KernelType;
-    extractCurve2dFromEdge(edge: KernelShape, face: KernelShape): Curve2dHandle;
-    buildCurves3d(_wire: KernelShape): void;
-    fixWireOnFace(wire: KernelShape, _face: KernelShape, _tolerance: number): KernelShape;
-    fillSurface(wires: KernelShape[], _options?: Record<string, unknown>): KernelShape;
 }
-//# sourceMappingURL=brepkitAdapter.d.ts.map
+export {};

package/dist/kernel/brepkit/brepkitWasmTypes.d.ts

@@ -293,4 +293,3 @@ export interface BrepkitKernel {
     /** Release the entire arena. */
     free(): void;
 }
-//# sourceMappingURL=brepkitWasmTypes.d.ts.map

package/dist/kernel/brepkit/constructionOps.d.ts

@@ -54,4 +54,54 @@ export declare function createVector3d(_bk: BrepkitKernel, x: number, y: number,
 export declare function createAxis1(_bk: BrepkitKernel, cx: number, cy: number, cz: number, dx: number, dy: number, dz: number): KernelType;
 export declare function createAxis2(_bk: BrepkitKernel, ox: number, oy: number, oz: number, zx: number, zy: number, zz: number, xx?: number, xy?: number, xz?: number): KernelType;
 export declare function createAxis3(_bk: BrepkitKernel, ox: number, oy: number, oz: number, zx: number, zy: number, zz: number, xx?: number, xy?: number, xz?: number): KernelType;
-//# sourceMappingURL=constructionOps.d.ts.map
+/** Co-located factory: returns the construction slice of {@link KernelAdapter} bound to `bk`. */
+export declare function makeConstructionOps(bk: BrepkitKernel): {
+    makeVertex: (x: number, y: number, z: number) => any;
+    makeEdge: (curve: any, start: number | undefined, end: number | undefined) => any;
+    makeWire: (edges: any[]) => any;
+    makeWireFromMixed: (items: any[]) => any;
+    makeFace: (wire: any, planar: boolean | undefined) => any;
+    makeBox: (w: number, h: number, d: number) => any;
+    makeRectangle: (w: number, h: number) => any;
+    makeCylinder: (radius: number, height: number, center: [number, number, number] | undefined, direction: [number, number, number] | undefined) => any;
+    makeSphere: (radius: number, center: [number, number, number] | undefined) => any;
+    makeCone: (r1: number, r2: number, h: number, center: [number, number, number] | undefined, direction: [number, number, number] | undefined) => any;
+    makeTorus: (major: number, minor: number, center: [number, number, number] | undefined, direction: [number, number, number] | undefined) => any;
+    makeEllipsoid: (a: number, b: number, c: number) => any;
+    makeLineEdge: (p1: [number, number, number], p2: [number, number, number]) => any;
+    makeCircleEdge: (center: [number, number, number], normal: [number, number, number], radius: number) => any;
+    makeCircleArc: (center: [number, number, number], normal: [number, number, number], radius: number, startAngle: number, endAngle: number) => any;
+    makeArcEdge: (p1: [number, number, number], p2: [number, number, number], p3: [number, number, number]) => any;
+    makeEllipseEdge: (center: [number, number, number], normal: [number, number, number], majorRadius: number, minorRadius: number, xDir: [number, number, number] | undefined) => any;
+    makeEllipseArc: (center: [number, number, number], normal: [number, number, number], majorRadius: number, minorRadius: number, startAngle: number, endAngle: number, xDir: [number, number, number] | undefined) => any;
+    makeBezierEdge: (points: [number, number, number][]) => any;
+    makeTangentArc: (startPoint: [number, number, number], startTangent: [number, number, number], endPoint: [number, number, number]) => any;
+    makeHelixWire: (pitch: number, height: number, radius: number, center: [number, number, number] | undefined, direction: [number, number, number] | undefined, leftHanded: boolean | undefined) => any;
+    makeCompound: (shapes: any[]) => any;
+    makeBoxFromCorners: (p1: [number, number, number], p2: [number, number, number]) => any;
+    solidFromShell: (shell: any) => any;
+    makeNonPlanarFace: (wire: any) => any;
+    addHolesInFace: (face: any, holeWires: any[]) => any;
+    removeHolesFromFace: (face: any) => any;
+    makeFaceOnSurface: (surface: any, wire: any) => any;
+    bsplineSurface: (points: [number, number, number][], rows: number, cols: number) => any;
+    triangulatedSurface: (points: [number, number, number][], rows: number, cols: number) => any;
+    buildTriFace: (a: [number, number, number], b: [number, number, number], c: [number, number, number]) => any;
+    sewAndSolidify: (faces: any[], tolerance: number) => any;
+    interpolatePoints: (points: [number, number, number][], options: {
+        periodic?: boolean;
+        tolerance?: number;
+    } | undefined) => any;
+    approximatePoints: (points: [number, number, number][], options: {
+        tolerance?: number;
+        degMin?: number;
+        degMax?: number;
+        smoothing?: [number, number, number] | null;
+    } | undefined) => any;
+    createPoint3d: (x: number, y: number, z: number) => any;
+    createDirection3d: (x: number, y: number, z: number) => any;
+    createVector3d: (x: number, y: number, z: number) => any;
+    createAxis1: (cx: number, cy: number, cz: number, dx: number, dy: number, dz: number) => any;
+    createAxis2: (ox: number, oy: number, oz: number, zx: number, zy: number, zz: number, xx: number | undefined, xy: number | undefined, xz: number | undefined) => any;
+    createAxis3: (ox: number, oy: number, oz: number, zx: number, zy: number, zz: number, xx: number | undefined, xy: number | undefined, xz: number | undefined) => any;
+};

package/dist/kernel/brepkit/evolutionOps.d.ts

@@ -23,10 +23,41 @@ export declare function composeTransform(_bk: BrepkitKernel, ops: Array<{
 } | {
     type: 'rotate';
     angle: number;
-    axis?: readonly [number, number, number];
-    center?: readonly [number, number, number];
+    axis?: readonly [number, number, number] | undefined;
+    center?: readonly [number, number, number] | undefined;
 }>): {
     handle: KernelType;
     dispose: () => void;
 };
-//# sourceMappingURL=evolutionOps.d.ts.map
+/** Co-located factory: returns the history-tracking slice of {@link KernelAdapter} bound to `bk`. */
+export declare function makeEvolutionOps(bk: BrepkitKernel): {
+    translateWithHistory: (shape: any, x: number, y: number, z: number, inputFaceHashes: number[], hashUpperBound: number) => OperationResult;
+    rotateWithHistory: (shape: any, angle: number, inputFaceHashes: number[], hashUpperBound: number, axis: readonly [number, number, number] | undefined, center: readonly [number, number, number] | undefined) => OperationResult;
+    mirrorWithHistory: (shape: any, origin: readonly [number, number, number], normal: readonly [number, number, number], inputFaceHashes: number[], hashUpperBound: number) => OperationResult;
+    scaleWithHistory: (shape: any, center: readonly [number, number, number], factor: number, inputFaceHashes: number[], hashUpperBound: number) => OperationResult;
+    generalTransformWithHistory: (shape: any, linear: readonly [number, number, number, number, number, number, number, number, number], translation: readonly [number, number, number], isOrthogonal: boolean, inputFaceHashes: number[], hashUpperBound: number) => OperationResult;
+    fuseWithHistory: (shape: any, tool: any, inputFaceHashes: number[], hashUpperBound: number, options: BooleanOptions | undefined) => DiagnosticOperationResult;
+    cutWithHistory: (shape: any, tool: any, inputFaceHashes: number[], hashUpperBound: number, options: BooleanOptions | undefined) => DiagnosticOperationResult;
+    intersectWithHistory: (shape: any, tool: any, inputFaceHashes: number[], hashUpperBound: number, options: BooleanOptions | undefined) => DiagnosticOperationResult;
+    filletWithHistory: (shape: any, edges: any[], radius: number | [number, number] | ((edge: KernelShape) => number | [number, number]), inputFaceHashes: number[], hashUpperBound: number) => OperationResult;
+    chamferWithHistory: (shape: any, edges: any[], distance: number | [number, number] | ((edge: KernelShape) => number | [number, number]), inputFaceHashes: number[], hashUpperBound: number) => OperationResult;
+    shellWithHistory: (shape: any, faces: any[], thickness: number, inputFaceHashes: number[], hashUpperBound: number, tolerance: number | undefined) => OperationResult;
+    thickenWithHistory: (shape: any, thickness: number, inputFaceHashes: number[], hashUpperBound: number) => OperationResult;
+    offsetWithHistory: (shape: any, distance: number, inputFaceHashes: number[], hashUpperBound: number, tolerance: number | undefined) => OperationResult;
+    draftWithHistory: (shape: any, faces: any[], pullDirection: [number, number, number], neutralPlane: [number, number, number], angleDeg: number | ((face: KernelShape) => number), inputFaceHashes: number[], hashUpperBound: number) => OperationResult;
+    applyComposedTransformWithHistory: (shape: any, transformHandle: any, inputFaceHashes: number[], hashUpperBound: number) => OperationResult;
+    composeTransform: (ops: ({
+        type: "translate";
+        x: number;
+        y: number;
+        z: number;
+    } | {
+        type: "rotate";
+        angle: number;
+        axis?: readonly [number, number, number] | undefined;
+        center?: readonly [number, number, number] | undefined;
+    })[]) => {
+        handle: KernelType;
+        dispose: () => void;
+    };
+};

package/dist/kernel/brepkit/geometryOps.d.ts

@@ -1,5 +1,5 @@
 import { BrepkitKernel } from './brepkitWasmTypes.js';
-import { KernelShape, KernelType, SurfaceType } from '../types.js';
+import { KernelShape, KernelType, NurbsCurveData, NurbsSurfaceData, SurfaceType } from '../types.js';
 export declare function vertexPosition(bk: BrepkitKernel, vertex: KernelShape): [number, number, number];
 export declare function surfaceType(bk: BrepkitKernel, face: KernelShape): SurfaceType;
 export declare function uvBounds(bk: BrepkitKernel, face: KernelShape): {
@@ -53,4 +53,65 @@ export declare function projectEdges(bk: BrepkitKernel, shape: KernelShape, _cam
         sharp: KernelShape;
     };
 };
-//# sourceMappingURL=geometryOps.d.ts.map
+/** brepkit does not support NURBS introspection on edges. Always returns null. */
+export declare function getNurbsCurveData(_bk: BrepkitKernel, _edge: KernelShape): NurbsCurveData | null;
+/** brepkit does not support NURBS introspection on faces. Always returns null. */
+export declare function getNurbsSurfaceData(_bk: BrepkitKernel, _face: KernelShape): NurbsSurfaceData | null;
+/** Co-located factory: returns the geometry-query slice of {@link KernelAdapter} bound to `bk`. */
+export declare function makeGeometryOps(bk: BrepkitKernel): {
+    vertexPosition: (vertex: any) => [number, number, number];
+    surfaceType: (face: any) => SurfaceType;
+    uvBounds: (face: any) => {
+        uMin: number;
+        uMax: number;
+        vMin: number;
+        vMax: number;
+    };
+    outerWire: (face: any) => any;
+    surfaceNormal: (face: any, u: number, v: number) => [number, number, number];
+    pointOnSurface: (face: any, u: number, v: number) => [number, number, number];
+    uvFromPoint: (face: any, point: [number, number, number]) => [number, number] | null;
+    projectPointOnFace: (face: any, point: [number, number, number]) => [number, number, number];
+    curveTangent: (shape: any, param: number) => {
+        point: [number, number, number];
+        tangent: [number, number, number];
+    };
+    curveParameters: (shape: any) => [number, number];
+    curvePointAtParam: (shape: any, param: number) => [number, number, number];
+    curveIsClosed: (shape: any) => boolean;
+    curveIsPeriodic: (shape: any) => boolean;
+    curvePeriod: (shape: any) => number;
+    curveType: (shape: any) => string;
+    curveDegreeElevate: (edge: any, elevateBy: number) => any;
+    curveKnotInsert: (edge: any, knot: number, times: number) => any;
+    curveKnotRemove: (edge: any, knot: number, tolerance: number) => any;
+    curveSplit: (edge: any, param: number) => [any, any];
+    approximateSurfaceLspia: (coords: number[], rows: number, cols: number, degU: number, degV: number, cpsU: number, cpsV: number, tol: number, maxIter: number) => any;
+    untrimFace: (face: any, samplesPerCurve: number, interiorSamples: number) => any;
+    createCurveAdaptor: (shape: any) => any;
+    getBezierPenultimatePole: (edge: any) => [number, number, number] | null;
+    getSurfaceCylinderData: (surface: any) => {
+        radius: number;
+        isDirect: boolean;
+    } | null;
+    reverseSurfaceU: (surface: any) => any;
+    classifyPointOnFace: (face: any, u: number, v: number, tolerance: number | undefined) => "in" | "on" | "out";
+    classifyPointRobust: (shape: any, point: [number, number, number], tolerance: number) => string;
+    classifyPointWinding: (shape: any, point: [number, number, number], tolerance: number) => string;
+    detectSmallFeatures: (shape: any, areaThreshold: number, tolerance: number) => any[];
+    recognizeFeatures: (shape: any, tolerance: number) => string;
+    projectEdges: (shape: any, cameraOrigin: [number, number, number], cameraDirection: [number, number, number], cameraXAxis: [number, number, number] | undefined) => {
+        visible: {
+            outline: KernelShape;
+            smooth: KernelShape;
+            sharp: KernelShape;
+        };
+        hidden: {
+            outline: KernelShape;
+            smooth: KernelShape;
+            sharp: KernelShape;
+        };
+    };
+    getNurbsCurveData: (edge: any) => NurbsCurveData | null;
+    getNurbsSurfaceData: (face: any) => NurbsSurfaceData | null;
+};