opengeometry 2.0.13 → 2.0.15

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "opengeometry",
-  "version": "2.0.13",
-  "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",
@@ -19,6 +19,7 @@
       "default": "./opengeometry/pkg/opengeometry.js"
     },
     "./opengeometry_bg.wasm": "./opengeometry_bg.wasm",
+    "./analytic-worker.js": "./analytic-worker.js",
     "./package.json": "./package.json"
   },
   "keywords": [
@@ -31,8 +32,6 @@
     "geometry",
     "webassembly",
     "wasm",
-    "aec",
-    "bim",
     "ifc",
     "step",
     "stl",

package/src/examples/booleans.d.ts

@@ -1,6 +1,7 @@
 import * as THREE from "three";
 import { Vector3 } from "../../opengeometry/pkg/opengeometry.js";
-import { BooleanExecutionOptions, BooleanResult } from "../operations/boolean.js";
+import { BooleanExecutionOptions } from "../operations/boolean.js";
+import { AnalyticSolid } from "../shapes/analytic-solid.js";
 export type BooleanExampleOperation = "union" | "intersection" | "subtraction";
 export type BooleanExampleMode = "solid" | "polygon" | "extruded";
 export interface BooleanExampleBuildOptions extends BooleanExecutionOptions {
@@ -13,7 +14,7 @@ export interface BooleanExampleBuildResult {
     group: THREE.Group;
     lhs: THREE.Object3D;
     rhs: THREE.Object3D;
-    result: BooleanResult;
+    result: AnalyticSolid;
     title: string;
     description: string;
 }

package/src/examples/editor-modes.d.ts

@@ -1,12 +1,11 @@
 import * as THREE from "three";
-import { FreeformEditResult, FreeformEditor } from "../editor.js";
+import { FreeformEditResult } from "../editor.js";
 import { Line } from "../primitives/line.js";
 import { Polygon } from "../shapes/polygon.js";
 import { Cuboid } from "../shapes/cuboid.js";
 /**
- * Demonstrates the intended editing flow for editor-controls:
- * parametric config/placement edits first, then explicit freeform conversion,
- * including wire-backed freeform edge insertion on a converted line.
+ * Demonstrates strict v2 parametric solid edits and the separate sampled-wire
+ * freeform editor. Analytic solid freeform conversion is intentionally unsupported.
  */
 export declare function createEditorModesExample(scene: THREE.Scene): {
     polygon: Polygon;
@@ -16,9 +15,6 @@ export declare function createEditorModesExample(scene: THREE.Scene): {
     cuboidCapabilities: import("../editor.js").ParametricEditCapabilities;
     guideLineCapabilities: import("../editor.js").ParametricEditCapabilities;
     guideLineFreeform: import("../freeform.js").FreeformGeometry;
-    guideLineEditor: FreeformEditor;
+    guideLineEditor: import("../editor.js").FreeformEditor;
     guideLineSplitResult: FreeformEditResult | null;
-    freeform: import("../freeform.js").FreeformGeometry;
-    freeformEditor: FreeformEditor;
-    freeformResult: FreeformEditResult | null;
 };

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/ribbon-from-offsets.d.ts

@@ -0,0 +1,33 @@
+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 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;
+    /**
+     * Ribbon extrusion height in meters. Default `2.6` to match the example HTML.
+     */
+    height?: number;
+}
+/**
+ * Renders a human-readable description for an analytic geometry error (or any
+ * other thrown value). Used by the example HTML to surface kernel failures
+ * in a status panel without losing the structured payload.
+ */
+export declare function describeRibbonSubtractError(error: unknown): string;
+export declare function createRibbonFromOffsetsExample(scene: THREE.Scene, options?: RibbonFromOffsetsOptions): {
+    centerline: Polyline;
+    leftOffsetPolyline: Polyline;
+    rightOffsetPolyline: Polyline;
+    ribbonPolygon: Polygon;
+    leftOffset: import("../primitives/polyline.js").IOffsetResult;
+    rightOffset: import("../primitives/polyline.js").IOffsetResult;
+    cutResult: {
+        ribbon: THREE.Object3D;
+        cutters: AnalyticSolid[];
+    } | null;
+    cutError: unknown;
+};

package/src/examples/shapes.d.ts

@@ -3,8 +3,8 @@ import { Cuboid } from "../shapes/cuboid.js";
 import { Cylinder } from "../shapes/cylinder.js";
 import { Opening } from "../shapes/opening.js";
 import { Polygon } from "../shapes/polygon.js";
-import { Sphere } from "../shapes/sphere.js";
 import { Sweep } from "../shapes/sweep.js";
+import { Sphere } from "../shapes/sphere.js";
 import { Wedge } from "../shapes/wedge.js";
 /**
  * Adds a basic shapes showcase to the provided scene.

package/src/export/analytic-ifc.d.ts

@@ -0,0 +1,61 @@
+export type IfcPreparedValue = {
+    kind: "Ref";
+    id: number;
+} | {
+    kind: "List";
+    values: IfcPreparedValue[];
+} | {
+    kind: "Real";
+    value: number;
+} | {
+    kind: "Integer";
+    value: number;
+} | {
+    kind: "Text" | "Enum";
+    value: string;
+} | {
+    kind: "Bool";
+    value: boolean;
+} | {
+    kind: "Null" | "Derived";
+};
+export interface AnalyticExchangeBodyV2 {
+    schema_version: 2;
+    revision: string;
+    length_unit: "metre";
+    up_axis: "Z";
+    coordinate_space: "world";
+    representation_type: "AdvancedBrep" | "CSG";
+    quality: {
+        kind: "Analytic";
+    } | {
+        kind: "Approximate";
+        max_error: number;
+    };
+    geometric_tolerance: number;
+    exchange_error_bound: number;
+    validation_level: string;
+    entities: {
+        id: number;
+        entity_type: string;
+        attributes: IfcPreparedValue[];
+    }[];
+    solids: number[];
+    faces: {
+        face: number;
+        key: string;
+        entity: number;
+        provenance: {
+            sources: {
+                entity: string;
+                body: string;
+                key: string;
+                face: number;
+            }[];
+            role: "Authored" | "Preserved" | "Split" | "Cut" | "Coincident";
+            reversed: boolean;
+        };
+    }[];
+}
+/** Serializes Rust-prepared geometry; this function does not fit curves or tessellate surfaces. */
+export declare function analyticIfcText(body: AnalyticExchangeBodyV2, name?: string): string;

package/src/freeform/geometry.d.ts

@@ -78,3 +78,5 @@ export declare class FreeformGeometry {
  * BRep object, or another wrapper exposing BRep accessors.
  */
 export declare function createFreeformGeometry(source: FreeformSource, options?: CreateFreeformGeometryOptions): FreeformGeometry;
+/** Triangulates an explicitly faceted BRep, including its planar face holes. */
+export declare function tessellateFacetedBrep(serialized: string): Float64Array;

package/src/freeform/index.d.ts

@@ -2,4 +2,4 @@
  * Freeform geometry types and helpers for working with raw BRep-backed models.
  */
 export * from "./types.js";
-export { FreeformGeometry, createFreeformGeometry } from "./geometry.js";
+export { FreeformGeometry, createFreeformGeometry, tessellateFacetedBrep } from "./geometry.js";

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

@@ -0,0 +1,8 @@
+export type AnalyticGeometryErrorCode = "math" | "invalid_geometry" | "invalid_topology" | "unsupported_geometry" | "ambiguous_profile_alignment" | "coverage_gap" | "singular_parameterization" | "missing_reference" | "unsupported_schema" | "unresolved_intersection" | "unresolved_tessellation" | "limit_exceeded" | "unknown";
+export declare class AnalyticGeometryError extends Error {
+    readonly code: AnalyticGeometryErrorCode;
+    readonly detail: unknown;
+    readonly families?: readonly [string, string];
+    constructor(code: AnalyticGeometryErrorCode, message: string, detail?: unknown);
+}
+export declare function parseAnalyticGeometryError(raw: unknown): AnalyticGeometryError;

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/boolean.d.ts

@@ -1,148 +1,16 @@
 import * as THREE from "three";
-import { type CreateFreeformGeometryOptions, type FreeformGeometry } from "../freeform.js";
-/**
- * Accepted operand formats for boolean helpers.
- */
-export type BooleanOperand = string | Record<string, unknown> | {
-    getBrep?: () => unknown;
-    getBrepData?: () => unknown;
-    getBrepSerialized?: () => string;
-};
-/**
- * Kernel-side boolean tuning options.
- *
- * `tolerance` is in **model units** (meters by convention). When omitted, the
- * kernel auto-scales it to `operandsDiagonal * 1e-8` (clamped to a `1e-6`
- * floor in many-subtract). This drives the kernel-side polygon / face math
- * (vertex welding, plane coincidence, AABB enforcement).
- *
- * **NOTE: this tolerance does NOT control boolmesh's internal snap window.**
- * Boolmesh has its own welding tolerance that may treat faces within ~1mm
- * of each other as coincident, regardless of what `tolerance` you pass. If
- * your cutter face sits within about 0.001 m – 0.01 m of a host face you
- * may still hit a `DegenerateTriangle` / `CoincidentFaces` error path.
- *
- * **Recommended cutter overshoot for through-cuts:** `max(hostThickness *
- * 0.05, 0.01)` in model units. See `knowledge/boolean-tolerance-guide.md`.
- *
- * `mergeCoplanarFaces` (default `true`) controls whether the planar pipeline
- * merges coplanar adjacent faces in its output.
- */
-export interface BooleanKernelOptions {
-    tolerance?: number;
-    mergeCoplanarFaces?: boolean;
-}
-/**
- * Rendering options applied to the boolean result mesh.
- *
- * `color`, `opacity`, `transparent`, and `side` override the corresponding
- * fields on the host (LHS) operand's cloned material. Omit them to inherit
- * the host's appearance unchanged.
- */
-export interface BooleanRenderOptions {
+import { AnalyticSolid } from "../shapes/analytic-solid.js";
+/** Rendering and tessellation options applied to an analytic boolean result. */
+export interface BooleanExecutionOptions {
+    deflection?: number;
     color?: THREE.ColorRepresentation;
     opacity?: number;
     transparent?: boolean;
     side?: THREE.Side;
     outline?: boolean;
-    fatOutlines?: boolean;
-    outlineWidth?: number;
-}
-/**
- * Combined kernel and rendering options accepted by boolean helpers.
- */
-export interface BooleanExecutionOptions extends BooleanRenderOptions {
-    kernel?: BooleanKernelOptions;
-}
-/**
- * Structured report returned by the kernel boolean pipeline.
- */
-export interface BooleanReport {
-    operation: string;
-    operand_kind: string;
-    input_face_count: number;
-    input_triangle_count: number;
-    output_face_count: number;
-    output_shell_count: number;
-    empty: boolean;
-}
-interface KernelBooleanResult {
-    brepSerialized: string;
-    geometrySerialized: string;
-    outlineGeometrySerialized: string;
-    reportJson: string;
-}
-/**
- * Renderable result mesh returned by the kernel boolean helpers.
- */
-export declare class BooleanResult extends THREE.Mesh {
-    #private;
-    ogid: string;
-    report: BooleanReport | null;
-    private brepSerialized;
-    private brepData;
-    private outlinePositions;
-    private _outlineEnabled;
-    private _fatOutlines;
-    private _outlineWidth;
-    constructor(kernelResult: KernelBooleanResult, options?: BooleanRenderOptions, host?: BooleanOperand | null);
-    /**
-     * Updates the result mesh's color in place without re-running the boolean
-     * pipeline. Accepts any value Three.js accepts (`number`, hex string, css
-     * color name, or `THREE.Color`). No-op for materials without a `color` field.
-     */
-    set color(value: THREE.ColorRepresentation);
-    get color(): THREE.Color | null;
-    /**
-     * Rebuilds the mesh, cached BRep payload, and outline geometry from the kernel output.
-     */
-    applyKernelResult(kernelResult: KernelBooleanResult, options?: BooleanRenderOptions, sourceMaterial?: THREE.Material | null): void;
-    /**
-     * Returns the parsed BRep object for reuse with scene export or downstream operations.
-     */
-    getBrepData(): Record<string, unknown> | null;
-    /**
-     * Returns the serialized BRep JSON emitted by the kernel boolean operation.
-     */
-    getBrepSerialized(): string;
-    canConvertToFreeform(): boolean;
-    /**
-     * Converts the boolean output into a first-class freeform geometry object so
-     * it can participate in direct face/edge/vertex editing.
-     */
-    toFreeform(options?: CreateFreeformGeometryOptions): FreeformGeometry;
-    set outline(enable: boolean);
-    get outline(): boolean;
-    set fatOutlines(value: boolean);
-    get fatOutlines(): boolean;
-    set outlineWidth(value: number);
-    get outlineWidth(): number;
-    disposeGeometry(): void;
-    private clearOutlineMesh;
 }
-/**
- * Computes a kernel-backed boolean union and returns a renderable result mesh.
- *
- * Accepts wrapper objects directly, including `Solid`, `Cuboid`, `Opening`,
- * and other shapes that expose BRep accessors.
- */
-export declare function booleanUnion(lhs: BooleanOperand, rhs: BooleanOperand, options?: BooleanExecutionOptions): BooleanResult;
-/**
- * Computes a kernel-backed boolean intersection and returns a renderable result mesh.
- */
-export declare function booleanIntersection(lhs: BooleanOperand, rhs: BooleanOperand, options?: BooleanExecutionOptions): BooleanResult;
-/**
- * Computes a kernel-backed boolean subtraction and returns a renderable result mesh.
- *
- * Use this when you want a standalone helper rather than a shape-level
- * convenience method like `opening.subtractFrom(host)`.
- */
-export declare function booleanSubtraction(lhs: BooleanOperand, rhs: BooleanOperand, options?: BooleanExecutionOptions): BooleanResult;
-/**
- * Computes a kernel-backed repeated subtraction using a left-to-right cutter array.
- *
- * This is used by the shape-level `.subtract([...])` helpers so the heavy
- * boolean orchestration stays in the Rust/WASM layer instead of JavaScript.
- */
-export declare function executeBooleanSubtractionMany(lhs: BooleanOperand, cutters: BooleanOperand[], options?: BooleanExecutionOptions): BooleanResult;
-export {};
+export type BooleanOperand = AnalyticSolid;
+export declare function booleanUnion(lhs: AnalyticSolid, rhs: AnalyticSolid, options?: BooleanExecutionOptions): AnalyticSolid;
+export declare function booleanIntersection(lhs: AnalyticSolid, rhs: AnalyticSolid, options?: BooleanExecutionOptions): AnalyticSolid;
+export declare function booleanSubtraction(lhs: AnalyticSolid, rhs: AnalyticSolid, options?: BooleanExecutionOptions): AnalyticSolid;
+export declare function executeBooleanSubtractionMany(lhs: BooleanOperand, cutters: BooleanOperand[], options?: BooleanExecutionOptions): AnalyticSolid;

package/src/operations/index.d.ts

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

package/src/operations/loft.d.ts

@@ -0,0 +1,13 @@
+import * as THREE from "three";
+import { AnalyticSolid, type AnalyticPolygonLoftAlignment } from "../shapes/analytic-solid.js";
+export type PolygonLoftPoint = readonly [number, number, number];
+export interface PolygonLoftOptions {
+    alignment?: AnalyticPolygonLoftAlignment;
+    deflection?: number;
+    color?: THREE.ColorRepresentation;
+}
+/**
+ * Creates a capped ruled solid between two planar polygon sections.
+ * Sections must have equal vertex counts and produce planar side faces.
+ */
+export declare function loftPolygonSections(sections: readonly [readonly PolygonLoftPoint[], readonly PolygonLoftPoint[]], options?: PolygonLoftOptions): AnalyticSolid;

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/primitives/analytic-curve.d.ts

@@ -0,0 +1,42 @@
+import * as THREE from "three";
+import { OGAnalyticBrep } from "../../opengeometry/pkg/opengeometry.js";
+import type { AnalyticAccuracy, AnalyticFrame } from "../shapes/analytic-solid.js";
+export type AnalyticCurveOptions = {
+    ogid?: string;
+    frame?: AnalyticFrame;
+    accuracy?: AnalyticAccuracy;
+    startAngle: number;
+    sweepAngle: number;
+    deflection?: number;
+    color?: THREE.ColorRepresentation;
+} & ({
+    kind: "arc";
+    radius: number;
+} | {
+    kind: "ellipticalArc";
+    majorRadius: number;
+    minorRadius: number;
+});
+export interface AnalyticCurveStats {
+    requestedDeflection: number;
+    achievedDeflection: number;
+    segmentCount: number;
+    revision: bigint;
+}
+export declare class AnalyticCurve extends THREE.Group {
+    readonly ogid: string;
+    readonly line: THREE.LineSegments<THREE.BufferGeometry, THREE.LineBasicMaterial>;
+    protected kernel: OGAnalyticBrep;
+    private segmentEdges;
+    private disposed;
+    get color(): THREE.Color;
+    set color(value: THREE.ColorRepresentation);
+    constructor(options: AnalyticCurveOptions);
+    getBrepSerialized(): string;
+    getBrepData(): Record<string, unknown>;
+    protected replaceDefinition(options: AnalyticCurveOptions): AnalyticCurveStats;
+    edgeIdForSegment(segment: number): number | undefined;
+    retessellate(deflection: number): AnalyticCurveStats;
+    dispose(): void;
+    private checkActive;
+}

package/src/primitives/arc.d.ts

@@ -1,65 +1,36 @@
-import { Vector3 } from "../../opengeometry/pkg/opengeometry.js";
 import * as THREE from "three";
-/**
- * Construction options for an arc or full-circle primitive.
- */
+import { Vector3 } from "../../opengeometry/pkg/opengeometry.js";
+import { AnalyticCurve, type AnalyticCurveStats } from "./analytic-curve.js";
+import type { AnalyticAccuracy } from "../shapes/analytic-solid.js";
 export interface IArcOptions {
+    ogid?: string;
+    center?: Vector3;
+    radius?: number;
+    startAngle?: number;
+    sweepAngle?: number;
+    deflection?: number;
+    accuracy?: AnalyticAccuracy;
+    color?: THREE.ColorRepresentation;
+}
+export type ArcConfigUpdate = Partial<Omit<IArcOptions, "ogid">>;
+interface NormalizedArcOptions {
     ogid?: string;
     center: Vector3;
     radius: number;
     startAngle: number;
-    endAngle: number;
-    segments: number;
-    color: number;
-    fatLines?: boolean;
-    width?: number;
-    translation?: Vector3;
-    rotation?: Vector3;
-    scale?: Vector3;
-}
-/**
- * Placement updates accepted by `Arc`.
- */
-export interface ArcPlacementOptions {
-    translation?: Vector3;
-    rotation?: Vector3;
-    scale?: Vector3;
+    sweepAngle: number;
+    deflection: number;
+    accuracy?: AnalyticAccuracy;
+    color: THREE.ColorRepresentation;
 }
-/**
- * Partial config payload accepted by `Arc.setConfig(...)`.
- */
-export type ArcConfigUpdate = Partial<Omit<IArcOptions, "translation" | "rotation" | "scale">>;
-/**
- * Alias for `Arc` placement updates.
- */
-export type ArcPlacementUpdate = ArcPlacementOptions;
-/**
- * Arc wrapper backed by the kernel OGArc primitive.
- */
-export declare class Arc extends THREE.Line {
-    ogid: string;
-    options: IArcOptions;
-    private arc;
-    private fatLine;
-    set color(color: number);
+/** Authoritative circular edge with transient deflection tessellation. */
+export declare class Arc extends AnalyticCurve {
+    options: Readonly<NormalizedArcOptions>;
     constructor(options?: IArcOptions);
-    validateOptions(): void;
-    setConfig(options: ArcConfigUpdate): void;
     getAnchor(): Vector3;
-    setPlacement(placement: ArcPlacementUpdate): void;
-    setTransform(translation: Vector3, rotation: Vector3, scale: Vector3): void;
-    setTranslation(translation: Vector3): void;
-    setRotation(rotation: Vector3): void;
-    setScale(scale: Vector3): void;
-    getConfig(): IArcOptions;
-    getPlacement(): import("../editor.js").ParametricPlacement;
-    getEditCapabilities(): import("../editor.js").ParametricEditCapabilities;
-    canConvertToFreeform(): boolean;
-    toFreeform(id?: string): import("../freeform.js").FreeformGeometry;
-    private getCurrentPositions;
-    private updateRenderStyle;
-    private generateGeometry;
-    getBrep(): any;
-    discardGeometry(): void;
-    private writePositionsToGeometry;
+    getConfig(): Readonly<NormalizedArcOptions>;
+    setConfig(update: ArcConfigUpdate): AnalyticCurveStats;
+    getBrep(): Record<string, unknown>;
+    retessellate(deflection: number): AnalyticCurveStats;
 }
+export {};