brepjs 18.6.0 → 18.14.3

package/dist/kernel/occt/defaultAdapter.d.ts

@@ -1,447 +1,16 @@
-import { BooleanOpType, CheckBooleanResult, KernelAdapter, KernelMeshResult, KernelEdgeMeshResult, DistanceResult, OperationResult, DiagnosticOperationResult, KernelInstance, KernelShape, KernelType, BooleanOptions, ShapeType, SurfaceType, ShapeOrientation, MeshOptions, StepAssemblyPart, NurbsCurveData, NurbsSurfaceData } from '../types.js';
-import { Kernel2DCapability, Curve2dHandle, BBox2dHandle } from '../kernel2dTypes.js';
-import { BulkMeasurement } from '../interfaces/measureOps.js';
-import { TransformEntry } from '../interfaces/transformOps.js';
-import { LoftBatchEntry, ExtrudeBatchEntry } from './sweepOps.js';
-import { ShellBatchEntry, FilletBatchEntry } from './modifierOps.js';
+import { KernelAdapter, KernelInstance } from '../types.js';
+import { Kernel2DCapability } from '../kernel2dTypes.js';
+export interface DefaultAdapter extends KernelAdapter, Kernel2DCapability {
+}
 /**
- * Default implementation of KernelAdapter.
+ * Default implementation of `KernelAdapter` backed by OpenCascade WASM.
+ *
+ * All methods are composed from per-domain factories at construction time —
+ * there is no body-level method declaration. To find a method's implementation,
+ * grep for `function <name>` in `src/kernel/occt/*Ops.ts`.
  */
-export declare class DefaultAdapter implements KernelAdapter, Kernel2DCapability {
+export declare class DefaultAdapter {
     readonly oc: KernelInstance;
     readonly kernelId = "occt";
     constructor(oc: 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;
-    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;
-    makeWireFromMixed(items: KernelShape[]): KernelShape;
-    makeFace(wire: KernelShape, planar?: boolean): KernelShape;
-    makeBox(width: number, height: number, depth: 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;
-    makeCompound(shapes: KernelShape[]): KernelShape;
-    makeBoxFromCorners(p1: [number, number, number], p2: [number, number, number]): KernelShape;
-    makeRectangle(width: number, height: number): KernelShape;
-    solidFromShell(shell: KernelShape): KernelShape;
-    extrude(face: KernelShape, direction: [number, number, number], length: number): KernelShape;
-    revolve(shape: KernelShape, axis: KernelType, 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;
-    loftBatch(entries: ReadonlyArray<LoftBatchEntry>): KernelShape[];
-    extrudeBatch(entries: ReadonlyArray<ExtrudeBatchEntry>): 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;
-    shellBatch(entries: ReadonlyArray<ShellBatchEntry>): KernelShape[];
-    filletBatch(entries: ReadonlyArray<FilletBatchEntry>): KernelShape[];
-    transform(shape: KernelShape, trsf: KernelType): KernelShape;
-    translate(shape: KernelShape, x: number, y: number, z: number): KernelShape;
-    rotate(shape: KernelShape, angle: number, axis?: [number, number, number], center?: [number, number, number]): KernelShape;
-    mirror(shape: KernelShape, origin: [number, number, number], normal: [number, number, number]): KernelShape;
-    scale(shape: KernelShape, center: [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;
-    mesh(shape: KernelShape, options: MeshOptions): KernelMeshResult;
-    meshEdges(shape: KernelShape, tolerance: number, angularTolerance: number): KernelEdgeMeshResult;
-    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;
-    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;
-    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;
-    reverseShape(shape: KernelShape): 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;
-    getSurfaceCylinderData(surface: KernelType): {
-        radius: number;
-        isDirect: boolean;
-    } | null;
-    reverseSurfaceU(surface: KernelType): KernelType;
-    getNurbsCurveData(edge: KernelShape): NurbsCurveData | null;
-    getNurbsSurfaceData(face: KernelShape): NurbsSurfaceData | null;
-    simplify(shape: KernelShape): KernelShape;
-    isValid(shape: KernelShape): boolean;
-    sew(shapes: KernelShape[], tolerance?: number): KernelShape;
-    healSolid(shape: KernelShape): KernelShape | null;
-    healFace(shape: KernelShape): KernelShape;
-    healWire(wire: KernelShape, face?: KernelShape): KernelShape;
-    offsetWire2D(wire: KernelShape, offset: number, joinType?: number | 'arc' | 'intersection' | 'tangent'): KernelShape;
-    distance(shape1: KernelShape, shape2: KernelShape): DistanceResult;
-    classifyPointOnFace(face: KernelShape, u: number, v: number, tolerance?: number): 'in' | 'on' | 'out';
-    split(shape: KernelShape, tools: KernelShape[]): 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;
-    toBREP(shape: KernelShape): string;
-    fromBREP(data: string): KernelShape;
-    hasTriangulation(shape: KernelShape): boolean;
-    meshShape(shape: KernelShape, tolerance: number, angularTolerance: number): void;
-    translateWithHistory(shape: KernelShape, x: number, y: number, z: number, inputFaceHashes: number[], hashUpperBound: number): OperationResult;
-    rotateWithHistory(shape: KernelShape, angle: number, inputFaceHashes: number[], hashUpperBound: number, axis?: [number, number, number], center?: [number, number, number]): OperationResult;
-    mirrorWithHistory(shape: KernelShape, origin: [number, number, number], normal: [number, number, number], inputFaceHashes: number[], hashUpperBound: number): OperationResult;
-    scaleWithHistory(shape: KernelShape, center: [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;
-    composeTransform(ops: Array<{
-        type: 'translate';
-        x: number;
-        y: number;
-        z: number;
-    } | {
-        type: 'rotate';
-        angle: number;
-        axis?: [number, number, number];
-        center?: [number, number, number];
-    }>): {
-        handle: KernelType;
-        dispose: () => void;
-    };
-    applyComposedTransformWithHistory(shape: KernelShape, transformHandle: KernelType, inputFaceHashes: number[], hashUpperBound: number): OperationResult;
-    sweepPipeShell(profile: KernelShape, spine: KernelShape, options?: {
-        transitionMode?: 'transformed' | 'round' | 'right';
-        auxiliary?: KernelShape;
-        law?: KernelType;
-        contact?: boolean;
-        correction?: boolean;
-        frenet?: boolean;
-        support?: KernelType;
-        shellMode?: boolean;
-        tolerance?: number;
-        boundTolerance?: number;
-        angularTolerance?: number;
-        maxDegree?: number;
-        maxSegments?: number;
-    }): KernelShape | {
-        shape: KernelShape;
-        firstShape: KernelShape;
-        lastShape: KernelShape;
-    };
-    loftAdvanced(wires: KernelShape[], options?: {
-        solid?: boolean;
-        ruled?: boolean;
-        tolerance?: number;
-        startVertex?: KernelShape;
-        endVertex?: KernelShape;
-    }): KernelShape;
-    buildExtrusionLaw(profile: 'linear' | 's-curve', length: number, endFactor: number): KernelType;
-    revolveVec(shape: KernelShape, center: [number, number, number], direction: [number, number, number], angle: 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[];
-    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;
-    fixShape(shape: KernelShape): KernelShape;
-    fixSelfIntersection(wire: KernelShape): KernelShape;
-    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;
-    };
-    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;
-        };
-    };
-    draftPrism(shape: KernelShape, face: KernelShape, baseFace: KernelShape, height: number | null, angleDeg: number, fuse: boolean): 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;
-    wrapCurve2dHandle(handle: KernelType): Curve2dHandle;
-    createCurve2dAdaptor(handle: Curve2dHandle): KernelType;
-    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;
-    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(startX: number, startY: number, tangentX: number, tangentY: number, endX: number, endY: number): Curve2dHandle;
-    makeEllipse2d(cx: number, cy: number, majorRadius: number, minorRadius: number, xDirX?: number, xDirY?: number, sense?: boolean): Curve2dHandle;
-    makeEllipseArc2d(cx: number, cy: number, majorRadius: number, minorRadius: number, startAngle: number, endAngle: number, xDirX?: number, xDirY?: number, sense?: boolean): Curve2dHandle;
-    makeBezier2d(points: [number, number][]): Curve2dHandle;
-    makeBSpline2d(points: [number, number][], options?: {
-        degMin?: number;
-        degMax?: number;
-        continuity?: 'C0' | 'C1' | 'C2' | 'C3';
-        tolerance?: number;
-        smoothing?: [number, number, number] | null;
-    }): 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, originX: number, originY: number, dirX: number, dirY: number): Curve2dHandle;
-    affinityTransform2d(curve: Curve2dHandle, axisOriginX: number, axisOriginY: number, axisDirX: number, axisDirY: number, ratio: number): Curve2dHandle;
-    createIdentityGTrsf2d(): KernelType;
-    createAffinityGTrsf2d(originX: number, originY: number, dirX: number, dirY: number, ratio: number): KernelType;
-    createTranslationGTrsf2d(dx: number, dy: number): KernelType;
-    createMirrorGTrsf2d(cx: number, cy: number, mode: 'point' | 'axis', originX?: number, originY?: number, dirX?: number, dirY?: 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, p1Start: number, p1End: number, p2Start: number, p2End: number): number;
-    approximateCurve2dAsBSpline(curve: Curve2dHandle, tolerance: number, continuity: 'C0' | 'C1' | 'C2' | 'C3', maxSegments: number): Curve2dHandle;
-    decomposeBSpline2dToBeziers(curve: Curve2dHandle): Curve2dHandle[];
-    createBoundingBox2d(): BBox2dHandle;
-    addCurveToBBox2d(bbox: BBox2dHandle, curve: Curve2dHandle, tolerance: 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, planeOrigin: [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?: {
-        order?: number;
-        nbPtsOnCur?: number;
-        nbIter?: number;
-        tol3d?: number;
-        tol2d?: number;
-        maxDeg?: number;
-        maxSeg?: number;
-    }): KernelShape;
-    createCurveAdaptor(shape: KernelShape): KernelType;
-    getBezierPenultimatePole(edge: KernelShape): [number, number, number] | null;
-    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;
-    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;
-    filletVariable(_shape: KernelShape, _spec: string): 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;
-    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;
-    detectSmallFeatures(_shape: KernelShape, _areaThreshold: number, _tolerance: number): KernelShape[];
-    recognizeFeatures(_shape: KernelShape, _tolerance: number): string;
-    meshBoolean(_positionsA: number[], _indicesA: number[], _positionsB: number[], _indicesB: number[], _op: string, _tolerance: number): KernelMeshResult;
-    booleanPipeline(base: KernelShape, steps: ReadonlyArray<{
-        op: 'fuse' | 'cut' | 'intersect';
-        tool: KernelShape;
-    }>, options?: {
-        glueMode?: number | undefined;
-        fuzzyValue?: number | undefined;
-    }): KernelShape | null;
-    edgeToFaceMap(_shape: KernelShape): string;
-    sharedEdges(_faceA: KernelShape, _faceB: KernelShape): KernelShape[];
-    adjacentFaces(_shape: KernelShape, _face: KernelShape): KernelShape[];
-    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;
-    mergeCoincidentVertices(_shape: KernelShape, _tolerance: number): number;
-    removeDegenerateEdges(_shape: KernelShape, _tolerance: number): number;
-    fixFaceOrientations(_shape: KernelShape): number;
-    classifyPointRobust(_shape: KernelShape, _point: [number, number, number], _tolerance: number): string;
-    classifyPointWinding(_shape: KernelShape, _point: [number, number, number], _tolerance: number): string;
-    executeBatch(_json: string): string;
-    checkpoint(): number;
-    checkpointCount(): number;
-    restoreCheckpoint(_cp: number): void;
-    discardCheckpoint(_cp: number): void;
-    dispose(handle: {
-        delete(): void;
-    }): void;
 }
-//# sourceMappingURL=defaultAdapter.d.ts.map

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

@@ -24,4 +24,3 @@ export declare function booleanWithEvolution(oc: KernelInstance, boolOp: OcctSim
  * with shape evolution tracking.
  */
 export declare function modifierWithEvolution(oc: KernelInstance, builder: OcctEvolutionBuilder, inputShape: KernelShape, inputFaceHashes: number[], hashUpperBound: number): OperationResult;
-//# sourceMappingURL=evolutionOps.d.ts.map

package/dist/kernel/occt/extendedConstructorOps.d.ts

@@ -62,4 +62,34 @@ export declare function createVector3d(oc: KernelInstance, x: number, y: number,
 export declare function createAxis1(oc: KernelInstance, cx: number, cy: number, cz: number, dx: number, dy: number, dz: number): KernelType;
 export declare function createAxis2(oc: KernelInstance, ox: number, oy: number, oz: number, zx: number, zy: number, zz: number, xx?: number, xy?: number, xz?: number): KernelType;
 export declare function createAxis3(oc: KernelInstance, ox: number, oy: number, oz: number, zx: number, zy: number, zz: number, xx?: number, xy?: number, xz?: number): KernelType;
-//# sourceMappingURL=extendedConstructorOps.d.ts.map
+/** Co-located factory: returns the extended-construction slice of {@link KernelAdapter} bound to `oc`. */
+export declare function makeExtendedConstructorOps(oc: KernelInstance): {
+    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;
+    makeRectangle: (width: number, height: number) => any;
+    solidFromShell: (shell: any) => any;
+    makeEllipsoid: (aLength: number, bLength: number, cLength: number) => any;
+    toBREP: (shape: any) => string;
+    fromBREP: (data: string) => any;
+    exportSTEPAssembly: (parts: import('../types.js').StepAssemblyPart[], options: {
+        unit?: string;
+    } | undefined) => string;
+    dispose: (handle: {
+        delete(): void;
+    }) => void;
+    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/occt/geometryQueryOps.d.ts

@@ -71,4 +71,43 @@ export declare function getSurfaceCylinderData(oc: KernelInstance, surface: Kern
 } | null;
 /** Reverse the U direction of a surface. Returns a new surface handle. */
 export declare function reverseSurfaceU(_oc: KernelInstance, surface: KernelType): KernelType;
-//# sourceMappingURL=geometryQueryOps.d.ts.map
+/** Co-located factory: returns the geometry-query slice of {@link KernelAdapter} bound to `oc`. */
+export declare function makeGeometryQueryOps(oc: KernelInstance): {
+    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];
+    shapeOrientation: (shape: any) => ShapeOrientation;
+    downcast: (shape: any, type: import('../types.js').ShapeType | undefined) => any;
+    hashCode: (shape: any, upperBound: number) => number;
+    isNull: (shape: any) => boolean;
+    hasTriangulation: (shape: any) => boolean;
+    meshShape: (shape: any, tolerance: number, angularTolerance: number) => void;
+    getBezierPenultimatePole: (edge: any) => [number, number, number] | null;
+    createCurveAdaptor: (shape: any) => any;
+    reverseShape: (shape: any) => any;
+    curvePointAtParam: (shape: any, param: number) => [number, number, number];
+    curveIsClosed: (shape: any) => boolean;
+    curveIsPeriodic: (shape: any) => boolean;
+    curvePeriod: (shape: any) => number;
+    curveType: (shape: any) => string;
+    getSurfaceCylinderData: (surface: any) => {
+        radius: number;
+        isDirect: boolean;
+    } | null;
+    reverseSurfaceU: (surface: any) => any;
+};

package/dist/kernel/occt/healingOps.d.ts

@@ -15,4 +15,9 @@ export declare function healFace(oc: KernelInstance, shape: KernelShape): Kernel
  * Returns the healed wire.
  */
 export declare function healWire(oc: KernelInstance, wire: KernelShape, face?: KernelShape): KernelShape;
-//# sourceMappingURL=healingOps.d.ts.map
+/** Co-located factory: returns the healing slice of {@link KernelAdapter} bound to `oc`. */
+export declare function makeHealingOps(oc: KernelInstance): {
+    healSolid: (shape: any) => any;
+    healFace: (shape: any) => any;
+    healWire: (wire: any, face: any) => any;
+};

package/dist/kernel/occt/historyOps.d.ts

@@ -13,4 +13,20 @@ export declare function shellWithHistory(oc: KernelInstance, shape: KernelShape,
 export declare function thickenWithHistory(oc: KernelInstance, shape: KernelShape, thickness: number, inputFaceHashes: number[], hashUpperBound: number): OperationResult;
 export declare function offsetWithHistory(oc: KernelInstance, shape: KernelShape, distance: number, inputFaceHashes: number[], hashUpperBound: number, tolerance?: number): OperationResult;
 export declare function draftWithHistory(oc: KernelInstance, shape: KernelShape, faces: KernelShape[], pullDirection: [number, number, number], neutralPlane: [number, number, number], angleDeg: number | ((face: KernelShape) => number), inputFaceHashes: number[], hashUpperBound: number): OperationResult;
-//# sourceMappingURL=historyOps.d.ts.map
+/** Co-located factory: returns the history-tracking slice of {@link KernelAdapter} bound to `oc`. */
+export declare function makeHistoryOps(oc: KernelInstance): {
+    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;
+};

package/dist/kernel/occt/hullOps.d.ts

@@ -19,5 +19,18 @@ export declare function hull(oc: KernelInstance, shapes: KernelShape[], toleranc
  */
 export declare function buildSolidFromFaces(oc: KernelInstance, points: Vec3[], faces: Array<readonly [number, number, number]>, tolerance: number): KernelShape;
 export declare function hullFromPoints(oc: KernelInstance, points: Vec3[], tolerance: number): KernelShape;
+/** Co-located factory: returns the hull/builder slice of {@link KernelAdapter} bound to `oc`. */
+export declare function makeHullOps(oc: KernelInstance): {
+    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;
+};
 export {};
-//# sourceMappingURL=hullOps.d.ts.map

package/dist/kernel/occt/ioOps.d.ts

@@ -28,4 +28,12 @@ export declare function importSTL(oc: KernelInstance, data: string | ArrayBuffer
  * Imports shapes from IGES data.
  */
 export declare function importIGES(oc: KernelInstance, data: string | ArrayBuffer): KernelShape[];
-//# sourceMappingURL=ioOps.d.ts.map
+/** Co-located factory: returns the file-I/O slice of {@link KernelAdapter} bound to `oc`. */
+export declare function makeIoOps(oc: KernelInstance): {
+    exportSTEP: (shapes: any[]) => string;
+    exportSTL: (shape: any, binary: boolean | undefined) => string | ArrayBuffer;
+    importSTEP: (data: string | ArrayBuffer) => any[];
+    importSTL: (data: string | ArrayBuffer) => any;
+    exportIGES: (shapes: any[]) => string;
+    importIGES: (data: string | ArrayBuffer) => any[];
+};