@asymmetric-effort/specifyjs 0.2.98 → 0.2.100

package/dist/types/components/viz/2D-complex-graph/src/ComplexGraph2D.d.ts

@@ -0,0 +1,33 @@
+export interface ComplexPointInfo {
+    re: number;
+    im: number;
+    iterations: number;
+    event: Event;
+}
+export interface ComplexGraph2DProps {
+    width?: number;
+    height?: number;
+    realRange?: [number, number];
+    imagRange?: [number, number];
+    maxIterations?: number;
+    colorScheme?: "classic" | "fire" | "ocean";
+    computeFunction?: (re: number, im: number, maxIter: number) => number;
+    /** Precomputed iteration grid (rows x cols). When provided, renders as SVG
+     *  instead of canvas. Each value is the iteration count at that pixel. */
+    data?: number[][];
+    /** Pixel resolution for precomputed SVG rendering (default: 2) */
+    resolution?: number;
+    /** If true, compute values synchronously (blocks render).
+     *  Default: false — uses canvas useEffect for runtime computation. */
+    sync?: boolean;
+    onPointClick?: (info: ComplexPointInfo) => void;
+    onPointHover?: (info: ComplexPointInfo) => void;
+    onPointDoubleClick?: (info: ComplexPointInfo) => void;
+    onPointContextMenu?: (info: ComplexPointInfo) => void;
+}
+/**
+ * Precompute a Mandelbrot iteration grid at a given resolution.
+ * Returns a 2D array of iteration counts (rows x cols).
+ */
+export declare function computeMandelbrotGrid(cols: number, rows: number, realRange?: [number, number], imagRange?: [number, number], maxIter?: number, computeFn?: (re: number, im: number, maxIter: number) => number): number[][];
+export declare function ComplexGraph2D(props: ComplexGraph2DProps): import("specifyjs/shared/types").SpecElement<import("specifyjs/shared/types").Props>;

package/dist/types/components/viz/2D-complex-graph/src/index.d.ts

@@ -0,0 +1,2 @@
+export { ComplexGraph2D, computeMandelbrotGrid } from './ComplexGraph2D';
+export type { ComplexGraph2DProps, ComplexPointInfo } from './ComplexGraph2D';

package/dist/types/components/viz/2D-discrete-cartesian/src/DiscreteCartesian2D.d.ts

@@ -0,0 +1,31 @@
+export interface DiscreteCartesian2DProps {
+    /** Grid data: rows x cols. Each value maps to a color via colorMap. */
+    data: number[][];
+    /** Map cell values to colors (e.g., {0: '#1e293b', 1: '#3b82f6'}) */
+    colorMap?: Record<number, string>;
+    /** SVG viewBox width (default: 600) */
+    width?: number;
+    /** SVG viewBox height (default: 600) */
+    height?: number;
+    /** Gap between cells in pixels (default: 1) */
+    cellGap?: number;
+    /** Cell border radius (default: 0) */
+    cellRadius?: number;
+    /** Show grid lines (default: false) */
+    showGrid?: boolean;
+    /** Grid line color (default: '#334155') */
+    gridColor?: string;
+    /** Show row/column indices (default: false) */
+    showIndices?: boolean;
+    /** Background color (default: '#0f172a') */
+    backgroundColor?: string;
+    /** Padding around grid (default: 10) */
+    padding?: number;
+    /** Called when a cell is clicked: (row, col, value) */
+    onCellClick?: (row: number, col: number, value: number) => void;
+    /** Called when mouse enters a cell */
+    onCellHover?: (row: number, col: number, value: number) => void;
+    /** Title */
+    title?: string;
+}
+export declare function DiscreteCartesian2D(props: DiscreteCartesian2DProps): import("specifyjs/shared/types").SpecElement<import("specifyjs/shared/types").Props>;

package/dist/types/components/viz/2D-discrete-cartesian/src/index.d.ts

@@ -0,0 +1,2 @@
+export { DiscreteCartesian2D } from './DiscreteCartesian2D';
+export type { DiscreteCartesian2DProps } from './DiscreteCartesian2D';

package/dist/types/components/viz/2D-line-graph/src/LineGraph.d.ts

@@ -0,0 +1,53 @@
+/** Supported point marker shapes */
+export type PointShape = 'circle' | 'square' | 'diamond' | 'triangle' | 'triangle-down' | 'cross' | 'plus';
+export interface Point {
+    x: number;
+    y: number;
+    /** Per-point shape override */
+    shape?: PointShape;
+    /** Per-point radius override */
+    radius?: number;
+}
+export interface LineSeries {
+    data: Point[];
+    color: string;
+    label?: string;
+    /** Point shape for this series */
+    pointShape?: PointShape;
+    /** Point radius for this series */
+    pointRadius?: number;
+}
+export interface LineGraphProps {
+    data: Point[];
+    width?: number;
+    height?: number;
+    lineColor?: string;
+    lineWidth?: number;
+    pointRadius?: number;
+    pointColor?: string;
+    /** Default point marker shape (default: 'circle') */
+    pointShape?: PointShape;
+    showPoints?: boolean;
+    showGrid?: boolean;
+    showArea?: boolean;
+    areaColor?: string;
+    xLabel?: string;
+    yLabel?: string;
+    title?: string;
+    padding?: number;
+    animate?: boolean;
+    multiLine?: LineSeries[];
+}
+interface ScaleResult {
+    xScale: (v: number) => number;
+    yScale: (v: number) => number;
+    xTicks: number[];
+    yTicks: number[];
+    xMin: number;
+    xMax: number;
+    yMin: number;
+    yMax: number;
+}
+export declare function useLineGraphScales(data: Point[], width: number, height: number, padding: number): ScaleResult;
+export declare function LineGraph(props: LineGraphProps): import("specifyjs/shared/types").SpecElement<import("specifyjs/shared/types").Props>;
+export {};

package/dist/types/components/viz/2D-line-graph/src/index.d.ts

@@ -0,0 +1,2 @@
+export { LineGraph, useLineGraphScales } from './LineGraph';
+export type { LineGraphProps, LineSeries, Point, PointShape } from './LineGraph';

package/dist/types/components/viz/2D-pie-graph/src/PieGraph.d.ts

@@ -0,0 +1,49 @@
+import { type SpecElement } from '../../../../core/src/index';
+export interface PieSliceDatum {
+    label: string;
+    value: number;
+    color?: string;
+}
+export interface ComputedSlice {
+    label: string;
+    value: number;
+    startAngle: number;
+    endAngle: number;
+    percentage: number;
+    color: string;
+}
+export interface PieGraphProps {
+    data: PieSliceDatum[];
+    width?: number;
+    height?: number;
+    innerRadius?: number;
+    outerRadius?: number;
+    padAngle?: number;
+    showLabels?: boolean;
+    showValues?: boolean;
+    showLegend?: boolean;
+    legendPosition?: 'right' | 'bottom';
+    title?: string;
+    centerLabel?: string;
+    colors?: string[];
+    strokeColor?: string;
+    strokeWidth?: number;
+    textColor?: string;
+}
+/**
+ * Build an SVG path `d` string for an arc (or annular sector).
+ *
+ * Angles are in **radians**, measured clockwise from 12-o'clock
+ * (i.e. -PI/2 offset so 0 rad = top).
+ *
+ * Exported as a public utility so consumers can draw custom arcs.
+ */
+export declare function describeArc(cx: number, cy: number, innerR: number, outerR: number, startAngle: number, endAngle: number): string;
+/**
+ * Given raw data, compute start/end angles, percentages, and resolved colors.
+ */
+export declare function computeSlices(data: PieSliceDatum[], options?: {
+    padAngle?: number;
+    colors?: string[];
+}): ComputedSlice[];
+export declare function PieGraph(props: PieGraphProps): SpecElement;

package/dist/types/components/viz/2D-pie-graph/src/index.d.ts

@@ -0,0 +1,3 @@
+export { PieGraph } from './PieGraph';
+export { describeArc, computeSlices } from './PieGraph';
+export type { PieGraphProps, PieSliceDatum, ComputedSlice, } from './PieGraph';

package/dist/types/components/viz/2D-polar-graph/src/PolarGraph2D.d.ts

@@ -0,0 +1,35 @@
+export interface PolarPointInfo {
+    r: number;
+    theta: number;
+    index: number;
+    event: Event;
+}
+export interface PolarGraph2DProps {
+    width?: number;
+    height?: number;
+    rRange?: [number, number];
+    /** Function to plot: f(theta) → r */
+    plotFunction?: (theta: number) => number;
+    /** Number of samples around the full circle (default: 360). Ignored if thetaStep is set. */
+    plotResolution?: number;
+    /** Explicit step increment in radians for function evaluation (e.g., Math.PI/180).
+     *  When set, overrides plotResolution and computes f(theta) at
+     *  theta = 0, step, 2*step, ..., 2*PI. */
+    thetaStep?: number;
+    /** If true, compute plotFunction synchronously (blocks render).
+     *  Default: false — computes asynchronously. */
+    sync?: boolean;
+    points?: {
+        r: number;
+        theta: number;
+    }[];
+    showGrid?: boolean;
+    pointRadius?: number;
+    pointColor?: string;
+    curveColor?: string;
+    onPointClick?: (info: PolarPointInfo) => void;
+    onPointDoubleClick?: (info: PolarPointInfo) => void;
+    onPointContextMenu?: (info: PolarPointInfo) => void;
+    onPointHover?: (info: PolarPointInfo) => void;
+}
+export declare function PolarGraph2D(props: PolarGraph2DProps): import("specifyjs/shared/types").SpecElement<import("specifyjs/shared/types").Props>;

package/dist/types/components/viz/2D-polar-graph/src/index.d.ts

@@ -0,0 +1,2 @@
+export { PolarGraph2D } from './PolarGraph2D';
+export type { PolarGraph2DProps, PolarPointInfo } from './PolarGraph2D';

package/dist/types/components/viz/3d-layers/src/ThreeDLayers.d.ts

@@ -0,0 +1,35 @@
+export interface Layer3D {
+    label: string;
+    data: number[][];
+    color?: string;
+    opacity?: number;
+}
+export interface ThreeDLayersProps {
+    /** Array of layers, each containing a 2D grid of height values */
+    layers: Layer3D[];
+    /** SVG width in pixels (default: 700) */
+    width?: number;
+    /** SVG height in pixels (default: 500) */
+    height?: number;
+    /** Perspective strength (default: 0.5) — 0 = flat, 1 = strong perspective */
+    perspective?: number;
+    /** X-axis rotation in degrees (default: 35) */
+    rotateX?: number;
+    /** Y-axis rotation in degrees (default: 45) */
+    rotateY?: number;
+    /** Z-axis rotation in degrees (default: 0) */
+    rotateZ?: number;
+    /** Show layer labels (default: true) */
+    showLabels?: boolean;
+    /** Show 3D axes (default: true) */
+    showAxes?: boolean;
+    /** Vertical spacing between layers in data units (default: 2) */
+    layerSpacing?: number;
+    /** Color palette for layers (default: built-in palette) */
+    colorScale?: string[];
+    /** Grid wireframe color (default: '#94a3b8') */
+    gridColor?: string;
+    /** Chart title */
+    title?: string;
+}
+export declare function ThreeDLayers(props: ThreeDLayersProps): import("specifyjs/shared/types").SpecElement<import("specifyjs/shared/types").Props>;

package/dist/types/components/viz/3d-layers/src/index.d.ts

@@ -0,0 +1,2 @@
+export { ThreeDLayers } from './ThreeDLayers';
+export type { ThreeDLayersProps, Layer3D } from './ThreeDLayers';

package/dist/types/components/viz/3dSpace/src/Space3D.d.ts

@@ -0,0 +1,63 @@
+import type { Vec3 } from '../../../math/src/vec';
+import type { LightingModel } from './lighting-model';
+import type { ObjectPicker } from './types';
+import type { CameraControllerFn } from './camera-controller';
+import type { Light } from './light';
+import type { AnimationManager } from './animation';
+import type { BoundaryMode } from './bounds';
+import type { CollisionManager } from './collision';
+import { Camera } from './camera';
+import { Viewport } from './viewport';
+import { SceneGraph } from './scene-graph';
+import { SceneObject } from './scene-object';
+/** Props for the Space3D component. */
+export interface Space3DProps {
+    /** Width of the canvas in pixels. */
+    width: number;
+    /** Height of the canvas in pixels. */
+    height: number;
+    /** Whether space is finite (bounded). Default: true */
+    finiteSpace?: boolean;
+    /** Bounds for finite space. Objects and camera are clamped within. */
+    bounds?: {
+        min: Vec3;
+        max: Vec3;
+    };
+    /** Lighting model (default: FlatShading). */
+    lightingModel?: LightingModel;
+    /** Consumer animation function — called each frame with deltaTime in seconds. */
+    onFrame?: (deltaTime: number, scene: SceneGraph, cameras: Camera[]) => void;
+    /** Object picker (default: no-op). */
+    objectPicker?: ObjectPicker;
+    /** Cameras (consumer-defined). */
+    cameras?: Camera[];
+    /** Viewports mapped to cameras. */
+    viewports?: Viewport[];
+    /** Scene objects to register. */
+    objects?: SceneObject[];
+    /** Lights. */
+    lights?: Light[];
+    /** Show a 3D grid on the XZ plane for spatial reference. Default: false. */
+    showGrid?: boolean;
+    /** Grid size in world units (default: 20). */
+    gridSize?: number;
+    /** Grid divisions (default: 20). */
+    gridDivisions?: number;
+    /** Preferred renderer: 'webgl' | 'cpu' | 'auto' (default 'auto'). */
+    renderer?: 'webgl' | 'cpu' | 'auto';
+    /** Pluggable camera controller function, called each frame with camera, input state, and delta time. */
+    cameraController?: CameraControllerFn;
+    /** Animation manager for per-object animations */
+    animations?: AnimationManager;
+    /** Boundary behavior mode. Default: 'none' */
+    boundaryMode?: BoundaryMode;
+    /** Collision manager for detecting object intersections */
+    collisions?: CollisionManager;
+}
+/**
+ * Space3D — a SpecifyJS component that renders a 3D scene to a canvas.
+ *
+ * Assembles the render pipeline, scene graph, cameras, viewports, and
+ * runs a requestAnimationFrame loop for continuous rendering.
+ */
+export declare function Space3D(props: Space3DProps): import("specifyjs/shared/types").SpecElement<import("specifyjs/shared/types").Props>;

package/dist/types/components/viz/3dSpace/src/animation.d.ts

@@ -0,0 +1,75 @@
+import type { SceneObject } from './scene-object';
+/**
+ * Animation update function for a single scene object.
+ * Called each frame with the object, elapsed time, and delta time.
+ */
+export type AnimationFn = (object: SceneObject, totalTime: number, deltaTime: number) => void;
+/**
+ * An animation binding: associates an animation function with a scene object.
+ */
+export interface AnimationBinding {
+    /** The scene object to animate */
+    objectId: string;
+    /** The animation function to call each frame */
+    animate: AnimationFn;
+    /** Whether this animation is currently active. Default: true */
+    active?: boolean;
+}
+/**
+ * Animation manager that tracks and executes per-object animations.
+ */
+export declare class AnimationManager {
+    private bindings;
+    /**
+     * Register an animation for a scene object.
+     * If an animation already exists for this objectId, it is replaced.
+     */
+    register(binding: AnimationBinding): void;
+    /**
+     * Unregister an animation by object ID.
+     */
+    unregister(objectId: string): void;
+    /**
+     * Pause animation for a specific object.
+     */
+    pause(objectId: string): void;
+    /**
+     * Resume animation for a specific object.
+     */
+    resume(objectId: string): void;
+    /**
+     * Check if an object has an active animation.
+     */
+    isActive(objectId: string): boolean;
+    /**
+     * Get all registered binding IDs.
+     */
+    getRegisteredIds(): string[];
+    /**
+     * Execute all active animations for the given frame.
+     * Looks up each object in the scene graph by ID.
+     */
+    update(scene: {
+        getVisibleObjects(): SceneObject[];
+    }, totalTime: number, deltaTime: number): void;
+    /**
+     * Remove all bindings.
+     */
+    clear(): void;
+}
+/**
+ * Create a rotation animation around the Y axis.
+ */
+export declare function rotateY(radiansPerSecond: number): AnimationFn;
+/**
+ * Create a bobbing animation (up and down on Y axis).
+ */
+export declare function bob(amplitude: number, frequency: number, baseY?: number): AnimationFn;
+/**
+ * Create a circular orbit animation in the XZ plane.
+ */
+export declare function orbit(radius: number, speed: number, centerX?: number, centerZ?: number): AnimationFn;
+/**
+ * Compose multiple animations on the same object.
+ */
+export declare function compose(...fns: AnimationFn[]): AnimationFn;

package/dist/types/components/viz/3dSpace/src/bounds.d.ts

@@ -0,0 +1,36 @@
+import type { Vec3 } from '../../../math/src/vec';
+import type { SceneObject } from './scene-object';
+/**
+ * Boundary behavior when an object reaches the edge of finite space.
+ */
+export type BoundaryMode = 'none' | 'clamp' | 'wrap' | 'bounce' | 'destroy';
+/** Axis-aligned bounding box defined by min and max corners. */
+export interface SpaceBounds {
+    min: Vec3;
+    max: Vec3;
+}
+/** Clamp a position to stay within the given bounds. */
+export declare function clampToBounds(position: Vec3, bounds: {
+    min: Vec3;
+    max: Vec3;
+}): Vec3;
+/** Check if a position is within bounds. */
+export declare function isInBounds(position: Vec3, bounds: SpaceBounds): boolean;
+/** Compute the center of bounds. */
+export declare function boundsCenter(bounds: SpaceBounds): Vec3;
+/** Compute the size (extents) of bounds. */
+export declare function boundsSize(bounds: SpaceBounds): Vec3;
+/**
+ * Apply boundary behavior to a scene object's position.
+ *
+ * @param obj - The scene object to check
+ * @param bounds - The space boundaries
+ * @param mode - The boundary behavior mode
+ * @param velocity - Object velocity (required for 'bounce' mode, modified in-place)
+ * @returns true if the object should remain in the scene, false if it should be destroyed
+ */
+export declare function applyBoundary(obj: SceneObject, bounds: SpaceBounds, mode: BoundaryMode, velocity?: {
+    x: number;
+    y: number;
+    z: number;
+}): boolean;

package/dist/types/components/viz/3dSpace/src/camera-controller.d.ts

@@ -0,0 +1,59 @@
+import type { Camera } from './camera';
+/**
+ * Input state snapshot passed to camera controllers each frame.
+ */
+export interface InputState {
+    /** Currently pressed keys (Set of key names, e.g., 'ArrowUp', 'w', 'Shift') */
+    keysDown: Set<string>;
+    /** Mouse position relative to canvas (pixels) */
+    mouseX: number;
+    mouseY: number;
+    /** Mouse button state */
+    mouseLeft: boolean;
+    mouseRight: boolean;
+    mouseMiddle: boolean;
+    /** Mouse movement since last frame (pixels) */
+    mouseDeltaX: number;
+    mouseDeltaY: number;
+    /** Scroll wheel delta */
+    scrollDelta: number;
+}
+/**
+ * Consumer-provided camera controller function.
+ * Called each frame with the current input state, camera, and delta time.
+ * The function should modify the camera's position and orientation.
+ */
+export type CameraControllerFn = (camera: Camera, input: InputState, deltaTime: number) => void;
+/**
+ * Create an InputState tracker that listens to keyboard, mouse, and wheel events
+ * on a canvas element. Returns the current state and a cleanup function.
+ */
+export declare function createInputTracker(canvas: HTMLCanvasElement): {
+    state: InputState;
+    cleanup: () => void;
+};
+/**
+ * Reset per-frame deltas. Call at the end of each frame.
+ */
+export declare function resetFrameDeltas(state: InputState): void;
+/**
+ * Orbit controller: left-drag to orbit around a target, scroll to zoom.
+ */
+export declare function orbitController(target: {
+    x: number;
+    y: number;
+    z: number;
+}, options?: {
+    orbitSpeed?: number;
+    zoomSpeed?: number;
+    minDist?: number;
+    maxDist?: number;
+}): CameraControllerFn;
+/**
+ * Fly controller: WASD + mouse look, arrow keys for strafe.
+ * Like a free-flying camera in space.
+ */
+export declare function flyController(options?: {
+    moveSpeed?: number;
+    lookSpeed?: number;
+}): CameraControllerFn;

package/dist/types/components/viz/3dSpace/src/camera.d.ts

@@ -0,0 +1,43 @@
+import type { Vec3 } from '../../../math/src/vec';
+import type { Mat4, Quaternion } from './types';
+/** Projection mode for the camera. */
+export type ProjectionMode = 'perspective' | 'orthographic';
+/** Camera for viewing a 3D scene. */
+export declare class Camera {
+    position: Vec3;
+    orientation: Quaternion;
+    projectionMode: ProjectionMode;
+    fov: number;
+    aspect: number;
+    near: number;
+    far: number;
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+    constructor(options?: {
+        position?: Vec3;
+        orientation?: Quaternion;
+        projectionMode?: ProjectionMode;
+        fov?: number;
+        aspect?: number;
+        near?: number;
+        far?: number;
+        left?: number;
+        right?: number;
+        top?: number;
+        bottom?: number;
+    });
+    /** Compute the view matrix from camera position and orientation. */
+    getViewMatrix(): Mat4;
+    /** Compute the projection matrix based on the current projection mode. */
+    getProjectionMatrix(): Mat4;
+    /** Move the camera by a delta vector. */
+    move(delta: Vec3): void;
+    /** Rotate the camera by multiplying a quaternion. */
+    rotate(q: Quaternion): void;
+    /** Orient the camera to look at a target position. */
+    lookAt(target: Vec3): void;
+    private perspectiveMatrix;
+    private orthographicMatrix;
+}

package/dist/types/components/viz/3dSpace/src/collision.d.ts

@@ -0,0 +1,54 @@
+import type { Vec3 } from '../../../math/src/vec';
+import type { SceneObject } from './scene-object';
+/** Collision detection method */
+export type ColliderType = 'sphere' | 'aabb';
+/** Information about a detected collision */
+export interface CollisionInfo {
+    objectA: SceneObject;
+    objectB: SceneObject;
+    /** Overlap distance (penetration depth) */
+    overlap: number;
+    /** Collision normal (from A toward B) */
+    normal: Vec3;
+    /** Contact point (approximate midpoint of overlap) */
+    contactPoint: Vec3;
+}
+/** Consumer-provided collision response function */
+export type CollisionResponse = (info: CollisionInfo) => void;
+/** Compute bounding sphere radius from mesh vertices */
+export declare function computeBoundingSphereRadius(obj: SceneObject): number;
+/** Axis-aligned bounding box */
+export interface AABB {
+    min: Vec3;
+    max: Vec3;
+}
+/** Compute AABB from mesh vertices in world space */
+export declare function computeAABB(obj: SceneObject): AABB;
+/** Test sphere-sphere overlap. Returns CollisionInfo or null. */
+export declare function sphereSphereTest(a: SceneObject, b: SceneObject): CollisionInfo | null;
+/** Test AABB-AABB overlap. Returns CollisionInfo or null. */
+export declare function aabbTest(a: SceneObject, b: SceneObject): CollisionInfo | null;
+/**
+ * CollisionManager detects collisions between registered objects
+ * each frame and calls the consumer's response function.
+ */
+export declare class CollisionManager {
+    private colliderType;
+    private response;
+    private pairs;
+    constructor(options?: {
+        colliderType?: ColliderType;
+        response?: CollisionResponse;
+    });
+    /** Update the collision response function */
+    setResponse(fn: CollisionResponse): void;
+    /** Update the collider type */
+    setColliderType(type: ColliderType): void;
+    /** Get active collision pair keys from last frame */
+    getActivePairs(): string[];
+    /**
+     * Check all object pairs for collisions.
+     * Call this once per frame with the visible objects.
+     */
+    update(objects: SceneObject[]): CollisionInfo[];
+}

package/dist/types/components/viz/3dSpace/src/cpu-pipeline.d.ts

@@ -0,0 +1,47 @@
+import type { RenderPipeline } from './render-pipeline';
+import type { SceneGraph } from './scene-graph';
+import type { Camera } from './camera';
+import type { Viewport } from './viewport';
+import type { LightingModel } from './lighting-model';
+import type { Light } from './light';
+import type { SpaceBounds } from './bounds';
+/**
+ * CPU-based software render pipeline.
+ * Renders 3D scenes to a Canvas 2D context using the painter's algorithm
+ * and canvas path fills for triangle rasterization.
+ */
+export declare class CpuPipeline implements RenderPipeline {
+    readonly name = "cpu";
+    private ctx;
+    initialize(canvas: HTMLCanvasElement): void;
+    dispose(): void;
+    render(scene: SceneGraph, camera: Camera, viewport: Viewport, lighting: LightingModel, lights?: Light[]): void;
+    /**
+     * Render wireframe edges (black outlines) for all visible scene objects.
+     * Call after render() to overlay edges on the filled triangles.
+     */
+    renderEdges(scene: SceneGraph, camera: Camera, viewport: Viewport, options?: {
+        color?: string;
+        lineWidth?: number;
+        opacity?: number;
+    }): void;
+    /**
+     * Render a 3D grid on the XZ plane at y=0.
+     * Call this after render() to overlay the grid on top of the scene
+     * (or before render() to draw it behind — painter's order).
+     */
+    renderGrid(camera: Camera, viewport: Viewport, options?: {
+        size?: number;
+        divisions?: number;
+        color?: string;
+        opacity?: number;
+    }): void;
+    /**
+     * Render a wireframe bounding box showing space boundaries.
+     * Draws the 12 edges of the box projected through the camera.
+     */
+    renderBounds(camera: Camera, viewport: Viewport, bounds: SpaceBounds, options?: {
+        color?: string;
+        opacity?: number;
+    }): void;
+}