opengeometry 2.0.14 → 2.0.15

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "opengeometry",
-  "version": "2.0.14",
-  "description": "CAD kernel for the web built with Rust, WebAssembly, and Three.js for browser CAD, AEC/BIM, and geometry-heavy tools.",
+  "version": "2.0.15",
+  "description": "CAD geometry kernel for the web built with Rust, WebAssembly, and Three.js.",
   "author": "Vishwajeet Vinayak Mane",
   "license": "MPL-2.0",
   "type": "module",
@@ -32,8 +32,6 @@
     "geometry",
     "webassembly",
     "wasm",
-    "aec",
-    "bim",
     "ifc",
     "step",
     "stl",

package/src/examples/index.d.ts

@@ -6,6 +6,6 @@ export * from './shapes.js';
 export * from './sweep.js';
 export * from './offset.js';
 export * from './offset-ring-variable.js';
-export * from './wall-from-offsets.js';
+export * from './ribbon-from-offsets.js';
 export * from './booleans.js';
 export * from './editor-modes.js';

package/src/examples/{wall-from-offsets.d.ts → ribbon-from-offsets.d.ts}

@@ -2,13 +2,13 @@ import * as THREE from "three";
 import { Polyline } from "../primitives/polyline.js";
 import { AnalyticSolid } from "../shapes/analytic-solid.js";
 import { Polygon } from "../shapes/polygon.js";
-export interface WallFromOffsetsOptions {
+export interface RibbonFromOffsetsOptions {
     /** Subtract one exact coextensive through slot. Default `false`. */
     cutThroughSlot?: boolean;
     /** Width of the through slot along its centerline segment. Default `0.6`. */
     slotWidth?: number;
     /**
-     * Wall extrusion height in meters. Default `2.6` to match the example HTML.
+     * Ribbon extrusion height in meters. Default `2.6` to match the example HTML.
      */
     height?: number;
 }
@@ -17,16 +17,16 @@ export interface WallFromOffsetsOptions {
  * other thrown value). Used by the example HTML to surface kernel failures
  * in a status panel without losing the structured payload.
  */
-export declare function describeWallSubtractError(error: unknown): string;
-export declare function createWallFromOffsetsExample(scene: THREE.Scene, options?: WallFromOffsetsOptions): {
+export declare function describeRibbonSubtractError(error: unknown): string;
+export declare function createRibbonFromOffsetsExample(scene: THREE.Scene, options?: RibbonFromOffsetsOptions): {
     centerline: Polyline;
     leftOffsetPolyline: Polyline;
     rightOffsetPolyline: Polyline;
-    wallPolygon: Polygon;
+    ribbonPolygon: Polygon;
     leftOffset: import("../primitives/polyline.js").IOffsetResult;
     rightOffset: import("../primitives/polyline.js").IOffsetResult;
     cutResult: {
-        wall: THREE.Object3D;
+        ribbon: THREE.Object3D;
         cutters: AnalyticSolid[];
     } | null;
     cutError: unknown;

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/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;