@thatopen/components 3.4.0 → 3.4.2

package/dist/index.d.ts

@@ -80,10 +80,7 @@ export declare type AngleAnnotationEvent =
     type: "ESCAPE";
 };
 
-/**
- * Global drawing system that manages angle dimension annotations across all
- * {@link TechnicalDrawing} instances.
- */
+/** Global drawing system that manages angle dimension annotations across all {@link TechnicalDrawing} instances. */
 export declare class AngleAnnotations extends AnnotationSystem<AngleAnnotationSystem> implements Transitionable<AngleAnnotationState, AngleAnnotationEvent>, Disposable_2 {
     enabled: boolean;
     readonly _item: AngleAnnotation;
@@ -157,17 +154,10 @@ declare interface AngleAnnotationSystem {
     handle: "pointA" | "vertex" | "pointB";
 }
 
-/**
- * Pure state transition function for the angle dimension tool.
- * Returns the **same state reference** when no transition applies.
- */
+/** Pure state transition function for the angle dimension tool. */
 export declare function angleDimensionMachine(state: AngleAnnotationState, event: AngleAnnotationEvent): AngleAnnotationState;
 
-/**
- * A single annotation entry stored in {@link DrawingAnnotations}.
- * Bundles the owning system, the annotation data, and its Three.js group
- * so that any lookup by UUID gives full access to all three.
- */
+/** A single annotation entry stored in {@link DrawingAnnotations}, bundling the owning system, the annotation data, and its Three.js group. */
 export declare interface AnnotationEntry {
     /** The system that created and owns this annotation. */
     system: AnnotationSystem<any>;
@@ -178,13 +168,8 @@ export declare interface AnnotationEntry {
 }
 
 /**
- * Abstract base for all annotation sub-systems operating on a
- * {@link TechnicalDrawing}. Provides the full CRUD lifecycle, material caches,
- * preview geometry, and automatic style-reactivity so subclasses only need to
- * implement geometry construction and handle-picking.
- *
- * @typeParam TSystem - A {@link DrawingSystemDescriptor} that declares the item,
- *   data, style, and handle types for this specific system.
+ * Abstract base for all annotation sub-systems operating on a {@link TechnicalDrawing}.
+ * @typeParam TSystem - A {@link DrawingSystemDescriptor} that declares the item, data, style, and handle types for this specific system.
  */
 declare abstract class AnnotationSystem<TSystem extends DrawingSystemDescriptor> {
     protected readonly _components: Components;
@@ -262,10 +247,7 @@ declare abstract class AnnotationSystem<TSystem extends DrawingSystemDescriptor>
 export { AnnotationSystem }
 export { AnnotationSystem as DrawingSystem }
 
-/**
- * Closed arrowhead tick — two wing lines plus a base line connecting them,
- * forming a triangle outline (tip → wing1, tip → wing2, wing1 → wing2).
- */
+/** Closed arrowhead tick — two wing lines plus a base line connecting them. */
 export declare const ArrowTick: LineTickBuilder;
 
 /**
@@ -301,13 +283,7 @@ export declare class AsyncEvent<T> {
     private handlers;
 }
 
-/**
- * Minimal interface for a translate-only gizmo that can be configured and
- * attached to one of the helper's control handles.
- *
- * Satisfied by `THREE.TransformControls` without a direct import, keeping
- * this class free of DOM dependencies.
- */
+/** Minimal interface for a translate-only gizmo that can be configured and attached to one of the helper's control handles. */
 export declare interface AxisGizmoLike {
     attach(object: THREE.Object3D): void;
     setSpace(space: "world" | "local"): void;
@@ -338,10 +314,7 @@ export declare abstract class Base {
     isSerializable: () => this is Serializable<any, Record<string, any>>;
 }
 
-/**
- * Minimum style contract shared by every annotation system.
- * All per-system style interfaces must extend this.
- */
+/** Minimum style contract shared by every annotation system. */
 export declare interface BaseAnnotationStyle {
     /** Line and text color as a hex number (e.g. `0xff0000`). */
     color: number;
@@ -837,32 +810,7 @@ export declare interface BCFViewpoint {
     bitmaps?: ViewpointBitmap[];
 }
 
-/**
- * Global drawing system that manages block insertions across all
- * {@link TechnicalDrawing} instances.
- *
- * A **block** is a named, reusable geometry definition (e.g. a furniture symbol
- * or a detail imported from a DXF). Multiple insertions of the same block share
- * the same `THREE.BufferGeometry`, so only the transform (position, rotation,
- * scale) differs per instance.
- *
- * Register via {@link TechnicalDrawings.use}:
- * ```ts
- * const blocks = techDrawings.use(BlockAnnotations);
- * ```
- *
- * Typical workflow:
- * ```ts
- * // 1. Project external geometry to drawing space
- * const projected = TechnicalDrawing.toDrawingSpace(ifcLines, drawing);
- *
- * // 2. Register the block definition (global — do this once)
- * blocks.define("CHAIR", { lines: projected.geometry });
- *
- * // 3. Insert on any drawing
- * blocks.add(drawing, { blockName: "CHAIR", position, rotation: 0, scale: 1, style: "default" });
- * ```
- */
+/** Global drawing system that manages block insertions across all {@link TechnicalDrawing} instances. */
 export declare class BlockAnnotations extends AnnotationSystem<BlockAnnotationsSystem> implements Disposable_2 {
     enabled: boolean;
     readonly _item: BlockInsertion;
@@ -872,6 +820,29 @@ export declare class BlockAnnotations extends AnnotationSystem<BlockAnnotationsS
      * Register via {@link define}. Geometry is shared across all drawings and insertions.
      */
     readonly definitions: FRAGS.DataMap<string, BlockDefinition>;
+    /**
+     * A **block** is a named, reusable geometry definition (e.g. a furniture symbol
+     * or a detail imported from a DXF). Multiple insertions of the same block share
+     * the same `THREE.BufferGeometry`, so only the transform (position, rotation,
+     * scale) differs per instance.
+     *
+     * Register via {@link TechnicalDrawings.use}:
+     * ```ts
+     * const blocks = techDrawings.use(BlockAnnotations);
+     * ```
+     *
+     * Typical workflow:
+     * ```ts
+     * // 1. Project external geometry to drawing space
+     * const projected = TechnicalDrawing.toDrawingSpace(ifcLines, drawing);
+     *
+     * // 2. Register the block definition (global — do this once)
+     * blocks.define("CHAIR", { lines: projected.geometry });
+     *
+     * // 3. Insert on any drawing
+     * blocks.add(drawing, { blockName: "CHAIR", position, rotation: 0, scale: 1, style: "default" });
+     * ```
+     */
     constructor(components: Components);
     pickHandle(_drawing: TechnicalDrawing, _ray: THREE.Ray, _threshold?: number): {
         uuid: string;
@@ -902,14 +873,7 @@ declare interface BlockAnnotationsSystem {
     handle: "position" | "rotation" | "scale";
 }
 
-/**
- * The geometry content of a named block.
- * At least one of `lines` or `mesh` must be provided.
- *
- * - `lines` — `BufferGeometry` rendered as `LineSegments` (wire outlines).
- * - `mesh`  — `BufferGeometry` rendered as a filled `THREE.Mesh` (e.g. hatches
- *              or solid fills imported from DXF `SOLID`/`HATCH` entities).
- */
+/** The geometry content of a named block. At least one of `lines` or `mesh` must be provided. */
 export declare interface BlockDefinition {
     /** Line geometry for `LineSegments`. */
     lines?: THREE.BufferGeometry;
@@ -917,10 +881,7 @@ export declare interface BlockDefinition {
     mesh?: THREE.BufferGeometry;
 }
 
-/**
- * A single placed instance of a named block definition.
- * All coordinates are in drawing local space (XZ plane, Y = 0).
- */
+/** A single placed instance of a named block definition. */
 export declare interface BlockInsertion {
     /** Unique identifier for this insertion. */
     uuid: string;
@@ -939,11 +900,7 @@ export declare interface BlockInsertion {
 /** Editable fields of {@link BlockInsertion} — everything except the `uuid`. */
 export declare type BlockInsertionData = Omit<BlockInsertion, "uuid">;
 
-/**
- * Style for a {@link BlockAnnotations} system.
- * `textOffset` and `fontSize` are unused for blocks but required by
- * {@link BaseAnnotationStyle} — set them to `0` in the default style.
- */
+/** Style for a {@link BlockAnnotations} system. */
 export declare interface BlockStyle extends BaseAnnotationStyle {
 }
 
@@ -1019,43 +976,19 @@ export declare class BoundingBoxer extends Component implements Disposable_2 {
  */
 export declare function buildAnglePositions(dim: AngleAnnotation, style: AngleAnnotationStyle): number[];
 
-/**
- * Builds vertex positions for the live preview during `positioningArc`.
- * Uses the cursor distance from the vertex as the arc radius.
- */
+/** Builds vertex positions for the live preview during `positioningArc`. */
 export declare function buildAnglePreviewPositions(pointA: THREE.Vector3, vertex: THREE.Vector3, pointB: THREE.Vector3, cursor: THREE.Vector3 | null, style: AngleAnnotationStyle, flipped?: boolean): number[];
 
-/**
- * Builds the flat vertex positions for a committed callout annotation:
- * enclosure outline + attachment-to-elbow line + elbow-to-extensionEnd line
- * + optional tick at `extensionEnd`.
- */
+/** Builds the flat vertex positions for a committed callout annotation. */
 export declare function buildCalloutPositions(ann: CalloutAnnotation, style: CalloutAnnotationStyle): number[];
 
-/**
- * Builds vertex positions for the live preview during interactive placement.
- * During `awaitingRadius`, `cursor` is treated as the SE corner of the enclosure
- * so halfW/halfH are derived live from the delta to `center`.
- */
+/** Builds vertex positions for the live preview during interactive placement. */
 export declare function buildCalloutPreviewPositions(kind: "awaitingRadius" | "awaitingElbow" | "awaitingExtension", center: THREE.Vector3, halfW: number, halfH: number, elbow: THREE.Vector3 | null, cursor: THREE.Vector3 | null, style: CalloutAnnotationStyle): number[];
 
-/**
- * Builds the flat vertex positions (x,y,z triplets) for a single committed
- * linear dimension. The result can be passed directly to a
- * `THREE.BufferAttribute`.
- *
- * The geometry lives in drawing local space (XZ plane, Y = 0) and consists of:
- * - Extension line from pointA
- * - Extension line from pointB
- * - Dimension line connecting both extension line ends
- * - Tick geometry at each end of the dimension line (from `style.tick`)
- */
+/** Builds the flat vertex positions (x,y,z triplets) for a single committed linear dimension. */
 export declare function buildDimensionPositions(dim: LinearAnnotation, style: LinearAnnotationStyle): number[];
 
-/**
- * Builds an array of {@link LinearAnnotation}s from consecutive point pairs,
- * all sharing the same perpendicular offset.
- */
+/** Builds an array of {@link LinearAnnotation}s from consecutive point pairs, all sharing the same perpendicular offset. */
 export declare function buildDimensions(points: THREE.Vector3[], offset: number): LinearAnnotation[];
 
 /**
@@ -1068,31 +1001,16 @@ export declare function buildLeaderPositions(ann: LeaderAnnotation, style: Leade
  */
 export declare function buildLeaderPreviewPositions(kind: "placingElbow" | "placingExtension", arrowTip: THREE.Vector3, elbow: THREE.Vector3 | null, cursor: THREE.Vector3 | null, style: LeaderAnnotationStyle): number[];
 
-/**
- * Builds the flat vertex positions for a live dimension preview.
- *
- * During `placingPoints`: lines connecting all placed points plus a line
- * to the cursor.
- * During `positioningOffset`: a full dimension preview using the cursor as
- * the offset reference, rendered with the active style's tick.
- */
+/** Builds the flat vertex positions for a live dimension preview. */
 export declare function buildPreviewPositions(kind: "placingPoints" | "positioningOffset", points: THREE.Vector3[], cursor: THREE.Vector3 | null, style: LinearAnnotationStyle): number[];
 
 /**
  * Builds the `LineSegments` position array for a committed slope annotation.
- *
- * The geometry consists of:
- * - **Shaft**: tail → tip
- * - **Tick**: geometry produced by `style.tick` at the downhill tip
- *
  * @returns A flat `Float32Array` of XYZ triplets (vertex pairs for `LineSegments`).
  */
 export declare function buildSlopePositions(ann: SlopeAnnotation, style: SlopeAnnotationStyle): Float32Array;
 
-/**
- * The committed data for a single callout annotation.
- * All coordinates are in drawing local space (XZ plane, Y = 0).
- */
+/** The committed data for a single callout annotation. */
 export declare interface CalloutAnnotation {
     /** Unique identifier. */
     uuid: string;
@@ -1141,16 +1059,10 @@ export declare type CalloutAnnotationEvent =
     type: "ESCAPE";
 };
 
-/**
- * Pure state transition function for the callout annotation tool.
- * Returns the **same state reference** when no transition applies.
- */
+/** Pure state transition function for the callout annotation tool. */
 export declare function calloutAnnotationMachine(state: CalloutAnnotationState, event: CalloutAnnotationEvent): CalloutAnnotationState;
 
-/**
- * Global drawing system that manages callout annotations across all
- * {@link TechnicalDrawing} instances.
- */
+/** Global drawing system that manages callout annotations across all {@link TechnicalDrawing} instances. */
 export declare class CalloutAnnotations extends AnnotationSystem<CalloutAnnotationSystem> implements Transitionable<CalloutAnnotationState, CalloutAnnotationEvent>, Disposable_2 {
     enabled: boolean;
     readonly _item: CalloutAnnotation;
@@ -1257,11 +1169,7 @@ export declare interface CameraControllable {
  */
 export declare type CameraProjection = "Perspective" | "Orthographic";
 
-/**
- * Elliptical enclosure — an ellipse approximated with line segments centred on
- * `center`, with semi-axis `halfW` on X and `halfH` on Z.
- * When `halfW === halfH` the result is a circle.
- */
+/** Elliptical enclosure — an ellipse approximated with line segments centred on `center`. */
 export declare const CircleEnclosure: EnclosureBuilder;
 
 /**
@@ -1615,10 +1523,7 @@ declare type ClipperConfigType = {
     size: NumberSettingControl;
 };
 
-/**
- * Revision-cloud enclosure — a bumpy rectangle centred on `center`.
- * Width = 2 × halfW, height = 2 × halfH.
- */
+/** Revision-cloud enclosure — a bumpy rectangle centred on `center`. */
 export declare const CloudEnclosure: EnclosureBuilder;
 
 export declare interface ColorSettingsControl {
@@ -1763,45 +1668,21 @@ export declare class Components implements Disposable_2 {
 }
 
 /**
- * Computes a local-to-world transformation matrix that maps a technical
- * drawing's local coordinate system onto a target plane in 3D world space.
- *
- * Given three point pairs — each pair being a point on the drawing (local
- * space) and its corresponding point in the 3D world — the function returns
- * the `THREE.Matrix4` that, when applied to the drawing's container, will
- * align the drawing to the target plane.
- *
- * The transformation encodes **translation**, **rotation**, and **uniform
- * scale** (derived from the ratio of world vs drawing distances between the
- * first pair of points, which handles unit mismatches such as mm vs m).
- *
+ * Computes a local-to-world transformation matrix that maps a technical drawing's local coordinate system onto a target plane in 3D world space.
  * @throws If either set of points is collinear (cannot define a plane).
  * @throws If either set contains a degenerate first pair (zero distance).
- *
  * @param drawingPoints - Three non-collinear points in drawing local space.
  * @param worldPoints   - Three corresponding non-collinear points in world space.
  */
 export declare function computeAlignmentMatrix(drawingPoints: THREE.Vector3[], worldPoints: THREE.Vector3[]): THREE.Matrix4;
 
-/**
- * Returns the angle in radians between the two rays defined by the dimension.
- * Result is in [0, π].
- */
+/** Returns the angle in radians between the two rays defined by the dimension. */
 export declare function computeAngle(dim: AngleAnnotation): number;
 
-/**
- * Returns the angle (in radians, in the XZ plane) of the bisector ray between
- * the two measured rays. Useful for positioning the text label.
- */
+/** Returns the angle (in radians, in the XZ plane) of the bisector ray between the two measured rays. */
 export declare function computeBisectorAngle(dim: AngleAnnotation): number;
 
-/**
- * Computes the signed offset from a cursor position to the measurement axis
- * defined by the first and last points.
- *
- * The offset is measured perpendicular to the `(points[0] → points[last])`
- * direction, which is the direction along the measured lines (lineDir).
- */
+/** Computes the signed offset from a cursor position to the measurement axis defined by the first and last points. */
 export declare function computeOffset(points: THREE.Vector3[], cursor: THREE.Vector3): number;
 
 /**
@@ -2083,21 +1964,10 @@ export declare class DataSet<T> extends Set<T> {
     dispose(): void;
 }
 
-/**
- * Diagonal slash tick (architectural style).
- * A single line crossing the dimension endpoint at 45° relative to the
- * dimension line direction.
- */
+/** Diagonal slash tick (architectural style). */
 export declare const DiagonalTick: LineTickBuilder;
 
-/**
- * Defines how a measured value (in drawing-space metres) is converted to a
- * display string. Pass one of the {@link Units} presets or build your own.
- *
- * ```ts
- * dims.styles.get("default")!.unit = OBC.Units.cm;
- * ```
- */
+/** Defines how a measured value (in drawing-space metres) is converted to a display string. */
 export declare interface DimensionUnit {
     /** Multiplier applied to the raw metre value before display. */
     factor: number;
@@ -2242,31 +2112,27 @@ export declare interface DocumentReference {
     description?: string;
 }
 
-/**
- * Dot tick — a small circle drawn with line segments at the endpoint.
- * Standard ISO tick for radius and diameter dimensions.
- * The circle is centred on the endpoint and independent of line direction.
- */
+/** Dot tick — a small circle drawn with line segments at the endpoint. */
 export declare const DotTick: LineTickBuilder;
 
-/**
- * Flat annotation store for a {@link TechnicalDrawing}, keyed by UUID.
- *
- * Each entry bundles the owning system, the data, and the Three.js group —
- * so a single `drawing.annotations.get(uuid)` gives full access to all three.
- *
- * Systems write here when they create or update annotations; consumers read
- * from here or subscribe to system-level events (`onCommit`, `onDelete`).
- *
- * ```ts
- * // Get everything for a known UUID
- * const { system, data, three } = drawing.annotations.get(uuid)!;
- *
- * // Iterate all annotations owned by a specific system
- * for (const [uuid, dim] of drawing.annotations.getBySystem(dims)) { ... }
- * ```
- */
+/** Flat annotation store for a {@link TechnicalDrawing}, keyed by UUID. */
 export declare class DrawingAnnotations extends FRAGS.DataMap<string, AnnotationEntry> {
+    /**
+     * Each entry bundles the owning system, the data, and the Three.js group —
+     * so a single `drawing.annotations.get(uuid)` gives full access to all three.
+     *
+     * Systems write here when they create or update annotations; consumers read
+     * from here or subscribe to system-level events (`onCommit`, `onDelete`).
+     *
+     * ```ts
+     * // Get everything for a known UUID
+     * const { system, data, three } = drawing.annotations.get(uuid)!;
+     *
+     * // Iterate all annotations owned by a specific system
+     * for (const [uuid, dim] of drawing.annotations.getBySystem(dims)) { ... }
+     * ```
+     */
+    constructor();
     /**
      * Returns a snapshot map of `uuid → item` for all annotations owned by
      * `system` on this drawing. Filters the flat store by system identity.
@@ -2285,10 +2151,7 @@ export declare class DrawingAnnotations extends FRAGS.DataMap<string, Annotation
     }): Map<string, T>;
 }
 
-/**
- * Result of a successful raycast against a {@link TechnicalDrawing}.
- * The `point` is in the drawing's **local coordinate space** (XZ plane, Y = 0).
- */
+/** Result of a successful raycast against a {@link TechnicalDrawing}. */
 export declare interface DrawingIntersection {
     /** Hit position in drawing local space (X right, Z down-screen, Y = 0). */
     point: THREE.Vector3;
@@ -2306,10 +2169,7 @@ export declare interface DrawingIntersection {
     line: THREE.Line3 | null;
 }
 
-/**
- * A named organizational layer on a {@link TechnicalDrawing}.
- * Mirrors the layer concept in CAD applications (AutoCAD, DXF, etc.).
- */
+/** A named organizational layer on a {@link TechnicalDrawing}. */
 export declare interface DrawingLayer {
     /** Unique name identifying this layer. */
     name: string;
@@ -2328,28 +2188,27 @@ export declare interface DrawingLayer {
     material: THREE.LineBasicMaterial;
 }
 
-/**
- * Manages the named layers of a {@link TechnicalDrawing}.
- *
- * Accessible via `drawing.layers`. Each layer owns a `THREE.LineBasicMaterial`
- * that is shared across all projection `LineSegments` assigned to it —
- * mutating the material (e.g. via {@link setColor}) is reflected on every line
- * immediately without any scene traversal. Annotation systems always use their
- * own style material and are not affected by layer materials.
- *
- * Extends `DataMap<string, DrawingLayer>` so consumers get reactive events
- * (`onItemSet`, `onItemDeleted`, …) directly on `drawing.layers`.
- *
- * Layer `"0"` always exists and cannot be removed.
- *
- * ```ts
- * drawing.layers.create("walls", { material: new THREE.LineBasicMaterial({ color: 0x333333 }) });
- * drawing.layers.setColor("walls", 0x888888);
- * drawing.layers.setVisibility("walls", false);
- * ```
- */
+/** Manages the named layers of a {@link TechnicalDrawing}. */
 export declare class DrawingLayers extends FRAGS.DataMap<string, DrawingLayer> {
     private readonly _container;
+    /**
+     * Accessible via `drawing.layers`. Each layer owns a `THREE.LineBasicMaterial`
+     * that is shared across all projection `LineSegments` assigned to it —
+     * mutating the material (e.g. via {@link setColor}) is reflected on every line
+     * immediately without any scene traversal. Annotation systems always use their
+     * own style material and are not affected by layer materials.
+     *
+     * Extends `DataMap<string, DrawingLayer>` so consumers get reactive events
+     * (`onItemSet`, `onItemDeleted`, …) directly on `drawing.layers`.
+     *
+     * Layer `"0"` always exists and cannot be removed.
+     *
+     * ```ts
+     * drawing.layers.create("walls", { material: new THREE.LineBasicMaterial({ color: 0x333333 }) });
+     * drawing.layers.setColor("walls", 0x888888);
+     * drawing.layers.setVisibility("walls", false);
+     * ```
+     */
     constructor(container: THREE.Group);
     /**
      * Creates a new layer. If a layer with the same name already exists, returns
@@ -2421,20 +2280,7 @@ declare interface DrawingProjectionSource {
     far: number;
 }
 
-/**
- * "Type bag" descriptor that fully parameterises an annotation system.
- * Each system declares a concrete interface extending this.
- *
- * ```ts
- * interface LinearAnnotationSystem extends DrawingSystemDescriptor {
- *   item:   LinearAnnotation;
- *   data:   LinearAnnotationData;
- *   style:  LinearAnnotationStyle;
- *   handle: "pointA" | "pointB" | "offset";
- * }
- * class LinearAnnotations extends AnnotationSystem<LinearAnnotationSystem> { ... }
- * ```
- */
+/** "Type bag" descriptor that fully parameterises an annotation system. */
 export declare interface DrawingSystemDescriptor {
     item: {
         uuid: string;
@@ -2445,21 +2291,7 @@ export declare interface DrawingSystemDescriptor {
     handle: string;
 }
 
-/**
- * Represents a framed orthographic window into a {@link TechnicalDrawing}.
- *
- * The viewport lives in the drawing's local coordinate system (XZ plane, Y = 0).
- * Its {@link camera} must be added as a child of the drawing's container so that
- * any world-space transform applied to the container automatically moves the camera.
- *
- * The camera uses **layer 1** exclusively, so only geometry explicitly assigned
- * to layer 1 (projection lines, dimensions) is visible in paper-space renders.
- *
- * Local coordinate convention:
- * - X right → world +X
- * - Y up (screen) → world -Z
- * - Normal (out of plane) → world +Y
- */
+/** Represents a framed orthographic window into a {@link TechnicalDrawing}. */
 export declare class DrawingViewport {
     /** Unique identifier for this viewport instance. */
     readonly uuid: string;
@@ -2527,6 +2359,19 @@ export declare class DrawingViewport {
     get localYAxis(): THREE.Vector3;
     /** Drawing plane normal (world +Y). */
     get normal(): THREE.Vector3;
+    /**
+     * The viewport lives in the drawing's local coordinate system (XZ plane, Y = 0).
+     * Its {@link camera} must be added as a child of the drawing's container so that
+     * any world-space transform applied to the container automatically moves the camera.
+     *
+     * The camera uses **layer 1** exclusively, so only geometry explicitly assigned
+     * to layer 1 (projection lines, dimensions) is visible in paper-space renders.
+     *
+     * Local coordinate convention:
+     * - X right → world +X
+     * - Y up (screen) → world -Z
+     * - Normal (out of plane) → world +Y
+     */
     constructor(config: DrawingViewportConfig);
     /* Excluded from this release type: setContainer */
     /**
@@ -2567,44 +2412,7 @@ export declare interface DrawingViewportConfig {
     name?: string;
 }
 
-/**
- * Visualises the bounds of a `DrawingViewport` as a rectangle in the 3D scene.
- *
- * Works exactly like the built-in Three.js helpers (e.g. `THREE.CameraHelper`):
- * the result is a plain `THREE.Group` you can add wherever you like in the scene
- * graph.  It renders on **layer 0**, so it is visible to the perspective camera
- * but invisible to the viewport's own orthographic camera (which only renders
- * layer 1).
- *
- * Typically you do not construct this directly — use
- * `DrawingViewport.helperVisible = true` instead, which attaches the helper to
- * the drawing container automatically.
- *
- * When {@link editable} is `true`, two kinds of interaction are enabled:
- *
- * - **Resize** — hover one of the eight handle spheres (corners + edge midpoints)
- *   and drag to resize the viewport in that direction.
- * - **Move** — hover the border rectangle itself and drag to translate the
- *   entire viewport while keeping its width and height constant.
- *
- * In both cases the border and the hovered element turn orange as visual
- * feedback, and {@link isDragging} becomes `true` for the duration of the drag.
- *
- * The class contains no browser API references and is safe in Node.js
- * environments; the consumer forwards events:
- *
- * ```ts
- * container.addEventListener("mousemove", (e) => {
- *   raycaster.setFromCamera(getNDC(e), camera);
- *   viewport.helper.onPointerMove(raycaster.ray);
- * });
- * container.addEventListener("mousedown", (e) => {
- *   raycaster.setFromCamera(getNDC(e), camera);
- *   viewport.helper.onPointerDown(raycaster.ray);
- * });
- * container.addEventListener("mouseup", () => viewport.helper.onPointerUp());
- * ```
- */
+/** Visualises the bounds of a `DrawingViewport` as a rectangle in the 3D scene. */
 export declare class DrawingViewportHelper extends THREE.Group {
     private readonly _viewport;
     private readonly _border;
@@ -2637,6 +2445,42 @@ export declare class DrawingViewportHelper extends THREE.Group {
     set movable(value: boolean);
     /** `true` while either a resize or a move drag is in progress. */
     get isDragging(): boolean;
+    /**
+     * Works exactly like the built-in Three.js helpers (e.g. `THREE.CameraHelper`):
+     * the result is a plain `THREE.Group` you can add wherever you like in the scene
+     * graph.  It renders on **layer 0**, so it is visible to the perspective camera
+     * but invisible to the viewport's own orthographic camera (which only renders
+     * layer 1).
+     *
+     * Typically you do not construct this directly — use
+     * `DrawingViewport.helperVisible = true` instead, which attaches the helper to
+     * the drawing container automatically.
+     *
+     * When {@link editable} is `true`, two kinds of interaction are enabled:
+     *
+     * - **Resize** — hover one of the eight handle spheres (corners + edge midpoints)
+     *   and drag to resize the viewport in that direction.
+     * - **Move** — hover the border rectangle itself and drag to translate the
+     *   entire viewport while keeping its width and height constant.
+     *
+     * In both cases the border and the hovered element turn orange as visual
+     * feedback, and {@link isDragging} becomes `true` for the duration of the drag.
+     *
+     * The class contains no browser API references and is safe in Node.js
+     * environments; the consumer forwards events:
+     *
+     * ```ts
+     * container.addEventListener("mousemove", (e) => {
+     *   raycaster.setFromCamera(getNDC(e), camera);
+     *   viewport.helper.onPointerMove(raycaster.ray);
+     * });
+     * container.addEventListener("mousedown", (e) => {
+     *   raycaster.setFromCamera(getNDC(e), camera);
+     *   viewport.helper.onPointerDown(raycaster.ray);
+     * });
+     * container.addEventListener("mouseup", () => viewport.helper.onPointerUp());
+     * ```
+     */
     constructor(viewport: ViewportBoundsController);
     /**
      * Rebuilds the border geometry and repositions all handles to match the
@@ -2678,19 +2522,18 @@ export declare class DrawingViewportHelper extends THREE.Group {
     private _setBorderHover;
 }
 
-/**
- * Manages the viewports of a {@link TechnicalDrawing}.
- *
- * Accessible via `drawing.viewports`. Extends `DataMap` so consumers get
- * reactive events (`onItemSet`, `onBeforeDelete`, …) for free.
- *
- * ```ts
- * const vp = drawing.viewports.create({ left: -1, right: 5, top: 1, bottom: -4 });
- * drawing.viewports.delete(vp.uuid); // disposes and removes
- * ```
- */
+/** Manages the viewports of a {@link TechnicalDrawing}. */
 export declare class DrawingViewports extends FRAGS.DataMap<string, DrawingViewport> {
     private readonly _container;
+    /**
+     * Accessible via `drawing.viewports`. Extends `DataMap` so consumers get
+     * reactive events (`onItemSet`, `onBeforeDelete`, …) for free.
+     *
+     * ```ts
+     * const vp = drawing.viewports.create({ left: -1, right: 5, top: 1, bottom: -4 });
+     * drawing.viewports.delete(vp.uuid); // disposes and removes
+     * ```
+     */
     constructor(container: THREE.Group);
     /**
      * Creates a new {@link DrawingViewport}, adds its camera to the drawing
@@ -2708,16 +2551,7 @@ export declare interface DxfDrawingEntry {
     viewports: DxfViewportEntry[];
 }
 
-/**
- * Serializes {@link TechnicalDrawing} content to DXF format (AC1015 / AutoCAD R2000).
- *
- * Used through {@link DxfManager}:
- * ```ts
- * const dxf = components.get(OBC.DxfManager).exporter.export([
- *   { drawing, viewports: [{ viewport, x: 10, y: 10 }] },
- * ], { widthMm: 420, heightMm: 297, margin: 10 });
- * ```
- */
+/** Serializes {@link TechnicalDrawing} content to DXF format (AC1015 / AutoCAD R2000). */
 export declare class DxfExporter {
     private readonly _components;
     /** Decimal places used when formatting measurement text in DXF. */
@@ -2737,6 +2571,14 @@ export declare class DxfExporter {
     private _paperSlot;
     private readonly _annotationLayers;
     private readonly _systemExporters;
+    /**
+     * Used through {@link DxfManager}:
+     * ```ts
+     * const dxf = components.get(OBC.DxfManager).exporter.export([
+     *   { drawing, viewports: [{ viewport, x: 10, y: 10 }] },
+     * ], { widthMm: 420, heightMm: 297, margin: 10 });
+     * ```
+     */
     constructor(_components: Components);
     /**
      * Registers a custom DXF exporter for a {@link DrawingSystem} subclass.
@@ -2809,19 +2651,18 @@ export declare class DxfExporter {
     private _makeContext;
 }
 
-/**
- * Manages DXF import and export for technical drawings.
- *
- * ```ts
- * const manager = components.get(OBC.DxfManager);
- * const dxf = manager.exporter.export([{ drawing, viewports: [{ viewport }] }]);
- * ```
- */
+/** Manages DXF import and export for technical drawings. */
 export declare class DxfManager extends Component {
     static readonly uuid: "e9a2c3d4-5f67-4b89-a012-1c3d5e7f9b2a";
     enabled: boolean;
     /** Handles DXF serialisation of {@link TechnicalDrawing} content. */
     readonly exporter: DxfExporter;
+    /**
+     * ```ts
+     * const manager = components.get(OBC.DxfManager);
+     * const dxf = manager.exporter.export([{ drawing, viewports: [{ viewport }] }]);
+     * ```
+     */
     constructor(components: Components);
 }
 
@@ -2867,10 +2708,7 @@ export declare interface DxfWriteContext {
     textAngle(dx: number, dz: number): number;
 }
 
-/**
- * Result of an edge projection, containing visible/hidden geometries
- * and a mapping from group indices to model item identifiers.
- */
+/** Result of an edge projection, containing visible/hidden geometries and a mapping from group indices to model item identifiers. */
 export declare interface EdgeProjectionResult {
     /** Line segment geometry for visible edges. Has a `group` vertex attribute with group indices. */
     visible: THREE.BufferGeometry;
@@ -2883,11 +2721,7 @@ export declare interface EdgeProjectionResult {
     }>;
 }
 
-/**
- * Component that generates 2D edge projections from fragment model items.
- * It takes a ModelIdMap, converts items to meshes, and runs them through
- * the three-edge-projection library to produce visible/hidden line segment geometries.
- */
+/** Component that generates 2D edge projections from fragment model items. */
 export declare class EdgeProjector extends Component implements Disposable_2 {
     static readonly uuid: "f2e76c3a-8b1d-4d5e-9a3f-7c6b2d4e8f1a";
     enabled: boolean;
@@ -2942,14 +2776,7 @@ export declare class EdgeProjector extends Component implements Disposable_2 {
     dispose(): void;
 }
 
-/**
- * Defines a closed shape (cloud, rectangle, circle, etc.) that forms the
- * body of a callout annotation.
- *
- * `buildGeometry` returns flat XYZ triplet pairs suitable for `THREE.LineSegments`.
- * `getAttachmentPoint` returns the point on the enclosure boundary in the
- * given direction — needed because non-circular shapes have non-radial boundaries.
- */
+/** Defines a closed shape (cloud, rectangle, circle, etc.) that forms the body of a callout annotation. */
 export declare type EnclosureBuilder = {
     /** Returns flat XYZ line-segment pairs forming the enclosure outline. */
     buildGeometry: (center: THREE.Vector3, halfW: number, halfH: number) => number[];
@@ -3202,24 +3029,13 @@ export declare class FastModelPickers extends Component implements Disposable_2
     dispose(): void;
 }
 
-/**
- * Filled arrowhead tick (solid triangle, requires a `THREE.Mesh`).
- * Use this as `meshTick` on a style — pair with `NoTick` as `tick` if you
- * want only the filled shape and no line arrowhead.
- */
+/** Filled arrowhead tick (solid triangle, requires a `THREE.Mesh`). */
 export declare const FilledArrowTick: MeshTickBuilder;
 
-/**
- * Filled circle tick (solid disc, requires a `THREE.Mesh`).
- * The disc is centred on the endpoint and approximated with 16 triangles.
- */
+/** Filled circle tick (solid disc, requires a `THREE.Mesh`). */
 export declare const FilledCircleTick: MeshTickBuilder;
 
-/**
- * Filled square tick (solid square, requires a `THREE.Mesh`).
- * The square is centred on the endpoint and oriented along the dimension line.
- * Common in structural and steel drawings.
- */
+/** Filled square tick (solid square, requires a `THREE.Mesh`). */
 export declare const FilledSquareTick: MeshTickBuilder;
 
 /**
@@ -3309,9 +3125,21 @@ export declare class FirstPersonMode implements NavigationMode {
 export declare function formatSlope(slope: number, format: SlopeFormat): string;
 
 /**
- * Component to load, delete and manage [fragments](https://github.com/ThatOpen/engine_fragment) efficiently. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/FragmentsManager). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/FragmentsManager).
+ * Component to load, delete and manage [fragments](https://github.com/ThatOpen/engine_fragment) efficiently. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/FragmentsManager). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/FragmentsManager). Before calling {@link FragmentsManager.init}, you need a URL for the fragments worker. The recommended way to get it is {@link FragmentsManager.getWorker}, which fetches the version-matched worker from unpkg.
  */
 export declare class FragmentsManager extends Component implements Disposable_2 {
+    /**
+     * Returns a blob URL for the fragments worker matching the installed
+     * `@thatopen/fragments` version. Delegates to {@link FRAGS.FragmentsModels.getWorker}.
+     * This is the recommended way to obtain the URL passed to {@link FragmentsManager.init}.
+     *
+     * @example
+     * ```ts
+     * const fragments = components.get(OBC.FragmentsManager);
+     * fragments.init(await OBC.FragmentsManager.getWorker());
+     * ```
+     */
+    static getWorker(): Promise<string>;
     /**
      * A unique identifier for the component.
      * This UUID is used to register the component within the Components system.
@@ -3340,6 +3168,13 @@ export declare class FragmentsManager extends Component implements Disposable_2
     constructor(components: Components);
     /** {@link Disposable.dispose} */
     dispose(): void;
+    /**
+     * Initializes the fragments core with the given worker URL.
+     * The recommended way to obtain the URL is {@link FragmentsManager.getWorker}:
+     * ```ts
+     * fragments.init(await OBC.FragmentsManager.getWorker());
+     * ```
+     */
     init(workerURL: string, options?: {
         classicWorker?: boolean;
     }): void;
@@ -3395,20 +3230,13 @@ export declare class FragmentsManager extends Component implements Disposable_2
     applyBaseCoordinateSystem(object: THREE.Object3D | THREE.Vector3, originalCoordinateSystem?: THREE.Matrix4): THREE.Matrix4;
 }
 
-/**
- * Returns the tip position and inward tangent direction for each tick endpoint
- * of an angle dimension arc. Used by {@link AngleDimensions} to build
- * `meshTick` geometry.
- */
+/** Returns the tip position and inward tangent direction for each tick endpoint of an angle dimension arc. */
 export declare function getAngleTickEndpoints(dim: AngleAnnotation): Array<{
     tip: THREE.Vector3;
     dir: THREE.Vector3;
 }>;
 
-/**
- * Returns the tip position and inward direction for each tick endpoint of a
- * linear dimension. Used by {@link LinearDimensions} to build `meshTick` geometry.
- */
+/** Returns the tip position and inward direction for each tick endpoint of a linear dimension. */
 export declare function getDimensionTickEndpoints(dim: LinearAnnotation): Array<{
     tip: THREE.Vector3;
     dir: THREE.Vector3;
@@ -4065,10 +3893,7 @@ export declare class ItemsFinder extends Component implements Serializable<Seria
     };
 }
 
-/**
- * The committed data for a single leader annotation.
- * Stored in drawing local space (XZ plane, Y = 0).
- */
+/** The committed data for a single leader annotation. */
 export declare interface LeaderAnnotation {
     /** Unique identifier. */
     uuid: string;
@@ -4112,16 +3937,10 @@ export declare type LeaderAnnotationEvent =
     type: "ESCAPE";
 };
 
-/**
- * Pure state transition function for the leader annotation tool.
- * Returns the **same state reference** when no transition applies.
- */
+/** Pure state transition function for the leader annotation tool. */
 export declare function leaderAnnotationMachine(state: LeaderAnnotationState, event: LeaderAnnotationEvent): LeaderAnnotationState;
 
-/**
- * Global drawing system that manages leader (arrow + text) annotations across
- * all {@link TechnicalDrawing} instances.
- */
+/** Global drawing system that manages leader (arrow + text) annotations across all {@link TechnicalDrawing} instances. */
 export declare class LeaderAnnotations extends AnnotationSystem<LeaderAnnotationSystem> implements Transitionable<LeaderAnnotationState, LeaderAnnotationEvent>, Disposable_2 {
     enabled: boolean;
     readonly _item: LeaderAnnotation;
@@ -4212,10 +4031,7 @@ declare interface LeaderAnnotationSystem {
     handle: "elbow" | "extensionEnd";
 }
 
-/**
- * The committed data for a single linear annotation.
- * Stored in drawing local space (XZ plane, Y = 0).
- */
+/** The committed data for a single linear annotation. */
 export declare interface LinearAnnotation {
     /** Unique identifier. */
     uuid: string;
@@ -4279,10 +4095,7 @@ export declare type LinearAnnotationEvent =
     type: "ESCAPE";
 };
 
-/**
- * Global drawing system that manages linear dimension annotations across all
- * {@link TechnicalDrawing} instances.
- */
+/** Global drawing system that manages linear dimension annotations across all {@link TechnicalDrawing} instances. */
 export declare class LinearAnnotations extends AnnotationSystem<LinearAnnotationSystem> implements Transitionable<LinearAnnotationState, LinearAnnotationEvent>, Disposable_2 {
     enabled: boolean;
     readonly _item: LinearAnnotation;
@@ -4367,20 +4180,11 @@ declare interface LinearAnnotationSystem {
     handle: "pointA" | "pointB" | "offset";
 }
 
-/**
- * Pure state transition function for the linear dimension tool.
- *
- * Given the current state and an incoming event, returns the next state.
- * Returns the **same state reference** when no transition applies (caller can
- * skip re-renders with a `===` check).
- */
+/** Pure state transition function for the linear dimension tool. */
 export declare function linearDimensionMachine(state: LinearAnnotationState, event: LinearAnnotationEvent): LinearAnnotationState;
 
 /**
- * A function that produces tick mark geometry at one endpoint of a dimension
- * or leader line. Returns a flat array of XYZ triplets (vertex pairs for
- * `LineSegments`).
- *
+ * A function that produces tick mark geometry at one endpoint of a dimension or leader line.
  * @param tip     - The endpoint of the line (drawing local space).
  * @param lineDir - Normalised direction FROM `tip` TOWARD the other endpoint.
  * @param size    - Tick size in drawing local units.
@@ -4457,12 +4261,7 @@ export declare class MeasurementUtils extends Component {
 }
 
 /**
- * A function that produces filled tick mark geometry (triangles) at one
- * endpoint. Returns a flat array of XYZ triplets forming non-indexed triangles
- * for a `THREE.Mesh`.
- *
- * Same signature as {@link LineTickBuilder} — swap one for the other freely.
- *
+ * A function that produces filled tick mark geometry (triangles) at one endpoint.
  * @param tip     - The endpoint of the dimension or leader line.
  * @param lineDir - Normalised direction FROM `tip` TOWARD the other endpoint.
  * @param size    - Tick/arrow size in drawing local units.
@@ -4599,9 +4398,7 @@ export declare interface NoControl {
     value: any;
 }
 
-/**
- * No tick — dimension line ends cleanly at the extension lines.
- */
+/** No tick — dimension line ends cleanly at the extension lines. */
 export declare const NoTick: LineTickBuilder;
 
 export declare interface NumberSettingControl {
@@ -4827,10 +4624,7 @@ export declare class Raycasters extends Component implements Disposable_2 {
     dispose(): void;
 }
 
-/**
- * Rectangular enclosure — a plain axis-aligned rectangle centred on `center`.
- * Width = 2 × halfW, height = 2 × halfH.
- */
+/** Rectangular enclosure — a plain axis-aligned rectangle centred on `center`. */
 export declare const RectEnclosure: EnclosureBuilder;
 
 /**
@@ -5608,10 +5402,7 @@ export declare class SimpleWorld<T extends BaseScene = BaseScene, U extends Base
     dispose(disposeResources?: boolean): void;
 }
 
-/**
- * A single committed slope annotation.
- * All coordinates are in drawing local space (XZ plane, Y = 0).
- */
+/** A single committed slope annotation. */
 export declare interface SlopeAnnotation {
     /** Unique identifier. */
     uuid: string;
@@ -5631,19 +5422,17 @@ export declare interface SlopeAnnotation {
 /** Editable fields of {@link SlopeAnnotation} — everything except the `uuid`. */
 export declare type SlopeAnnotationData = Omit<SlopeAnnotation, "uuid">;
 
-/**
- * Global drawing system that manages slope annotations across all
- * {@link TechnicalDrawing} instances.
- *
- * Because slope data comes from the 3D model, there is no state machine.
- * Call {@link add} directly with the computed slope values:
- * ```ts
- * slopes.add(drawing, { position, direction, slope, style: "default" });
- * ```
- */
+/** Global drawing system that manages slope annotations across all {@link TechnicalDrawing} instances. */
 export declare class SlopeAnnotations extends AnnotationSystem<SlopeAnnotationSystem> implements Disposable_2 {
     enabled: boolean;
     readonly _item: SlopeAnnotation;
+    /**
+     * Because slope data comes from the 3D model, there is no state machine.
+     * Call {@link add} directly with the computed slope values:
+     * ```ts
+     * slopes.add(drawing, { position, direction, slope, style: "default" });
+     * ```
+     */
     constructor(components: Components);
     pickHandle(_drawing: TechnicalDrawing, _ray: THREE.Ray, _threshold?: number): {
         uuid: string;
@@ -5681,52 +5470,51 @@ declare interface SlopeAnnotationSystem {
 /** How the slope value is displayed in the text label. */
 export declare type SlopeFormat = "percentage" | "ratio" | "degrees";
 
-/**
- * A single technical drawing — the core spatial aggregate.
- *
- * Brings together:
- * - A {@link three} (`THREE.Group`) that anchors the drawing in world space.
- *   All 2D geometry (projection lines, dimensions) must be added as children of
- *   this group so they inherit its world transform.
- * - A collection of {@link viewports}, each defining an orthographic framing
- *   window and owning a camera that is itself a child of the container.
- *
- * Moving or rotating the container repositions the entire drawing — including
- * all its viewport cameras — in the 3D world without affecting any local
- * coordinates.
- *
- * ---
- *
- * ### Rotation convention
- *
- * The drawing projects geometry along its **local −Y axis**. The drawing
- * plane is the local **XZ plane** (Y = 0).
- *
- * When rotating `drawing.three`, two constraints must hold at the same time:
- *
- * 1. **Projection direction** — local −Y must point toward the surface you
- *    want to capture.
- * 2. **Text orientation** — local +X must point toward the right side of the
- *    screen when the drawing is viewed from the projection direction.
- *    Violating this causes annotations and dimension text to appear mirrored.
- *
- * For the six standard orthographic views, use {@link orientTo} — it enforces
- * both constraints with a single call:
- *
- * ```ts
- * drawing.orientTo(new THREE.Vector3(0, -1, 0)); // top / plan
- * drawing.orientTo(new THREE.Vector3(0,  0, -1)); // front elevation
- * ```
- *
- * ---
- *
- * Typically created via {@link TechnicalDrawings.create}.
- */
+/** A single technical drawing — the core spatial aggregate. */
 export declare class TechnicalDrawing {
     /** Unique identifier for this drawing instance. */
     readonly uuid: string;
     private readonly _raycaster;
     private readonly _components;
+    /**
+     * Brings together:
+     * - A {@link three} (`THREE.Group`) that anchors the drawing in world space.
+     *   All 2D geometry (projection lines, dimensions) must be added as children of
+     *   this group so they inherit its world transform.
+     * - A collection of {@link viewports}, each defining an orthographic framing
+     *   window and owning a camera that is itself a child of the container.
+     *
+     * Moving or rotating the container repositions the entire drawing — including
+     * all its viewport cameras — in the 3D world without affecting any local
+     * coordinates.
+     *
+     * ---
+     *
+     * ### Rotation convention
+     *
+     * The drawing projects geometry along its **local −Y axis**. The drawing
+     * plane is the local **XZ plane** (Y = 0).
+     *
+     * When rotating `drawing.three`, two constraints must hold at the same time:
+     *
+     * 1. **Projection direction** — local −Y must point toward the surface you
+     *    want to capture.
+     * 2. **Text orientation** — local +X must point toward the right side of the
+     *    screen when the drawing is viewed from the projection direction.
+     *    Violating this causes annotations and dimension text to appear mirrored.
+     *
+     * For the six standard orthographic views, use {@link orientTo} — it enforces
+     * both constraints with a single call:
+     *
+     * ```ts
+     * drawing.orientTo(new THREE.Vector3(0, -1, 0)); // top / plan
+     * drawing.orientTo(new THREE.Vector3(0,  0, -1)); // front elevation
+     * ```
+     *
+     * ---
+     *
+     * Typically created via {@link TechnicalDrawings.create}.
+     */
     constructor(components: Components);
     /**
      * The world that hosts this drawing. Set automatically by
@@ -5923,67 +5711,7 @@ export declare class TechnicalDrawing {
     dispose(): void;
 }
 
-/**
- * Visualises a {@link TechnicalDrawing}'s projection volume in the 3D scene
- * and exposes three gizmo anchors for interactive control.
- *
- * Works exactly like the built-in Three.js helpers (e.g. `THREE.CameraHelper`):
- * add it as a child of `drawing.three` so it inherits the drawing's world
- * transform automatically.
- *
- * It renders on **layer 0** — visible to the perspective camera, invisible to
- * the drawing's orthographic cameras (which only render layer 1).
- *
- * The helper draws three things:
- * - A rectangular frame on the drawing plane (Y = 0 in drawing local space).
- * - Four pillar lines dropping from each corner along the projection direction
- *   (local −Y) to the far boundary.
- * - A matching rectangle at the far boundary.
- *
- * ### Interactive control via gizmos
- *
- * Three `THREE.Object3D` anchors are exposed for `TransformControls`:
- *
- * | Anchor | Controls | Constrained axis |
- * |---|---|---|
- * | {@link farHandle} | `drawing.far` | local Y |
- * | {@link widthHandle} | {@link width} (symmetric) | local X |
- * | {@link heightHandle} | {@link height} (symmetric) | local Z |
- *
- * Use the corresponding `attach*Gizmo` methods instead of configuring the
- * gizmos manually — they enforce the correct axis constraints, local space,
- * and change listeners automatically:
- *
- * ```ts
- * const helper = new TechnicalDrawingHelper(drawing);
- * helper.width = 20;
- * helper.height = 15;
- * drawing.three.add(helper);
- *
- * // Main gizmo — full translate + rotate on drawing.three
- * const mainGizmo = new TransformControls(camera, domElement);
- * mainGizmo.attach(drawing.three);
- * scene.add(mainGizmo);
- *
- * // Depth gizmo — controls drawing.far
- * const farGizmo = new TransformControls(camera, domElement);
- * scene.add(farGizmo);
- * helper.attachFarGizmo(farGizmo);
- *
- * // Width gizmo
- * const widthGizmo = new TransformControls(camera, domElement);
- * scene.add(widthGizmo);
- * helper.attachWidthGizmo(widthGizmo);
- *
- * // Height gizmo
- * const heightGizmo = new TransformControls(camera, domElement);
- * scene.add(heightGizmo);
- * helper.attachHeightGizmo(heightGizmo);
- * ```
- *
- * Call {@link update} after changing {@link width}, {@link height}, or
- * `drawing.far` programmatically to rebuild the geometry.
- */
+/** Visualises a {@link TechnicalDrawing}'s projection volume in the 3D scene and exposes three gizmo anchors for interactive control. */
 export declare class TechnicalDrawingHelper extends THREE.Group {
     private readonly _drawing;
     private readonly _topFrame;
@@ -6024,6 +5752,64 @@ export declare class TechnicalDrawingHelper extends THREE.Group {
      * manipulate this object's position directly.
      */
     readonly heightHandle: THREE.Object3D<THREE.Object3DEventMap>;
+    /**
+     * Works exactly like the built-in Three.js helpers (e.g. `THREE.CameraHelper`):
+     * add it as a child of `drawing.three` so it inherits the drawing's world
+     * transform automatically.
+     *
+     * It renders on **layer 0** — visible to the perspective camera, invisible to
+     * the drawing's orthographic cameras (which only render layer 1).
+     *
+     * The helper draws three things:
+     * - A rectangular frame on the drawing plane (Y = 0 in drawing local space).
+     * - Four pillar lines dropping from each corner along the projection direction
+     *   (local −Y) to the far boundary.
+     * - A matching rectangle at the far boundary.
+     *
+     * ### Interactive control via gizmos
+     *
+     * Three `THREE.Object3D` anchors are exposed for `TransformControls`:
+     *
+     * | Anchor | Controls | Constrained axis |
+     * |---|---|---|
+     * | {@link farHandle} | `drawing.far` | local Y |
+     * | {@link widthHandle} | {@link width} (symmetric) | local X |
+     * | {@link heightHandle} | {@link height} (symmetric) | local Z |
+     *
+     * Use the corresponding `attach*Gizmo` methods instead of configuring the
+     * gizmos manually — they enforce the correct axis constraints, local space,
+     * and change listeners automatically:
+     *
+     * ```ts
+     * const helper = new TechnicalDrawingHelper(drawing);
+     * helper.width = 20;
+     * helper.height = 15;
+     * drawing.three.add(helper);
+     *
+     * // Main gizmo — full translate + rotate on drawing.three
+     * const mainGizmo = new TransformControls(camera, domElement);
+     * mainGizmo.attach(drawing.three);
+     * scene.add(mainGizmo);
+     *
+     * // Depth gizmo — controls drawing.far
+     * const farGizmo = new TransformControls(camera, domElement);
+     * scene.add(farGizmo);
+     * helper.attachFarGizmo(farGizmo);
+     *
+     * // Width gizmo
+     * const widthGizmo = new TransformControls(camera, domElement);
+     * scene.add(widthGizmo);
+     * helper.attachWidthGizmo(widthGizmo);
+     *
+     * // Height gizmo
+     * const heightGizmo = new TransformControls(camera, domElement);
+     * scene.add(heightGizmo);
+     * helper.attachHeightGizmo(heightGizmo);
+     * ```
+     *
+     * Call {@link update} after changing {@link width}, {@link height}, or
+     * `drawing.far` programmatically to rebuild the geometry.
+     */
     constructor(drawing: DrawingProjectionSource);
     /**
      * Rebuilds the helper geometry and repositions all gizmo anchors to match
@@ -6066,30 +5852,7 @@ export declare class TechnicalDrawingHelper extends THREE.Group {
     dispose(): void;
 }
 
-/**
- * OBC Component that creates and manages {@link TechnicalDrawing} instances.
- *
- * A TechnicalDrawing is a 2D drawing plane that lives in 3D world space.
- * It contains projection lines and dimension annotations (layer 1 geometry)
- * framed by one or more orthographic {@link DrawingViewport}s.
- *
- * The drawing's `container` (a `THREE.Group`) can be freely transformed in the
- * 3D world — all viewports and geometry move together as a single unit.
- *
- * @example
- * ```ts
- * const techDrawings = components.get(TechnicalDrawings);
- * const drawing = techDrawings.create(world);
- *
- * // Add layer-1 geometry to the drawing
- * const lines = new THREE.LineSegments(geometry, material);
- * lines.layers.set(1);
- * drawing.three.add(lines);
- *
- * // Add viewports
- * const vp = drawing.viewports.create({ left: -1, right: 5, top: 1, bottom: -4 });
- * ```
- */
+/** OBC Component that creates and manages {@link TechnicalDrawing} instances. */
 export declare class TechnicalDrawings extends Component implements Disposable_2 {
     /**
      * A unique identifier for the component.
@@ -6107,6 +5870,28 @@ export declare class TechnicalDrawings extends Component implements Disposable_2
     readonly systems: FRAGS.DataMap<Function, AnnotationSystem<any>>;
     /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event_2<unknown>;
+    /**
+     * A TechnicalDrawing is a 2D drawing plane that lives in 3D world space.
+     * It contains projection lines and dimension annotations (layer 1 geometry)
+     * framed by one or more orthographic {@link DrawingViewport}s.
+     *
+     * The drawing's `container` (a `THREE.Group`) can be freely transformed in the
+     * 3D world — all viewports and geometry move together as a single unit.
+     *
+     * @example
+     * ```ts
+     * const techDrawings = components.get(TechnicalDrawings);
+     * const drawing = techDrawings.create(world);
+     *
+     * // Add layer-1 geometry to the drawing
+     * const lines = new THREE.LineSegments(geometry, material);
+     * lines.layers.set(1);
+     * drawing.three.add(lines);
+     *
+     * // Add viewports
+     * const vp = drawing.viewports.create({ left: -1, right: 5, top: 1, bottom: -4 });
+     * ```
+     */
     constructor(components: Components);
     /**
      * Returns the global singleton instance of the given system, creating it if it
@@ -6280,9 +6065,6 @@ export declare class Topic implements BCFTopic {
 
 /**
  * Whether this component manages its interaction through an explicit state machine.
- * The machine is the single source of truth: the system can only be in one state at
- * a time, and every transition is deterministic given the current state and the event.
- *
  * @template TState - Discriminated union of all valid states (each with a `kind` string).
  * @template TEvent - Discriminated union of all accepted events (each with a `type` string).
  */
@@ -6302,13 +6084,7 @@ export declare interface Transitionable<TState extends {
     readonly onMachineStateChanged: Event_2<TState>;
 }
 
-/**
- * Built-in {@link DimensionUnit} presets.
- *
- * ```ts
- * style.unit = OBC.Units.mm;
- * ```
- */
+/** Built-in {@link DimensionUnit} presets. */
 export declare const Units: {
     readonly m: {
         readonly factor: 1;