fluidcad 0.0.2

package/lib/dist/filters/filter.js

@@ -0,0 +1,33 @@
+export class ShapeFilter {
+    shapes;
+    builders;
+    constructor(shapes, ...filterBuilders) {
+        this.shapes = shapes;
+        this.builders = filterBuilders;
+    }
+    apply() {
+        if (!this.builders?.length) {
+            return this.shapes;
+        }
+        const result = [];
+        for (const shape of this.shapes) {
+            for (const filter of this.builders) {
+                const filters = filter.getFilters();
+                if (filters.every(f => {
+                    try {
+                        return f.match(shape);
+                    }
+                    catch (e) {
+                        console.error('Error applying filter:', e, f);
+                        return false;
+                    }
+                })) {
+                    if (!result.includes(shape)) {
+                        result.push(shape);
+                    }
+                }
+            }
+        }
+        return result;
+    }
+}

package/lib/dist/filters/index.d.ts

@@ -0,0 +1,4 @@
+import { FaceFilterBuilder } from './face/face-filter.js';
+import { EdgeFilterBuilder } from './edge/edge-filter.js';
+export declare function face(): FaceFilterBuilder;
+export declare function edge(): EdgeFilterBuilder;

package/lib/dist/filters/index.js

@@ -0,0 +1,8 @@
+import { FaceFilterBuilder } from './face/face-filter.js';
+import { EdgeFilterBuilder } from './edge/edge-filter.js';
+export function face() {
+    return new FaceFilterBuilder();
+}
+export function edge() {
+    return new EdgeFilterBuilder();
+}

package/lib/dist/filters/near-point-filter.d.ts

@@ -0,0 +1,11 @@
+import { Matrix4 } from "../math/matrix4.js";
+import { Point } from "../math/point.js";
+import { Shape } from "../common/shapes.js";
+import { FilterBase } from "./filter-base.js";
+export declare class NearPointFilter extends FilterBase<Shape> {
+    private point;
+    constructor(point: Point);
+    match(shape: Shape): boolean;
+    compareTo(other: NearPointFilter): boolean;
+    transform(matrix: Matrix4): NearPointFilter;
+}

package/lib/dist/filters/near-point-filter.js

@@ -0,0 +1,33 @@
+import { FilterBase } from "./filter-base.js";
+import { getOC } from "../oc/init.js";
+const NEAR_POINT_TOLERANCE = 0.5;
+export class NearPointFilter extends FilterBase {
+    point;
+    constructor(point) {
+        super();
+        this.point = point;
+    }
+    match(shape) {
+        const oc = getOC();
+        const gpPnt = new oc.gp_Pnt(this.point.x, this.point.y, this.point.z);
+        const vertexMaker = new oc.BRepBuilderAPI_MakeVertex(gpPnt);
+        const vertexShape = vertexMaker.Shape();
+        gpPnt.delete();
+        const progress = new oc.Message_ProgressRange();
+        const distCalc = new oc.BRepExtrema_DistShapeShape(vertexShape, shape.getShape(), oc.Extrema_ExtFlag.Extrema_ExtFlag_MIN, oc.Extrema_ExtAlgo.Extrema_ExtAlgo_Grad, progress);
+        let result = false;
+        if (distCalc.IsDone()) {
+            result = distCalc.Value() < NEAR_POINT_TOLERANCE;
+        }
+        distCalc.delete();
+        progress.delete();
+        vertexMaker.delete();
+        return result;
+    }
+    compareTo(other) {
+        return this.point.equals(other.point, 1e-6);
+    }
+    transform(matrix) {
+        return new NearPointFilter(this.point.transform(matrix));
+    }
+}

package/lib/dist/helpers/clone-transform.d.ts

@@ -0,0 +1,3 @@
+import { Matrix4 } from "../math/matrix4.js";
+import { SceneObject } from "../common/scene-object.js";
+export declare function cloneWithTransform(objects: SceneObject[], transform: Matrix4, container: SceneObject): SceneObject[];

package/lib/dist/helpers/clone-transform.js

@@ -0,0 +1,46 @@
+export function cloneWithTransform(objects, transform, container) {
+    const visited = new Set();
+    const ordered = [];
+    const collectDeps = (obj) => {
+        if (visited.has(obj)) {
+            return;
+        }
+        visited.add(obj);
+        for (const dep of obj.getDependencies()) {
+            collectDeps(dep);
+        }
+        ordered.push(obj);
+        // Collect children without following their dependencies —
+        // cloned children will reference originals for any deps not in the clone set
+        collectChildren(obj);
+    };
+    const collectChildren = (obj) => {
+        for (const child of obj.getChildren()) {
+            if (visited.has(child)) {
+                continue;
+            }
+            visited.add(child);
+            ordered.push(child);
+            collectChildren(child);
+        }
+    };
+    for (const obj of objects) {
+        collectDeps(obj);
+    }
+    const remap = new Map();
+    const allCloned = [];
+    for (const obj of ordered) {
+        const copy = obj.createCopy(remap);
+        remap.set(obj, copy);
+        copy.setTransform(transform);
+        allCloned.push(copy);
+        const parent = obj.getParent();
+        if (parent && remap.has(parent)) {
+            remap.get(parent).addChildObject(copy);
+        }
+        else if (!copy.parentId) {
+            container.addChildObject(copy);
+        }
+    }
+    return allCloned;
+}

package/lib/dist/helpers/cut-helpers.d.ts

@@ -0,0 +1,13 @@
+import { SceneObject } from "../common/scene-object.js";
+import { Shape } from "../common/shape.js";
+import { Plane } from "../math/plane.js";
+/**
+ * Classifies edges and faces from cleaned result shapes by comparing with
+ * original stock shapes. Edges/faces not present in stock are "section" geometry
+ * created by the cut. Section edges are further classified by signed distance
+ * from the cut plane into start, end, and internal groups.
+ *
+ * Sets state keys on target: section-edges, start-edges, end-edges,
+ * internal-edges, internal-faces
+ */
+export declare function classifyCutResult(target: SceneObject, stockShapes: Shape[], cleanedShapes: Shape[], plane: Plane, cutDistance: number): void;

package/lib/dist/helpers/cut-helpers.js

@@ -0,0 +1,79 @@
+import { Explorer } from "../oc/explorer.js";
+import { EdgeOps } from "../oc/edge-ops.js";
+/**
+ * Classifies edges and faces from cleaned result shapes by comparing with
+ * original stock shapes. Edges/faces not present in stock are "section" geometry
+ * created by the cut. Section edges are further classified by signed distance
+ * from the cut plane into start, end, and internal groups.
+ *
+ * Sets state keys on target: section-edges, start-edges, end-edges,
+ * internal-edges, internal-faces
+ */
+export function classifyCutResult(target, stockShapes, cleanedShapes, plane, cutDistance) {
+    // Collect stock edge midpoints for geometric comparison
+    const stockEdgeMidpoints = [];
+    for (const stock of stockShapes) {
+        const edges = Explorer.findEdgesWrapped(stock);
+        for (const edge of edges) {
+            stockEdgeMidpoints.push(EdgeOps.getEdgeMidPoint(edge));
+        }
+    }
+    const tolerance = 1e-6;
+    const isStockEdge = (edge) => {
+        const mid = EdgeOps.getEdgeMidPoint(edge);
+        return stockEdgeMidpoints.some(sm => Math.abs(mid.x - sm.x) < tolerance &&
+            Math.abs(mid.y - sm.y) < tolerance &&
+            Math.abs(mid.z - sm.z) < tolerance);
+    };
+    // Find section edges from cleaned result (edges not in stock)
+    const sectionEdges = [];
+    for (const shape of cleanedShapes) {
+        const edges = Explorer.findEdgesWrapped(shape);
+        for (const edge of edges) {
+            if (!isStockEdge(edge)) {
+                sectionEdges.push(edge);
+            }
+        }
+    }
+    // Internal faces: faces where ALL edges are section edges (not from stock).
+    const internalFaces = [];
+    for (const shape of cleanedShapes) {
+        const faces = Explorer.findFacesWrapped(shape);
+        for (const f of faces) {
+            const faceEdges = f.getEdges();
+            if (faceEdges.length > 0 && faceEdges.every(e => !isStockEdge(e))) {
+                internalFaces.push(f);
+            }
+        }
+    }
+    // Classify section edges by signed distance from cut plane
+    const startEdges = [];
+    const endEdges = [];
+    const internalEdges = [];
+    if (plane && sectionEdges.length > 0) {
+        const isThroughAll = cutDistance === 0;
+        const dists = sectionEdges.map(edge => ({
+            edge,
+            d: plane.signedDistanceToPoint(EdgeOps.getEdgeMidPoint(edge))
+        }));
+        const startDist = isThroughAll ? Math.max(...dists.map(e => e.d)) : 0;
+        const endDist = isThroughAll ? Math.min(...dists.map(e => e.d)) : -cutDistance;
+        const distTolerance = 1e-4;
+        for (const { edge, d } of dists) {
+            if (Math.abs(d - startDist) < distTolerance) {
+                startEdges.push(edge);
+            }
+            else if (Math.abs(d - endDist) < distTolerance) {
+                endEdges.push(edge);
+            }
+            else {
+                internalEdges.push(edge);
+            }
+        }
+    }
+    target.setState('section-edges', sectionEdges);
+    target.setState('start-edges', startEdges);
+    target.setState('end-edges', endEdges);
+    target.setState('internal-edges', internalEdges);
+    target.setState('internal-faces', internalFaces);
+}

package/lib/dist/helpers/math-helpers.d.ts

@@ -0,0 +1,2 @@
+export declare function degree(rad: number): number;
+export declare function rad(deg: number): number;

package/lib/dist/helpers/math-helpers.js

@@ -0,0 +1,6 @@
+export function degree(rad) {
+    return rad * (180 / Math.PI);
+}
+export function rad(deg) {
+    return deg * (Math.PI / 180);
+}

package/lib/dist/helpers/normalize.d.ts

@@ -0,0 +1,12 @@
+import { AxisLike } from "../math/axis.js";
+import { Plane, PlaneLike } from "../math/plane.js";
+import { Point2DLike, PointLike } from "../math/point.js";
+import { Vector3d, Vector3dLike } from "../math/vector3d.js";
+import { LazyVertex } from "../features/lazy-vertex.js";
+export declare function normalizePoint(p: PointLike): LazyVertex;
+export declare function normalizePoint2DSafe(p: Point2DLike): LazyVertex;
+export declare function normalizePoint2D(p: Point2DLike): LazyVertex;
+export declare function normalizeVector(v: Vector3dLike): Vector3d;
+export declare function normalizePlane(arg: PlaneLike): Plane;
+export declare function normalizeAxisSafe(a: AxisLike): import("../math/axis.js").Axis;
+export declare function normalizeAxis(a: AxisLike): import("../math/axis.js").Axis;

package/lib/dist/helpers/normalize.js

@@ -0,0 +1,118 @@
+import { CoordinateSystem } from "../math/coordinate-system.js";
+import { Plane } from "../math/plane.js";
+import { Point, Point2D } from "../math/point.js";
+import { Vector3d } from "../math/vector3d.js";
+import { Vertex } from "../common/shapes.js";
+import { LazyVertex } from "../features/lazy-vertex.js";
+export function normalizePoint(p) {
+    if (p instanceof LazyVertex) {
+        return p;
+    }
+    let point;
+    if (p instanceof Point) {
+        point = p;
+    }
+    if (Array.isArray(p)) {
+        point = new Point(p[0], p[1], p[2]);
+    }
+    else if (typeof p === 'object' && 'x' in p && 'y' in p && 'z' in p) {
+        point = new Point(p.x, p.y, p.z);
+    }
+    if (!point) {
+        throw new Error("Failed to normalize point");
+    }
+    return LazyVertex.fromVertex(Vertex.fromPoint(point));
+}
+export function normalizePoint2DSafe(p) {
+    try {
+        return normalizePoint2D(p);
+    }
+    catch (e) {
+        console.error("Failed to normalize point2D:", e);
+        return null;
+    }
+}
+export function normalizePoint2D(p) {
+    let point2D;
+    if (p instanceof LazyVertex) {
+        return p;
+    }
+    else if (p instanceof Point2D) {
+        point2D = p;
+    }
+    else if (Array.isArray(p)) {
+        point2D = new Point2D(p[0], p[1]);
+    }
+    else if (typeof p === 'object' && 'x' in p && 'y' in p) {
+        point2D = new Point2D(p.x, p.y);
+    }
+    else {
+        throw new Error("Invalid point2D format");
+    }
+    return new LazyVertex(`point2D-${point2D.x}-${point2D.y}`, () => [Vertex.fromPoint2D(point2D)]);
+}
+export function normalizeVector(v) {
+    if (v instanceof Vector3d) {
+        return v;
+    }
+    if (Array.isArray(v)) {
+        return new Vector3d(v[0], v[1], v[2]);
+    }
+    else if (typeof v === 'object' && 'x' in v && 'y' in v && 'z' in v) {
+        return new Vector3d(v.x, v.y, v.z);
+    }
+    else {
+        throw new Error("Invalid vector format");
+    }
+}
+export function normalizePlane(arg) {
+    if (typeof (arg) === 'string') {
+        const world = CoordinateSystem.World();
+        if (arg === 'xy' || arg === 'top') {
+            return world.getXYPlane();
+        }
+        else if (arg === '-xy' || arg === 'bottom') {
+            return world.getXYPlane().reverse();
+        }
+        else if (arg === 'xz' || arg === 'front') {
+            return world.getXZPlane();
+        }
+        else if (arg === '-xz' || arg === 'back') {
+            return world.getXZPlane().reverse();
+        }
+        else if (arg === 'yz' || arg === 'right') {
+            return world.getYZPlane();
+        }
+        else if (arg === '-yz' || arg === 'left') {
+            return world.getYZPlane().reverse();
+        }
+    }
+    else if (arg instanceof Plane) {
+        return arg;
+    }
+    throw new Error("Invalid plane format");
+}
+export function normalizeAxisSafe(a) {
+    try {
+        return normalizeAxis(a);
+    }
+    catch (e) {
+        console.error("Failed to normalize axis:", e);
+        return null;
+    }
+}
+export function normalizeAxis(a) {
+    const world = CoordinateSystem.World();
+    if (typeof a === 'string') {
+        if (a === 'x') {
+            return world.xAxis;
+        }
+        else if (a === 'y') {
+            return world.yAxis;
+        }
+        else if (a === 'z') {
+            return world.mainAxis;
+        }
+    }
+    throw new Error("Invalid axis format");
+}

package/lib/dist/helpers/resolve-filters.d.ts

@@ -0,0 +1,6 @@
+import { Shape } from "../common/shape.js";
+import { EdgeFilterBuilder } from "../filters/edge/edge-filter.js";
+import { FaceFilterBuilder } from "../filters/face/face-filter.js";
+import { FilterBuilderBase } from "../filters/filter-builder-base.js";
+export declare function resolveEdgeFilters(args: (number | EdgeFilterBuilder)[], defaultBuilder?: EdgeFilterBuilder): FilterBuilderBase<Shape>[];
+export declare function resolveFaceFilters(args: (number | FaceFilterBuilder)[], defaultBuilder?: FaceFilterBuilder): FilterBuilderBase<Shape>[];

package/lib/dist/helpers/resolve-filters.js

@@ -0,0 +1,25 @@
+import { EdgeFilterBuilder } from "../filters/edge/edge-filter.js";
+import { FaceFilterBuilder } from "../filters/face/face-filter.js";
+import { FilterBuilderBase } from "../filters/filter-builder-base.js";
+export function resolveEdgeFilters(args, defaultBuilder) {
+    if (args.length === 0) {
+        return defaultBuilder ? [defaultBuilder] : [];
+    }
+    if (args.every(a => typeof a === 'number')) {
+        const indices = args;
+        const builder = defaultBuilder ?? new EdgeFilterBuilder();
+        return [builder.at(...indices)];
+    }
+    return args;
+}
+export function resolveFaceFilters(args, defaultBuilder) {
+    if (args.length === 0) {
+        return defaultBuilder ? [defaultBuilder] : [];
+    }
+    if (args.every(a => typeof a === 'number')) {
+        const indices = args;
+        const builder = defaultBuilder ?? new FaceFilterBuilder();
+        return [builder.at(...indices)];
+    }
+    return args.filter(a => a instanceof FilterBuilderBase);
+}

package/lib/dist/helpers/resolve.d.ts

@@ -0,0 +1,8 @@
+import { PlaneObjectBase } from "../features/plane-renderable-base.js";
+import { SceneParserContext } from "../index.js";
+import { PlaneLike } from "../math/plane.js";
+import { AxisObjectBase } from "../features/axis-renderable-base.js";
+import { AxisLike } from "../math/axis.js";
+import { ISceneObject } from "../core/interfaces.js";
+export declare function resolvePlane(p: PlaneLike | ISceneObject, context: SceneParserContext): PlaneObjectBase;
+export declare function resolveAxis(arg: AxisLike | ISceneObject, context: SceneParserContext): AxisObjectBase;

package/lib/dist/helpers/resolve.js

@@ -0,0 +1,45 @@
+import { SceneObject } from "../common/scene-object.js";
+import { PlaneFromObject } from "../features/plane-from-object.js";
+import { PlaneObjectBase } from "../features/plane-renderable-base.js";
+import { PlaneObject } from "../features/plane.js";
+import { normalizeAxis, normalizePlane } from "./normalize.js";
+import { isPlaneLike } from "../math/plane.js";
+import { AxisObjectBase } from "../features/axis-renderable-base.js";
+import { isAxisLike } from "../math/axis.js";
+import { AxisObject } from "../features/axis.js";
+import { AxisFromEdge } from "../features/axis-from-edge.js";
+export function resolvePlane(p, context) {
+    if (p instanceof PlaneObjectBase) {
+        return p;
+    }
+    if (isPlaneLike(p)) {
+        const planeObj = new PlaneObject(normalizePlane(p));
+        context.addSceneObject(planeObj);
+        return planeObj;
+    }
+    if (p instanceof SceneObject) {
+        context.addSceneObject(p);
+        const planeObj = new PlaneFromObject(p);
+        context.addSceneObject(planeObj);
+        return planeObj;
+    }
+    throw new Error('Invalid argument: expected a plane or a scene object');
+}
+export function resolveAxis(arg, context) {
+    if (arg instanceof AxisObjectBase) {
+        return arg;
+    }
+    if (arg instanceof SceneObject) {
+        context.addSceneObject(arg);
+        const axis = new AxisFromEdge(arg);
+        context.addSceneObject(axis);
+        return axis;
+    }
+    if (isAxisLike(arg)) {
+        const a = normalizeAxis(arg);
+        const axis = new AxisObject(a);
+        context.addSceneObject(axis);
+        return axis;
+    }
+    throw new Error('Invalid argument: expected an axis or a scene object');
+}

package/lib/dist/helpers/scene-helpers.d.ts

@@ -0,0 +1,17 @@
+import { SceneObject } from "../common/scene-object.js";
+import { Shape } from "../common/shapes.js";
+import { Plane } from "../math/plane.js";
+export declare function fuseWithSceneObjects(sceneObjects: SceneObject[], extrusions: Shape<any>[]): {
+    newShapes: Shape<any>[];
+    modifiedShapes: any[];
+} | {
+    newShapes: Shape<import("occjs-wrapper").TopoDS_Shape>[];
+    modifiedShapes: {
+        shape: Shape<any>;
+        object: SceneObject;
+    }[];
+};
+export declare function cutWithSceneObjects(sceneObjects: SceneObject[], toolShapes: Shape[], plane: Plane, distance: number, caller: SceneObject): {
+    cleanedShapes: Shape[];
+    stockShapes: Shape[];
+};

package/lib/dist/helpers/scene-helpers.js

@@ -0,0 +1,67 @@
+import { BooleanOps } from "../oc/boolean-ops.js";
+import { ShapeOps } from "../oc/shape-ops.js";
+import { classifyCutResult } from "./cut-helpers.js";
+export function fuseWithSceneObjects(sceneObjects, extrusions) {
+    const modified = [];
+    const objShapeMap = new Map();
+    for (const obj of sceneObjects) {
+        const shapes = obj.getShapes({}, 'solid');
+        for (const shape of shapes) {
+            objShapeMap.set(shape, obj);
+        }
+    }
+    let sceneShapes = Array.from(objShapeMap.keys());
+    console.log("Fusing extrusions with scene objects. Extrusions:", extrusions.length, "Scene object shapes:", sceneShapes.length);
+    const all = [...sceneShapes, ...extrusions];
+    const { result, newShapes, modifiedShapes } = BooleanOps.fuse(all);
+    if (newShapes.length === 0 && modifiedShapes.length === 0) {
+        console.log("No fusions were made.");
+        return {
+            newShapes: extrusions,
+            modifiedShapes: []
+        };
+    }
+    for (const shape of modifiedShapes) {
+        const obj = objShapeMap.get(shape);
+        modified.push({ shape, object: obj });
+    }
+    // Include all result shapes EXCEPT partners of scene object shapes
+    // that survived the fuse (weren't consumed). Unconsumed scene shapes
+    // stay on their original owners so we must not duplicate them.
+    const unconsumed = sceneShapes.filter(s => !modifiedShapes.includes(s));
+    const shapesToAdd = result.filter(s => !unconsumed.some(u => u.getShape().IsPartner(s.getShape())));
+    return { newShapes: shapesToAdd, modifiedShapes: modified };
+}
+export function cutWithSceneObjects(sceneObjects, toolShapes, plane, distance, caller) {
+    const sceneObjectMap = new Map();
+    for (const obj of sceneObjects) {
+        const shapes = obj.getShapes({}, 'solid');
+        if (shapes.length === 0) {
+            continue;
+        }
+        sceneObjectMap.set(obj, shapes);
+    }
+    const shapeObjectMap = new Map();
+    for (const [obj, shapes] of sceneObjectMap) {
+        for (const shape of shapes) {
+            shapeObjectMap.set(shape, obj);
+        }
+    }
+    const stock = Array.from(shapeObjectMap.keys());
+    const cutResult = BooleanOps.cutMultiShape(stock, toolShapes, plane, distance);
+    const cleanedShapes = [];
+    for (const shape of stock) {
+        const list = cutResult.modified(shape);
+        if (list.length) {
+            for (const newShape of list) {
+                const s = ShapeOps.cleanShape(newShape);
+                caller.addShape(s);
+                cleanedShapes.push(s);
+            }
+            const obj = shapeObjectMap.get(shape);
+            obj.removeShape(shape, caller);
+        }
+    }
+    classifyCutResult(caller, stock, cleanedShapes, plane, distance);
+    return { cleanedShapes, stockShapes: stock };
+}

package/lib/dist/helpers/types.d.ts

@@ -0,0 +1,27 @@
+import { Edge } from "../common/edge.js";
+import { Face } from "../common/face.js";
+import { SceneObject } from "../common/scene-object.js";
+import { Wire } from "../common/wire.js";
+import { GeometrySceneObject } from "../features/2d/geometry.js";
+import { Plane } from "../math/plane.js";
+export type BoundingBox = {
+    minX: number;
+    minY: number;
+    minZ: number;
+    maxX: number;
+    maxY: number;
+    maxZ: number;
+    [key: string]: any;
+};
+export type FaceInfo = {
+    face: Face;
+    wire: Wire;
+    bbox: BoundingBox;
+    diagonal: number;
+    holes?: FaceInfo[];
+};
+export interface Extrudable extends SceneObject {
+    getGeometries(): Edge[];
+    getGeometriesWithOwner(): Map<Edge, GeometrySceneObject>;
+    getPlane(): Plane;
+}

package/lib/dist/helpers/types.js

@@ -0,0 +1 @@
+export {};

package/lib/dist/index.d.ts

@@ -0,0 +1,37 @@
+import { Scene } from "./rendering/scene.js";
+import { SceneObject, SourceLocation } from "./common/scene-object.js";
+import { SelectSceneObject } from "./features/select.js";
+import { Sketch } from "./features/2d/sketch.js";
+import { Extrudable } from "./helpers/types.js";
+export declare function captureSourceLocation(): SourceLocation | null;
+export type SceneParserContext = {
+    addSceneObject(obj: SceneObject): void;
+    addSceneObjects(objs: SceneObject[]): void;
+    getLastExtrudable(): Extrudable | null;
+    getLastSelection(): SelectSceneObject | null;
+    getLastSelections(): SelectSceneObject[] | null;
+    startProgressiveContainer(obj: SceneObject): void;
+    endProgressiveContainer(): void;
+    getSceneObjects(): SceneObject[];
+    getActiveSketch(): Sketch | null;
+};
+export declare function registerBuilder<T extends Function>(builder: (context: SceneParserContext) => T): T;
+export declare function init(rootPath?: string): Promise<{
+    currentScene: Scene;
+    currentFile: string;
+    rootPath: string;
+    setCurrentFile(filePath: string): void;
+    startScene(): Scene;
+    renderScene(scene: Scene): Scene;
+    rollbackScene(scene: Scene, rollbackIndex: number): Scene;
+    compare(previous: Scene, current: Scene): Scene;
+    importFile(workspacePath: string, fileName: string, data: Uint8Array): void;
+    getShapeProperties(scene: Scene, shapeId: string): import("./oc/props.js").ShapeProperties | null;
+    getFaceProperties(scene: Scene, shapeId: string, faceIndex: number): import("./oc/face-props.js").FaceProperties | null;
+    getEdgeProperties(scene: Scene, shapeId: string, edgeIndex: number): import("./oc/edge-props.js").EdgeProperties | null;
+    exportShapes(scene: Scene, shapeIds: string[], options: import("./io/file-export.js").ExportOptions): {
+        data: string | Uint8Array;
+        fileName: string;
+    };
+    hitTest(scene: Scene, shapeId: string, rayOrigin: [number, number, number], rayDir: [number, number, number], edgeThreshold: number): import("./oc/hit-test.js").HitTestResult;
+}>;