opengeometry 2.0.14 → 2.0.16

package/src/operations/boolean-regions.d.ts

@@ -0,0 +1,20 @@
+import type { OffsetRegion } from "./offset-regions.js";
+export type PlanarBooleanOperation = "union" | "intersection" | "subtraction";
+export type CurvedRegionEdge = {
+    kind: "line";
+    from: [number, number];
+    to: [number, number];
+} | {
+    kind: "arc";
+    center: [number, number];
+    radius: number;
+    start_angle: number;
+    sweep_angle: number;
+};
+export interface CurvedRegion2D {
+    outer: CurvedRegionEdge[];
+    holes: CurvedRegionEdge[][];
+}
+export declare function booleanRegions2D(a: readonly OffsetRegion[], b: readonly OffsetRegion[], operation: PlanarBooleanOperation): OffsetRegion[];
+/** Analytic line/arc region Boolean; output arcs retain their exact circles. */
+export declare function booleanCurvedRegions2D(a: readonly CurvedRegion2D[], b: readonly CurvedRegion2D[], operation: PlanarBooleanOperation): CurvedRegion2D[];

package/src/operations/index.d.ts

@@ -2,6 +2,7 @@
  * Kernel-backed boolean helpers and renderable result mesh.
  */
 export * from "./boolean.js";
+export * from "./boolean-regions.js";
 export * from "./analytic-errors.js";
 export * from "./extrude.js";
 export * from "./loft.js";

package/src/operations/offset-regions.d.ts

@@ -17,7 +17,7 @@ export interface OffsetRegion {
  * trims, and nonzero-winding resolution of reflex / closed loops. NO boolean union
  * (so it is deterministic, unlike the 3D-mesh CSG path). A simple centreline returns
  * one region; a self-crossing closed centreline (e.g. a figure-8) returns one per
- * simple sub-loop. Returns an EMPTY array for a genuinely unbuildable input (does
+ * simple sub-loop. Returns an EMPTY array for a collapsed input (does
  * not throw, so it never looks like a kernel crash). Rings are CW-outer / CCW-holes.
  *
  * @param centrelineFlat centreline points as `[x,y,z, …]`.
@@ -25,9 +25,8 @@ export interface OffsetRegion {
  * @param miterLimit SVG stroke-miterlimit; corners sharper than this bevel. Default 4.
  */
 export declare function offsetPolylineRegions(centrelineFlat: number[] | Float64Array, width: number, closed: boolean, miterLimit?: number): OffsetRegion[];
-/** An excluded interior ring of a variable inset (an easement island, a
- *  protected tree pit): its closed ring `[x,y,z, …]` plus one clearance
- *  distance per hole edge. The inset GROWS the hole by its distances. */
+/** An excluded interior ring of a variable inset. Its closed ring has one
+ * clearance distance per edge; the inset grows the hole by those distances. */
 export interface OffsetHole {
     ring: number[] | Float64Array;
     distances: number[] | Float64Array;
@@ -35,17 +34,17 @@ export interface OffsetHole {
 /**
  * Inset a CLOSED ring inward with one distance per edge (edge i =
  * `ring[i] → ring[i+1]`; an explicit closing duplicate point is accepted and
- * stripped, the distance count stays one per unique edge). Built for setback
- * envelopes: the result is the CLEARANCE-EXACT buildable region — the ring's
- * interior minus every point within `distances[i]` of edge i's SEGMENT, so
- * distant lot lines are honoured across notches and corners where distances
- * differ become circumscribed clearance arcs (conservative). There is no
+ * stripped, the distance count stays one per unique edge). The result is a
+ * clearance-exact inset region: the ring's interior minus every point within
+ * `distances[i]` of edge i's segment. Distant boundary segments remain
+ * effective across notches; different distances produce circumscribed
+ * clearance arcs. There is no
  * `miterLimit` parameter, deliberately: miters and bevels only approximate the
  * clearance arc, and a bevel would claim points inside the required distance.
  *
  * `holes` are excluded interior rings, each grown outward by its own per-edge
  * distances — the region keeps clear of a hole's edges exactly as it keeps
- * clear of the lot lines, so a hole can split the region or swallow it.
+ * clear of the outer boundary, so a hole can split the region or swallow it.
  *
  * Returns CW-outer / CCW-hole regions (canonical start vertex), possibly
  * SEVERAL when a deep inset (or a hole) splits a waisted ring into disjoint
@@ -57,7 +56,7 @@ export interface OffsetHole {
  *
  * @param ring closed ring points as `[x,y,z, …]` (Y is carried through).
  * @param distances inward inset distance per edge, metres, each >= 0
- *                  (0 = the edge stays in place, e.g. lot-line construction).
+ *                  (0 keeps that boundary edge in place).
  * @param holes excluded interior rings with their own per-edge distances.
  */
 export declare function offsetRingVariable(ring: number[] | Float64Array, distances: number[] | Float64Array, holes?: OffsetHole[]): OffsetRegion[];
@@ -71,7 +70,7 @@ export interface OffsetPolyline {
  * Merge a GROUP of separate polylines (a crossing T / X / L overlap) into one clean
  * region by nonzero-winding union of their mitered bands — the overlapping strokes
  * merge into a single region with mitered/bevelled corners, no internal edges.
- * Returns CW-outer / CCW-hole regions (one or more); empty if nothing is buildable.
+ * Returns CW-outer / CCW-hole regions (one or more); empty if no region remains.
  * No CSG. Used to render/extrude an overlapping crossing as one joined mass.
  */
 export declare function offsetPolylineGroupRegions(polylines: OffsetPolyline[]): OffsetRegion[];

package/src/shapes/analytic-solid.d.ts

@@ -13,13 +13,24 @@ export interface AnalyticAccuracy {
     tessellation: number;
     exchange: number;
 }
-export interface AnalyticCircularWallOpening {
+export interface AnalyticAnnularSectorOpening {
     id: string;
     angle: number;
     width: number;
     bottom: number;
     height: number;
 }
+export type AnalyticProfileEdge = {
+    kind: "line";
+    from: [number, number];
+    to: [number, number];
+} | {
+    kind: "arc";
+    center: [number, number];
+    radius: number;
+    startAngle: number;
+    sweepAngle: number;
+};
 export type AnalyticPolygonLoftAlignment = "auto" | {
     upperStartIndex: number;
     reverseUpper?: boolean;
@@ -63,13 +74,18 @@ export type AnalyticPrimitiveOptions = AnalyticOptions & ({
     outer: [number, number][];
     holes: [number, number][][];
     height: number;
+} | {
+    kind: "arcEdgedExtrusion";
+    outer: AnalyticProfileEdge[];
+    holes?: AnalyticProfileEdge[][];
+    height: number;
 } | {
     kind: "polygonLoft";
     lower: [number, number, number][];
     upper: [number, number, number][];
     alignment?: AnalyticPolygonLoftAlignment;
 } | {
-    kind: "straightWallWithArchedOpening";
+    kind: "boxWithArchedOpening";
     width: number;
     depth: number;
     height: number;
@@ -107,28 +123,28 @@ export type AnalyticPrimitiveOptions = AnalyticOptions & ({
     majorRadius: number;
     minorRadius: number;
 } | {
-    kind: "circularWall";
+    kind: "annularSectorExtrusion";
     radius: number;
     thickness: number;
     height: number;
     startAngle: number;
     sweepAngle: number;
 } | {
-    kind: "circularWallWithOpenings";
+    kind: "annularSectorExtrusionWithOpenings";
     radius: number;
     thickness: number;
     height: number;
     startAngle: number;
     sweepAngle: number;
-    openings: AnalyticCircularWallOpening[];
+    openings: AnalyticAnnularSectorOpening[];
 } | {
-    kind: "circularWallWithArchedOpening";
+    kind: "annularSectorExtrusionWithArchedOpening";
     radius: number;
     thickness: number;
     height: number;
     startAngle: number;
     sweepAngle: number;
-    opening: AnalyticCircularWallOpening;
+    opening: AnalyticAnnularSectorOpening;
 } | {
     kind: "coaxialCircleLoft";
     lowerRadius: number;

package/src/world/world-graph.d.ts

@@ -0,0 +1,112 @@
+import * as THREE from "three";
+import type { AnalyticFrame, AnalyticProjectionCamera, AnalyticProjectionHlr, AnalyticSolid } from "../shapes/analytic-solid.js";
+export interface WorldTransform {
+    frame: AnalyticFrame;
+    scale: number;
+}
+export interface WorldNodeOptions {
+    id: string;
+    parent?: string;
+    definition?: string;
+    local?: THREE.Matrix4;
+    kind?: string;
+}
+export interface WorldProjectedLine {
+    start: {
+        x: number;
+        y: number;
+    };
+    end: {
+        x: number;
+        y: number;
+    };
+    stroke_width: number | null;
+    stroke_color: [number, number, number] | null;
+    class?: string;
+}
+export interface WorldProjectedLines {
+    name: string | null;
+    lines: WorldProjectedLine[];
+}
+export interface WorldProjectedSegment {
+    geometry: unknown;
+    class: string;
+    layer?: string | null;
+    source_entity_id?: string | null;
+}
+export interface WorldProjectedScene {
+    name: string | null;
+    segments: WorldProjectedSegment[];
+}
+export interface WorldProjectionView {
+    id: string;
+    camera: AnalyticProjectionCamera;
+    hlr?: AnalyticProjectionHlr;
+}
+export interface WorldExportedMesh {
+    bytes: Uint8Array;
+    report: unknown;
+}
+export interface WorldExportedFile {
+    text: string;
+    report: unknown;
+}
+export type WorldClashKind = "hard" | "touch" | "unresolved";
+export interface WorldClash {
+    a: string;
+    b: string;
+    kind: WorldClashKind;
+    parts: [string, string];
+    detail?: string;
+}
+export interface WorldClashOptions {
+    depth?: number;
+}
+export interface WorldProximity {
+    a: string;
+    b: string;
+    distance: number;
+    errorBound: number;
+    parts: [string, string];
+    points: [[number, number, number], [number, number, number]];
+}
+export type WorldGraphErrorCode = "duplicate_node" | "unknown_node" | "duplicate_definition" | "unknown_definition" | "definition_in_use" | "cycle" | "invalid_input" | "export" | "geometry" | "unknown";
+export declare class WorldGraphError extends Error {
+    readonly code: WorldGraphErrorCode;
+    readonly detail: unknown;
+    constructor(code: WorldGraphErrorCode, message: string, detail?: unknown);
+}
+export declare function matrixToWorldTransform(matrix: THREE.Matrix4): WorldTransform;
+export declare class WorldGraph {
+    private readonly kernel;
+    private readonly bindings;
+    private bindingOrder;
+    private disposed;
+    get nodeCount(): number;
+    get definitionCount(): number;
+    define(id: string, solid: AnalyticSolid): void;
+    defineLegacy(id: string, brepSerialized: string): void;
+    hasDefinition(id: string): boolean;
+    undefine(id: string): void;
+    addNode(options: WorldNodeOptions): void;
+    hasNode(id: string): boolean;
+    setLocal(id: string, local: THREE.Matrix4): void;
+    reparent(id: string, parent?: string): void;
+    removeNode(id: string): void;
+    getWorldMatrix(id: string): THREE.Matrix4;
+    getWorldBounds(id: string): THREE.Box3 | null;
+    clash(itemsA: string[], itemsB: string[], options?: WorldClashOptions): WorldClash[];
+    clearance(itemsA: string[], itemsB: string[], clearance: number): WorldProximity[];
+    distance(itemA: string, itemB: string, tolerance?: number): WorldProximity | null;
+    projectLines(items: string[], camera: AnalyticProjectionCamera, hlr?: AnalyticProjectionHlr, deflection?: number): WorldProjectedLines;
+    projectViews(items: string[], views: WorldProjectionView[], deflection?: number): Record<string, WorldProjectedScene>;
+    exportStl(items: string[], config?: Record<string, unknown>): WorldExportedMesh;
+    exportStep(items: string[], config?: Record<string, unknown>): WorldExportedFile;
+    exportIfc(items: string[], config?: Record<string, unknown>): WorldExportedFile;
+    bind(object: THREE.Object3D, id: string): void;
+    unbind(id: string): void;
+    sync(): void;
+    dispose(): void;
+    private syncObject;
+    private checkActive;
+}

package/src/operations/boolean-errors.d.ts

@@ -1,90 +0,0 @@
-/**
- * Typed error hierarchy for boolean operations.
- *
- * The Rust kernel emits a structured `BooleanError` as JSON across the WASM
- * boundary (see `main/opengeometry/src/booleans/error.rs`). This module parses
- * that JSON and re-throws it as a typed `BooleanError` (or a more specific
- * subclass) so app code can `instanceof`-discriminate without parsing message
- * strings.
- *
- * Cutter indices are **0-based** to match `Vec` / array indexing on both
- * sides of the boundary.
- */
-import * as THREE from "three";
-export type BooleanErrorPhase = "input_validation" | "union_pre_pass" | "subtract_step" | "output_validation";
-export type BooleanErrorReason = "invalid_operand" | "malformed_input" | "mixed_operand_kinds" | "unsupported_operand_kind" | "non_coplanar_planar_operands" | "topology_error" | "kernel_failure" | "non_manifold_edges" | "open_shell" | "coincident_faces" | "degenerate_triangle" | "empty_result" | "overlapping_cutters" | "cutter_exceeds_host";
-interface KindPayload {
-    code: BooleanErrorReason;
-    other_index?: number;
-    axis?: string;
-    overshoot?: number;
-}
-interface BooleanErrorJson {
-    kind: KindPayload;
-    phase: BooleanErrorPhase;
-    cutter_index: number | null;
-    message: string;
-    details: string | null;
-    edge_samples: Array<[{
-        x: number;
-        y: number;
-        z: number;
-    }, {
-        x: number;
-        y: number;
-        z: number;
-    }]> | null;
-}
-/**
- * Base class for every typed boolean error. Carries the structured payload the
- * kernel emitted across WASM. Specialized subclasses (`OverlappingCuttersError`,
- * `CutterExceedsHostError`, `NonManifoldOutputError`, `CoincidentFacesError`)
- * narrow the payload for the variants that carry extra fields.
- */
-export declare class BooleanError extends Error {
-    readonly reason: BooleanErrorReason;
-    readonly phase: BooleanErrorPhase;
-    readonly cutterIndex: number | null;
-    readonly details: string | null;
-    readonly edgeSamples: ReadonlyArray<[THREE.Vector3, THREE.Vector3]> | null;
-    constructor(payload: BooleanErrorJson);
-}
-/**
- * Two cutters overlap each other. `otherIndex` is the 0-based index of the
- * cutter that conflicts with the one at `cutterIndex`.
- */
-export declare class OverlappingCuttersError extends BooleanError {
-    readonly otherIndex: number;
-    constructor(payload: BooleanErrorJson);
-}
-/**
- * A cutter extends past the host's hull along the named axis.
- */
-export declare class CutterExceedsHostError extends BooleanError {
-    readonly axis: "x" | "y" | "z";
-    readonly overshoot: number;
-    constructor(payload: BooleanErrorJson);
-}
-/**
- * Output mesh has open or over-shared edges after a boolean. `edgeSamples`
- * carries up to ~8 sample non-manifold edges to aid app-side debugging.
- */
-export declare class NonManifoldOutputError extends BooleanError {
-    constructor(payload: BooleanErrorJson);
-}
-/**
- * Cutter and host share a coplanar face. Distinct from
- * `DegenerateTriangleError` (zero-area input) — see `06a-snap-tolerance.md`.
- */
-export declare class CoincidentFacesError extends BooleanError {
-    constructor(payload: BooleanErrorJson);
-}
-/**
- * Parses a WASM-thrown error and returns the appropriate typed `BooleanError`
- * subclass. If the error's message is not valid `BooleanError` JSON, returns a
- * fallback `BooleanError` with `reason: "kernel_failure"` carrying the original
- * string, so callers always get a typed error and never have to `try/catch`
- * twice.
- */
-export declare function parseBooleanError(raw: unknown): BooleanError;
-export {};

package/src/shapes/boolean-subtract.d.ts

@@ -1,21 +0,0 @@
-import type { BooleanExecutionOptions, BooleanOperand, BooleanResult } from "../operations/boolean.js";
-/**
- * Operand types accepted by shape instance `.subtract(...)` helpers.
- */
-export type ShapeSubtractOperand = BooleanOperand;
-/**
- * Array-only operand list accepted by shape instance `.subtract(...)` helpers.
- */
-export type ShapeSubtractOperands = ShapeSubtractOperand[];
-/**
- * Options accepted by shape instance `.subtract(...)` helpers.
- */
-export type ShapeSubtractOptions = BooleanExecutionOptions;
-/**
- * Return type for shape instance `.subtract(...)` helpers.
- */
-export type ShapeSubtractResult = BooleanResult;
-/**
- * Executes a kernel-backed subtraction for a shape wrapper against another boolean operand.
- */
-export declare function subtractShapeOperand(host: ShapeSubtractOperand, operands: ShapeSubtractOperands, options?: ShapeSubtractOptions): ShapeSubtractResult;