blecsd 0.1.0

package/dist/index-zSGJ2eUk.d.ts

@@ -0,0 +1,3156 @@
+import { z } from 'zod';
+import { W as World, E as Entity, S as System } from './types-BcsvoKzf.js';
+import { A as Animation3DConfig, C as Camera3DConfig, M as Material3DConfig, a as MouseInteraction3DConfig, T as Transform3DConfig, V as Viewport3DConfig, b as Animation3DConfigSchema, c as Camera3DConfigSchema, d as Material3DConfigSchema, e as MouseInteraction3DConfigSchema, f as Transform3DConfigSchema, g as Viewport3DConfigSchema, h as Viewport3DWidgetConfig, i as Viewport3DWidgetConfigSchema } from './viewport3d-xI33-_wq.js';
+
+/**
+ * Zod schemas for 3D renderer backend configuration.
+ *
+ * @module 3d/schemas/backends
+ */
+
+/**
+ * Supported backend rendering types.
+ *
+ * @example
+ * ```typescript
+ * const type = BackendTypeSchema.parse('braille'); // Valid
+ * BackendTypeSchema.parse('invalid'); // Throws
+ * ```
+ */
+declare const BackendTypeSchema: z.ZodEnum<{
+    braille: "braille";
+    halfblock: "halfblock";
+    sextant: "sextant";
+    sixel: "sixel";
+    kitty: "kitty";
+}>;
+type BackendType = z.infer<typeof BackendTypeSchema>;
+/**
+ * Capabilities descriptor for a rendering backend.
+ *
+ * @example
+ * ```typescript
+ * const caps = BackendCapabilitiesSchema.parse({
+ *   maxColors: 2,
+ *   supportsAlpha: false,
+ *   pixelsPerCellX: 2,
+ *   pixelsPerCellY: 4,
+ *   supportsAnimation: false,
+ *   requiresEscapeSequences: false,
+ * });
+ * ```
+ */
+declare const BackendCapabilitiesSchema: z.ZodObject<{
+    maxColors: z.ZodNumber;
+    supportsAlpha: z.ZodBoolean;
+    pixelsPerCellX: z.ZodNumber;
+    pixelsPerCellY: z.ZodNumber;
+    supportsAnimation: z.ZodBoolean;
+    requiresEscapeSequences: z.ZodBoolean;
+}, z.core.$strip>;
+type BackendCapabilities = z.infer<typeof BackendCapabilitiesSchema>;
+/**
+ * A single encoded terminal cell for cell-based backends.
+ *
+ * @example
+ * ```typescript
+ * const cell = EncodedCellSchema.parse({ x: 0, y: 0, char: '⠿', fg: 0xffffff, bg: 0x000000 });
+ * ```
+ */
+declare const EncodedCellSchema: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    char: z.ZodString;
+    fg: z.ZodNumber;
+    bg: z.ZodNumber;
+}, z.core.$strip>;
+type EncodedCell = z.infer<typeof EncodedCellSchema>;
+/**
+ * Output from a renderer backend encode pass.
+ *
+ * Cell-based backends (braille, halfblock, sextant) produce `cells`.
+ * Escape-based backends (sixel, kitty) produce `escape` strings.
+ * At least one of `cells` or `escape` must be present.
+ *
+ * @example
+ * ```typescript
+ * // Cell-based output
+ * const cellOutput: EncodedOutput = { cells: [{ x: 0, y: 0, char: '⠿', fg: 0xffffff, bg: 0 }] };
+ *
+ * // Escape-based output
+ * const escapeOutput: EncodedOutput = { escape: '\x1bPq...', cursorX: 0, cursorY: 0 };
+ * ```
+ */
+declare const EncodedOutputSchema: z.ZodObject<{
+    cells: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        char: z.ZodString;
+        fg: z.ZodNumber;
+        bg: z.ZodNumber;
+    }, z.core.$strip>>>;
+    escape: z.ZodOptional<z.ZodString>;
+    cursorX: z.ZodOptional<z.ZodNumber>;
+    cursorY: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type EncodedOutput = z.infer<typeof EncodedOutputSchema>;
+/**
+ * Backend selection: a specific type or 'auto' for capability-based detection.
+ *
+ * @example
+ * ```typescript
+ * const sel = BackendSelectionSchema.parse('auto'); // Valid
+ * const sel2 = BackendSelectionSchema.parse('sixel'); // Valid
+ * ```
+ */
+declare const BackendSelectionSchema: z.ZodUnion<readonly [z.ZodEnum<{
+    braille: "braille";
+    halfblock: "halfblock";
+    sextant: "sextant";
+    sixel: "sixel";
+    kitty: "kitty";
+}>, z.ZodLiteral<"auto">]>;
+type BackendSelection = z.infer<typeof BackendSelectionSchema>;
+/**
+ * Configuration for the braille rendering backend.
+ *
+ * @example
+ * ```typescript
+ * const config = BrailleConfigSchema.parse({ threshold: 64, colorMode: 'dominant' });
+ * ```
+ */
+declare const BrailleConfigSchema: z.ZodObject<{
+    threshold: z.ZodDefault<z.ZodNumber>;
+    colorMode: z.ZodDefault<z.ZodEnum<{
+        average: "average";
+        dominant: "dominant";
+        brightness: "brightness";
+    }>>;
+    backgroundColor: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+type BrailleConfig = z.input<typeof BrailleConfigSchema>;
+/**
+ * Configuration for the half-block rendering backend.
+ *
+ * @example
+ * ```typescript
+ * const config = HalfBlockConfigSchema.parse({});
+ * ```
+ */
+declare const HalfBlockConfigSchema: z.ZodObject<{
+    backgroundColor: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+type HalfBlockConfig = z.input<typeof HalfBlockConfigSchema>;
+/**
+ * Configuration for the sextant rendering backend.
+ *
+ * @example
+ * ```typescript
+ * const config = SextantConfigSchema.parse({ threshold: 100 });
+ * ```
+ */
+declare const SextantConfigSchema: z.ZodObject<{
+    threshold: z.ZodDefault<z.ZodNumber>;
+    backgroundColor: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+type SextantConfig = z.input<typeof SextantConfigSchema>;
+/**
+ * Configuration for the sixel rendering backend.
+ *
+ * @example
+ * ```typescript
+ * const config = SixelConfigSchema.parse({ maxColors: 64 });
+ * ```
+ */
+declare const SixelConfigSchema: z.ZodObject<{
+    maxColors: z.ZodDefault<z.ZodNumber>;
+    rleEnabled: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+type SixelConfig = z.input<typeof SixelConfigSchema>;
+/**
+ * Configuration for the Kitty Graphics Protocol rendering backend.
+ *
+ * @example
+ * ```typescript
+ * const config = KittyConfigSchema.parse({ imageId: 42 });
+ * ```
+ */
+declare const KittyConfigSchema: z.ZodObject<{
+    imageId: z.ZodDefault<z.ZodNumber>;
+    chunkSize: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+type KittyConfig = z.input<typeof KittyConfigSchema>;
+/**
+ * Backend selection preferences for auto-detection.
+ *
+ * @example
+ * ```typescript
+ * const pref = BackendPreferenceSchema.parse({ preferred: 'auto', fallback: 'braille' });
+ * ```
+ */
+declare const BackendPreferenceSchema: z.ZodObject<{
+    preferred: z.ZodDefault<z.ZodUnion<readonly [z.ZodEnum<{
+        braille: "braille";
+        halfblock: "halfblock";
+        sextant: "sextant";
+        sixel: "sixel";
+        kitty: "kitty";
+    }>, z.ZodLiteral<"auto">]>>;
+    fallback: z.ZodDefault<z.ZodEnum<{
+        braille: "braille";
+        halfblock: "halfblock";
+        sextant: "sextant";
+        sixel: "sixel";
+        kitty: "kitty";
+    }>>;
+    forceBackend: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+type BackendPreference = z.input<typeof BackendPreferenceSchema>;
+
+/**
+ * Zod schemas for the pixel rasterizer subsystem.
+ * @module 3d/schemas/rasterizer
+ */
+
+/**
+ * Configuration for creating a pixel framebuffer.
+ *
+ * @example
+ * ```typescript
+ * const config = PixelBufferConfigSchema.parse({ width: 400, height: 200 });
+ * ```
+ */
+declare const PixelBufferConfigSchema: z.ZodObject<{
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+    enableDepthBuffer: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+type PixelBufferConfig = z.input<typeof PixelBufferConfigSchema>;
+/**
+ * An RGBA color with components in the range [0, 255].
+ *
+ * @example
+ * ```typescript
+ * const red = RGBAColorSchema.parse({ r: 255, g: 0, b: 0 });
+ * // red.a defaults to 255
+ * ```
+ */
+/**
+ * A line endpoint with position, optional depth, and color.
+ *
+ * @example
+ * ```typescript
+ * const endpoint = LineEndpointSchema.parse({ x: 10, y: 20, r: 255, g: 0, b: 0 });
+ * ```
+ */
+declare const LineEndpointSchema: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    depth: z.ZodOptional<z.ZodNumber>;
+    r: z.ZodNumber;
+    g: z.ZodNumber;
+    b: z.ZodNumber;
+    a: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+type LineEndpoint = z.input<typeof LineEndpointSchema>;
+declare const RGBAColorSchema: z.ZodObject<{
+    r: z.ZodNumber;
+    g: z.ZodNumber;
+    b: z.ZodNumber;
+    a: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+type RGBAColor = z.infer<typeof RGBAColorSchema>;
+/**
+ * A triangle vertex with position, depth, and color.
+ *
+ * @example
+ * ```typescript
+ * const vertex = TriangleVertexSchema.parse({ x: 10, y: 20, depth: 0.5, r: 255, g: 0, b: 0 });
+ * ```
+ */
+declare const TriangleVertexSchema: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    depth: z.ZodNumber;
+    r: z.ZodNumber;
+    g: z.ZodNumber;
+    b: z.ZodNumber;
+    a: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+type TriangleVertex = z.input<typeof TriangleVertexSchema>;
+/**
+ * A directional light source for flat shading.
+ *
+ * @example
+ * ```typescript
+ * const light = DirectionalLightSchema.parse({
+ *   direction: [0, -1, 0],
+ *   intensity: 0.8,
+ * });
+ * ```
+ */
+declare const DirectionalLightSchema: z.ZodObject<{
+    direction: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+    intensity: z.ZodDefault<z.ZodNumber>;
+    color: z.ZodOptional<z.ZodObject<{
+        r: z.ZodNumber;
+        g: z.ZodNumber;
+        b: z.ZodNumber;
+        a: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type DirectionalLight = z.input<typeof DirectionalLightSchema>;
+/**
+ * An ambient light for baseline illumination.
+ *
+ * @example
+ * ```typescript
+ * const ambient = AmbientLightSchema.parse({ intensity: 0.2 });
+ * ```
+ */
+declare const AmbientLightSchema: z.ZodObject<{
+    intensity: z.ZodDefault<z.ZodNumber>;
+    color: z.ZodOptional<z.ZodObject<{
+        r: z.ZodNumber;
+        g: z.ZodNumber;
+        b: z.ZodNumber;
+        a: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type AmbientLight = z.input<typeof AmbientLightSchema>;
+
+/**
+ * RGBA pixel framebuffer with optional depth buffer for 3D rasterization.
+ *
+ * All backends consume this intermediate format. The rasterizer writes to it,
+ * and encoding backends read from it to produce terminal output.
+ *
+ * @module 3d/rasterizer/pixelBuffer
+ */
+
+/**
+ * An RGBA pixel framebuffer with optional depth buffer.
+ *
+ * @example
+ * ```typescript
+ * const fb = createPixelFramebuffer({ width: 400, height: 200 });
+ * setPixel(fb, 10, 20, { r: 255, g: 0, b: 0, a: 255 });
+ * const pixel = getPixel(fb, 10, 20);
+ * ```
+ */
+interface PixelFramebuffer {
+    readonly width: number;
+    readonly height: number;
+    readonly colorBuffer: Uint8ClampedArray;
+    readonly depthBuffer: Float32Array | null;
+}
+/**
+ * Create a new pixel framebuffer. Config is validated via Zod.
+ *
+ * @param config - Buffer dimensions and depth buffer toggle
+ * @returns A new framebuffer with cleared color and depth buffers
+ *
+ * @example
+ * ```typescript
+ * const fb = createPixelFramebuffer({ width: 400, height: 200, enableDepthBuffer: true });
+ * ```
+ */
+declare function createPixelFramebuffer(config: PixelBufferConfig): PixelFramebuffer;
+/**
+ * Clear the framebuffer to a solid color and reset depth values.
+ * Mutates the framebuffer in place for performance (hot path).
+ *
+ * @param fb - Framebuffer to clear
+ * @param color - Clear color (defaults to transparent black)
+ * @param depth - Clear depth value (defaults to 1.0, far plane)
+ *
+ * @example
+ * ```typescript
+ * clearFramebuffer(fb, { r: 0, g: 0, b: 0, a: 255 });
+ * ```
+ */
+declare function clearFramebuffer(fb: PixelFramebuffer, color?: RGBAColor, depth?: number): void;
+/**
+ * Check if coordinates are within framebuffer bounds.
+ *
+ * @param fb - Framebuffer to check against
+ * @param x - X coordinate
+ * @param y - Y coordinate
+ * @returns True if (x, y) is within bounds
+ *
+ * @example
+ * ```typescript
+ * if (isInBounds(fb, x, y)) {
+ *   setPixel(fb, x, y, color);
+ * }
+ * ```
+ */
+declare function isInBounds(fb: PixelFramebuffer, x: number, y: number): boolean;
+/**
+ * Get the RGBA color at the specified pixel. Returns a copy.
+ * Returns transparent black for out-of-bounds coordinates.
+ *
+ * @param fb - Framebuffer to read from
+ * @param x - X coordinate
+ * @param y - Y coordinate
+ * @returns RGBA color at the pixel
+ *
+ * @example
+ * ```typescript
+ * const color = getPixel(fb, 10, 20);
+ * console.log(color.r, color.g, color.b, color.a);
+ * ```
+ */
+declare function getPixel(fb: PixelFramebuffer, x: number, y: number): RGBAColor;
+/**
+ * Set the RGBA color at the specified pixel. Bounds-checked (no-op if out of bounds).
+ *
+ * @param fb - Framebuffer to write to
+ * @param x - X coordinate
+ * @param y - Y coordinate
+ * @param color - RGBA color to set
+ *
+ * @example
+ * ```typescript
+ * setPixel(fb, 10, 20, { r: 255, g: 0, b: 0, a: 255 });
+ * ```
+ */
+declare function setPixel(fb: PixelFramebuffer, x: number, y: number, color: RGBAColor): void;
+/**
+ * Set pixel color without bounds checking. Use only in inner loops where
+ * bounds have already been verified.
+ *
+ * @param fb - Framebuffer to write to
+ * @param x - X coordinate (must be in bounds)
+ * @param y - Y coordinate (must be in bounds)
+ * @param r - Red component (0-255)
+ * @param g - Green component (0-255)
+ * @param b - Blue component (0-255)
+ * @param a - Alpha component (0-255)
+ *
+ * @example
+ * ```typescript
+ * // Only use when bounds are guaranteed
+ * if (isInBounds(fb, x, y)) {
+ *   setPixelUnsafe(fb, x, y, 255, 0, 0, 255);
+ * }
+ * ```
+ */
+declare function setPixelUnsafe(fb: PixelFramebuffer, x: number, y: number, r: number, g: number, b: number, a: number): void;
+/**
+ * Get the depth value at the specified pixel.
+ * Returns 1.0 (far plane) for out-of-bounds or if no depth buffer exists.
+ *
+ * @param fb - Framebuffer to read from
+ * @param x - X coordinate
+ * @param y - Y coordinate
+ * @returns Depth value at the pixel (0.0 = near, 1.0 = far)
+ *
+ * @example
+ * ```typescript
+ * const depth = getDepth(fb, 10, 20);
+ * ```
+ */
+declare function getDepth(fb: PixelFramebuffer, x: number, y: number): number;
+/**
+ * Test if a pixel passes the depth test (closer than current depth) and
+ * update the depth buffer if it passes.
+ *
+ * @param fb - Framebuffer with depth buffer
+ * @param x - X coordinate
+ * @param y - Y coordinate
+ * @param depth - Depth value to test (0.0 = near, 1.0 = far)
+ * @returns True if the depth test passed and the value was written
+ *
+ * @example
+ * ```typescript
+ * if (testAndSetDepth(fb, x, y, 0.5)) {
+ *   setPixelUnsafe(fb, x, y, 255, 0, 0, 255);
+ * }
+ * ```
+ */
+declare function testAndSetDepth(fb: PixelFramebuffer, x: number, y: number, depth: number): boolean;
+/**
+ * Fill a rectangular region with a solid color. Clips to framebuffer bounds.
+ *
+ * @param fb - Framebuffer to write to
+ * @param x - Left edge X coordinate
+ * @param y - Top edge Y coordinate
+ * @param w - Width of the rectangle
+ * @param h - Height of the rectangle
+ * @param color - Fill color
+ *
+ * @example
+ * ```typescript
+ * fillRect(fb, 10, 10, 50, 30, { r: 0, g: 255, b: 0, a: 255 });
+ * ```
+ */
+declare function fillRect(fb: PixelFramebuffer, x: number, y: number, w: number, h: number, color: RGBAColor): void;
+
+/**
+ * Renderer backend interface and supporting types.
+ *
+ * All backends implement RendererBackend, converting a PixelFramebuffer
+ * into terminal output (either cells for cell-based backends or escape
+ * sequences for pixel-protocol backends).
+ *
+ * @module 3d/backends/types
+ */
+
+/**
+ * Interface that all renderer backends must implement.
+ *
+ * Cell-based backends (braille, halfblock, sextant) return `cells` in their
+ * EncodedOutput. Escape-based backends (sixel, kitty) return `escape` strings.
+ *
+ * @example
+ * ```typescript
+ * const backend: RendererBackend = createBrailleBackend();
+ * const dims = backend.getPixelDimensions(60, 20);
+ * const fb = createPixelFramebuffer({ width: dims.width, height: dims.height });
+ * // ... rasterize to fb ...
+ * const output = backend.encode(fb, 0, 0);
+ * ```
+ */
+interface RendererBackend {
+    /** The backend type identifier. */
+    readonly type: BackendType;
+    /** Capabilities descriptor for this backend. */
+    readonly capabilities: BackendCapabilities;
+    /**
+     * Encode a pixel framebuffer into terminal output.
+     *
+     * @param framebuffer - The pixel buffer to encode
+     * @param screenX - Terminal column offset for output placement
+     * @param screenY - Terminal row offset for output placement
+     * @returns Encoded output (cells or escape sequences)
+     */
+    encode(framebuffer: PixelFramebuffer, screenX: number, screenY: number): EncodedOutput;
+    /**
+     * Calculate pixel dimensions for a given terminal cell region.
+     *
+     * @param cellWidth - Number of terminal columns
+     * @param cellHeight - Number of terminal rows
+     * @returns Pixel dimensions the framebuffer should be created with
+     */
+    getPixelDimensions(cellWidth: number, cellHeight: number): {
+        width: number;
+        height: number;
+    };
+}
+
+/**
+ * Braille-dot rendering backend.
+ *
+ * Maps 2x4 pixel blocks to Unicode braille characters (U+2800-U+28FF).
+ * Each terminal cell represents 8 pixels, giving ~2x density horizontally
+ * and ~4x density vertically. This is the universal fallback backend
+ * that works on virtually all Unicode terminals.
+ *
+ * Dot numbering follows the Unicode braille standard:
+ * ```
+ * [0] [3]     bit 0  bit 3
+ * [1] [4]     bit 1  bit 4
+ * [2] [5]     bit 2  bit 5
+ * [6] [7]     bit 6  bit 7
+ * ```
+ *
+ * @module 3d/backends/braille
+ */
+
+/**
+ * Create a braille rendering backend.
+ *
+ * @param config - Optional braille configuration
+ * @returns A RendererBackend that encodes pixels as braille characters
+ *
+ * @example
+ * ```typescript
+ * const backend = createBrailleBackend({ threshold: 64 });
+ * const dims = backend.getPixelDimensions(80, 24);
+ * // dims = { width: 160, height: 96 }
+ * ```
+ */
+declare function createBrailleBackend(config?: BrailleConfig): RendererBackend;
+
+/**
+ * Backend auto-detection.
+ *
+ * Selects the best rendering backend based on terminal capabilities,
+ * integrating with the existing TerminalCapabilities negotiation system.
+ *
+ * Priority order: kitty > sixel > sextant > halfblock > braille
+ *
+ * @module 3d/backends/detection
+ */
+
+/**
+ * Simplified terminal capabilities relevant to backend selection.
+ * This matches a subset of the full TerminalCapabilities interface
+ * from src/terminal/capabilities/negotiation.ts.
+ */
+interface GraphicsCapabilities {
+    /** Graphics protocol: 'kitty', 'sixel', 'iterm2', 'none', or false. */
+    readonly graphics: string | false;
+    /** Whether the terminal supports true 24-bit color. */
+    readonly truecolor: boolean;
+}
+/**
+ * Create a RendererBackend by explicit type.
+ *
+ * @param type - The backend type to create
+ * @returns A new RendererBackend of the specified type
+ *
+ * @example
+ * ```typescript
+ * const backend = createBackendByType('braille');
+ * ```
+ */
+declare function createBackendByType(type: BackendType): RendererBackend;
+/**
+ * Detect the best available rendering backend based on terminal capabilities.
+ *
+ * Priority: kitty > sixel > sextant (if truecolor) > halfblock (if truecolor) > braille
+ *
+ * @param capabilities - Terminal graphics capabilities
+ * @param preference - Optional backend selection preferences
+ * @returns The best available RendererBackend
+ *
+ * @example
+ * ```typescript
+ * // Auto-detect best backend
+ * const backend = detectBestBackend({ graphics: 'kitty', truecolor: true });
+ *
+ * // Force a specific backend
+ * const braille = detectBestBackend(
+ *   { graphics: 'kitty', truecolor: true },
+ *   { preferred: 'braille', forceBackend: true },
+ * );
+ * ```
+ */
+declare function detectBestBackend(capabilities: GraphicsCapabilities, preference?: BackendPreference): RendererBackend;
+
+/**
+ * Half-block rendering backend.
+ *
+ * Maps 1x2 pixel blocks using upper/lower half-block characters.
+ * Each terminal cell represents 2 pixels vertically, with independent
+ * foreground and background colors for true 2-color-per-cell rendering.
+ *
+ * Characters used:
+ * - U+2580 (upper half block): top pixel as fg, bottom pixel as bg
+ * - U+2584 (lower half block): bottom pixel as fg, top pixel as bg
+ * - U+2588 (full block): both pixels same color, that color as fg
+ * - Space: both pixels are background color
+ *
+ * @module 3d/backends/halfblock
+ */
+
+/**
+ * Create a half-block rendering backend.
+ *
+ * @param config - Optional half-block configuration
+ * @returns A RendererBackend that encodes pixels as half-block characters
+ *
+ * @example
+ * ```typescript
+ * const backend = createHalfBlockBackend();
+ * const dims = backend.getPixelDimensions(80, 24);
+ * // dims = { width: 80, height: 48 }
+ * ```
+ */
+declare function createHalfBlockBackend(config?: HalfBlockConfig): RendererBackend;
+
+/**
+ * Kitty Graphics Protocol rendering backend.
+ *
+ * Encodes pixel data as Kitty graphics protocol escape sequences,
+ * supporting true-color RGBA with alpha transparency.
+ *
+ * Protocol format:
+ * ```
+ * ESC _G <key>=<value>,...; <base64 payload> ESC \
+ * ```
+ *
+ * Key parameters:
+ * - `a=t` - transmit image data (upload only, no display)
+ * - `a=T` - transmit and display image data
+ * - `a=p` - display (put) image
+ * - `a=d` - delete image
+ * - `f=32` - RGBA pixel format
+ * - `s=<width>` - image width in pixels
+ * - `v=<height>` - image height in pixels
+ * - `i=<id>` - image ID for reuse
+ * - `m=0|1` - 0 = last chunk, 1 = more chunks follow
+ *
+ * @module 3d/backends/kitty
+ */
+
+/**
+ * Create a Kitty Graphics Protocol rendering backend.
+ *
+ * @param config - Optional kitty configuration
+ * @returns A RendererBackend that encodes pixels as kitty graphics escape sequences
+ *
+ * @example
+ * ```typescript
+ * const backend = createKittyBackend({ imageId: 1 });
+ * const output = backend.encode(framebuffer, 0, 0);
+ * process.stdout.write(output.escape);
+ * ```
+ */
+declare function createKittyBackend(config?: KittyConfig): RendererBackend;
+
+/**
+ * Sextant rendering backend.
+ *
+ * Maps 2x3 pixel blocks to Unicode 13 legacy computing sextant characters
+ * (U+1FB00-U+1FB3B). Each terminal cell represents 6 pixels, offering a
+ * middle ground between braille (2x4, 1 fg color) and half-block (1x2, 2 colors).
+ *
+ * Dot numbering:
+ * ```
+ * [0] [1]
+ * [2] [3]
+ * [4] [5]
+ * ```
+ *
+ * Pattern mapping:
+ * - Pattern 0 (all off): space character
+ * - Patterns 1-62: U+1FB00 + (pattern - 1)
+ * - Pattern 63 (all on): U+2588 (full block)
+ *
+ * Requires Unicode 13+ support in the terminal.
+ *
+ * @module 3d/backends/sextant
+ */
+
+/**
+ * Create a sextant rendering backend.
+ *
+ * @param config - Optional sextant configuration
+ * @returns A RendererBackend that encodes pixels as sextant characters
+ *
+ * @example
+ * ```typescript
+ * const backend = createSextantBackend({ threshold: 100 });
+ * const dims = backend.getPixelDimensions(80, 24);
+ * // dims = { width: 160, height: 72 }
+ * ```
+ */
+declare function createSextantBackend(config?: SextantConfig): RendererBackend;
+
+/**
+ * Sixel (DEC bitmap) rendering backend.
+ *
+ * Encodes pixel data as DCS (Device Control String) sixel sequences.
+ * Sixel images are encoded in 6-pixel-tall horizontal bands, with color
+ * palette selection and run-length encoding for compression.
+ *
+ * Protocol format:
+ * ```
+ * ESC P q <palette> <data> ESC \
+ * ```
+ *
+ * Palette entry: `#<n>;2;<r%>;<g%>;<b%>`
+ * Data per band: `#<color><sixel chars>$` ($ = carriage return within band)
+ * Band separator: `-` (newline, advances 6 pixels down)
+ *
+ * @module 3d/backends/sixel
+ */
+
+/**
+ * Create a sixel rendering backend.
+ *
+ * @param config - Optional sixel configuration
+ * @returns A RendererBackend that encodes pixels as sixel escape sequences
+ *
+ * @example
+ * ```typescript
+ * const backend = createSixelBackend({ maxColors: 64 });
+ * const output = backend.encode(framebuffer, 0, 0);
+ * process.stdout.write(output.escape);
+ * ```
+ */
+declare function createSixelBackend(config?: SixelConfig): RendererBackend;
+
+/**
+ * SoA component for 3D animation (continuous rotation, orbital movement).
+ *
+ * @module 3d/components/animation3d
+ */
+
+/**
+ * Structure-of-Arrays animation component.
+ * Supports continuous rotation and orbital movement around a center point.
+ *
+ * @example
+ * ```typescript
+ * Animation3D.rotateSpeedY[eid] = Math.PI; // 180 degrees per second
+ * ```
+ */
+declare const Animation3D: {
+    /** Rotation speed around X axis in radians per second. */
+    rotateSpeedX: Float32Array<ArrayBuffer>;
+    /** Rotation speed around Y axis in radians per second. */
+    rotateSpeedY: Float32Array<ArrayBuffer>;
+    /** Rotation speed around Z axis in radians per second. */
+    rotateSpeedZ: Float32Array<ArrayBuffer>;
+    /** X component of orbit center point. */
+    orbitCenterX: Float32Array<ArrayBuffer>;
+    /** Y component of orbit center point. */
+    orbitCenterY: Float32Array<ArrayBuffer>;
+    /** Z component of orbit center point. */
+    orbitCenterZ: Float32Array<ArrayBuffer>;
+    /** Orbit speed in radians per second. */
+    orbitSpeed: Float32Array<ArrayBuffer>;
+    /** Distance from orbit center. */
+    orbitRadius: Float32Array<ArrayBuffer>;
+    /** Current orbit angle in radians. */
+    orbitAngle: Float32Array<ArrayBuffer>;
+    /** Whether orbiting is enabled (0 = no, 1 = yes). */
+    orbitEnabled: Uint8Array<ArrayBuffer>;
+};
+/**
+ * Data returned from getAnimation3D.
+ */
+interface Animation3DData {
+    readonly rotateSpeedX: number;
+    readonly rotateSpeedY: number;
+    readonly rotateSpeedZ: number;
+    readonly orbitCenterX: number;
+    readonly orbitCenterY: number;
+    readonly orbitCenterZ: number;
+    readonly orbitSpeed: number;
+    readonly orbitRadius: number;
+    readonly orbitAngle: number;
+    readonly orbitEnabled: boolean;
+}
+/**
+ * Set animation properties on an entity. Config is validated via Zod.
+ *
+ * @param world - ECS world
+ * @param eid - Entity ID
+ * @param config - Animation configuration
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * setAnimation3D(world, eid, { rotateSpeed: { y: Math.PI } });
+ * ```
+ */
+declare function setAnimation3D(world: World, eid: Entity, config: Animation3DConfig): Entity;
+/**
+ * Get animation data for an entity.
+ *
+ * @param world - ECS world
+ * @param eid - Entity ID
+ * @returns Animation data or undefined if component missing
+ */
+declare function getAnimation3D(world: World, eid: Entity): Animation3DData | undefined;
+
+/**
+ * SoA component for 3D cameras.
+ *
+ * @module 3d/components/camera3d
+ */
+
+/**
+ * Structure-of-Arrays 3D camera component.
+ * Stores projection parameters and cached matrices.
+ *
+ * @example
+ * ```typescript
+ * Camera3D.fov[eid] = Math.PI / 3;
+ * ```
+ */
+declare const Camera3D: {
+    fov: Float32Array<ArrayBuffer>;
+    near: Float32Array<ArrayBuffer>;
+    far: Float32Array<ArrayBuffer>;
+    aspect: Float32Array<ArrayBuffer>;
+    /** 0 = perspective, 1 = orthographic */
+    projectionMode: Uint8Array<ArrayBuffer>;
+    /** Cached projection matrix (16 floats per entity) */
+    projMatrix: Float32Array<ArrayBuffer>;
+    /** Cached view matrix (16 floats per entity) */
+    viewMatrix: Float32Array<ArrayBuffer>;
+    dirty: Uint8Array<ArrayBuffer>;
+};
+/**
+ * Data returned from getCamera3D.
+ */
+interface Camera3DData {
+    readonly fov: number;
+    readonly near: number;
+    readonly far: number;
+    readonly aspect: number;
+    readonly projectionMode: 'perspective' | 'orthographic';
+}
+/**
+ * Set camera properties on an entity. Config is validated via Zod.
+ *
+ * @param world - ECS world
+ * @param eid - Entity ID
+ * @param config - Camera configuration
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * setCamera3D(world, eid, { fov: Math.PI / 3, near: 0.1, far: 100 });
+ * ```
+ */
+declare function setCamera3D(world: World, eid: Entity, config: Camera3DConfig): Entity;
+/**
+ * Get camera data for an entity.
+ *
+ * @param world - ECS world
+ * @param eid - Entity ID
+ * @returns Camera data or undefined if component missing
+ */
+declare function getCamera3D(world: World, eid: Entity): Camera3DData | undefined;
+/**
+ * Get the cached projection matrix for a camera entity.
+ *
+ * @param eid - Entity ID
+ * @returns 16-element Float32Array view
+ */
+declare function getProjMatrix(eid: Entity): Float32Array;
+/**
+ * Get the cached view matrix for a camera entity.
+ *
+ * @param eid - Entity ID
+ * @returns 16-element Float32Array view
+ */
+declare function getViewMatrix(eid: Entity): Float32Array;
+
+/**
+ * SoA component for 3D materials.
+ *
+ * @module 3d/components/material
+ */
+
+/**
+ * Structure-of-Arrays material component.
+ * Controls how meshes are rendered (wireframe, filled, colors, culling).
+ *
+ * @example
+ * ```typescript
+ * Material3D.wireColor[eid] = 0x00ff00;
+ * ```
+ */
+declare const Material3D: {
+    wireColor: Uint32Array<ArrayBuffer>;
+    fillColor: Uint32Array<ArrayBuffer>;
+    /** 0 = wireframe, 1 = filled, 2 = both */
+    renderMode: Uint8Array<ArrayBuffer>;
+    backfaceCull: Uint8Array<ArrayBuffer>;
+    flatShading: Uint8Array<ArrayBuffer>;
+    antiAlias: Uint8Array<ArrayBuffer>;
+};
+/**
+ * Data returned from getMaterial3D.
+ */
+interface Material3DData {
+    readonly wireColor: number;
+    readonly fillColor: number;
+    readonly renderMode: 'wireframe' | 'filled' | 'both';
+    readonly backfaceCull: boolean;
+    readonly flatShading: boolean;
+    readonly antiAlias: boolean;
+}
+/**
+ * Set material properties on an entity. Config is validated via Zod.
+ *
+ * @param world - ECS world
+ * @param eid - Entity ID
+ * @param config - Material configuration
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * setMaterial3D(world, eid, { wireColor: 0x00ff00, renderMode: 'wireframe' });
+ * ```
+ */
+declare function setMaterial3D(world: World, eid: Entity, config: Material3DConfig): Entity;
+/**
+ * Get material data for an entity.
+ *
+ * @param world - ECS world
+ * @param eid - Entity ID
+ * @returns Material data or undefined if component missing
+ */
+declare function getMaterial3D(world: World, eid: Entity): Material3DData | undefined;
+
+/**
+ * Mesh component and meshStore side-car for 3D geometry data.
+ *
+ * The Mesh component is a lightweight SoA marker that links an entity to
+ * its geometry via a mesh ID. The actual vertex/face data lives in the
+ * meshStore Map (side-car pattern, like spriteStore).
+ *
+ * @module 3d/components/mesh
+ */
+
+/**
+ * SoA mesh component. Links entities to geometry data in meshStore.
+ *
+ * @example
+ * ```typescript
+ * Mesh.meshId[eid] = registeredId;
+ * ```
+ */
+declare const Mesh: {
+    /** ID referencing meshStore data */
+    meshId: Uint32Array<ArrayBuffer>;
+};
+/**
+ * Geometry data stored in the mesh store.
+ * Vertex positions and face indices in typed arrays.
+ */
+interface MeshData {
+    readonly name: string;
+    /** Flat array of vertex positions: [x0, y0, z0, x1, y1, z1, ...] */
+    readonly vertices: Float32Array;
+    /** Number of vertices (vertices.length / 3) */
+    readonly vertexCount: number;
+    /** Face indices as flat array of triangles: [i0, i1, i2, i3, i4, i5, ...] */
+    readonly indices: Uint32Array;
+    /** Number of triangles (indices.length / 3) */
+    readonly triangleCount: number;
+    /** Optional vertex normals: [nx0, ny0, nz0, nx1, ny1, nz1, ...] */
+    readonly normals?: Float32Array;
+}
+/**
+ * Register mesh geometry data and return an ID.
+ *
+ * @param name - Descriptive name for the mesh
+ * @param vertices - Flat array of vertex positions [x, y, z, ...]
+ * @param indices - Triangle indices [i0, i1, i2, ...]
+ * @param normals - Optional vertex normals
+ * @returns Unique mesh ID
+ *
+ * @example
+ * ```typescript
+ * const cubeId = registerMesh('cube',
+ *   new Float32Array([-1,-1,-1, 1,-1,-1, ...]),
+ *   new Uint32Array([0,1,2, 0,2,3, ...]),
+ * );
+ * ```
+ */
+declare function registerMesh(name: string, vertices: Float32Array, indices: Uint32Array, normals?: Float32Array): number;
+/**
+ * Create a mesh from arrays of vertex objects and polygon face indices.
+ * Automatically triangulates quads and larger polygons using fan triangulation.
+ *
+ * @param name - Descriptive name
+ * @param vertexPositions - Array of {x, y, z} objects
+ * @param faces - Array of polygon index arrays (e.g., [[0,1,2,3], [4,5,6,7]])
+ * @returns Unique mesh ID
+ *
+ * @example
+ * ```typescript
+ * const cubeId = createMeshFromArrays('cube',
+ *   [{ x: -1, y: -1, z: -1 }, { x: 1, y: -1, z: -1 }, ...],
+ *   [[0, 1, 2, 3], [4, 5, 6, 7], ...],
+ * );
+ * ```
+ */
+declare function createMeshFromArrays(name: string, vertexPositions: ReadonlyArray<{
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+}>, faces: ReadonlyArray<ReadonlyArray<number>>): number;
+/**
+ * Get mesh data by ID.
+ *
+ * @param meshId - Mesh ID from registerMesh or createMeshFromArrays
+ * @returns MeshData or undefined if not found
+ */
+declare function getMeshData(meshId: number): MeshData | undefined;
+/**
+ * Remove mesh data from the store.
+ *
+ * @param meshId - Mesh ID to remove
+ * @returns True if the mesh was found and removed
+ */
+declare function unregisterMesh(meshId: number): boolean;
+/**
+ * Set a mesh component on an entity, linking it to registered geometry.
+ *
+ * @param world - ECS world
+ * @param eid - Entity ID
+ * @param meshId - Registered mesh ID
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * const cubeId = registerMesh('cube', vertices, indices);
+ * setMesh(world, eid, cubeId);
+ * ```
+ */
+declare function setMesh(world: World, eid: Entity, meshId: number): Entity;
+/**
+ * Get the mesh ID for an entity.
+ *
+ * @param world - ECS world
+ * @param eid - Entity ID
+ * @returns Mesh ID or undefined if component missing
+ */
+declare function getMesh(world: World, eid: Entity): number | undefined;
+/**
+ * Get the total number of registered meshes.
+ */
+declare function getMeshCount(): number;
+/**
+ * Clear all registered meshes. Useful for testing.
+ */
+declare function clearMeshStore(): void;
+
+/**
+ * SoA component for mouse-based 3D camera interaction.
+ *
+ * Stores per-entity configuration for camera rotation (drag) and zoom (scroll).
+ * Works with the mouseInteraction3DSystem to apply accumulated mouse input
+ * to the camera's Transform3D component.
+ *
+ * @module 3d/components/mouseInteraction3d
+ */
+
+/**
+ * Structure-of-Arrays mouse interaction component.
+ * Stores sensitivity, zoom bounds, and accumulated mouse state.
+ *
+ * @example
+ * ```typescript
+ * MouseInteraction3D.rotationSensitivity[eid] = 0.005;
+ * ```
+ */
+declare const MouseInteraction3D: {
+    /** Radians per pixel of mouse movement for rotation. */
+    rotationSensitivity: Float32Array<ArrayBuffer>;
+    /** Units per scroll tick for zoom. */
+    zoomSensitivity: Float32Array<ArrayBuffer>;
+    /** Minimum zoom distance (camera distance from target). */
+    zoomMin: Float32Array<ArrayBuffer>;
+    /** Maximum zoom distance (camera distance from target). */
+    zoomMax: Float32Array<ArrayBuffer>;
+    /** Whether to invert the Y axis (0 = no, 1 = yes). */
+    invertY: Uint8Array<ArrayBuffer>;
+    /** Current camera distance (used for zoom). */
+    distance: Float32Array<ArrayBuffer>;
+    /** Accumulated X rotation from mouse drag (yaw). */
+    yaw: Float32Array<ArrayBuffer>;
+    /** Accumulated Y rotation from mouse drag (pitch). */
+    pitch: Float32Array<ArrayBuffer>;
+};
+/**
+ * Data returned from getMouseInteraction3D.
+ */
+interface MouseInteraction3DData {
+    readonly rotationSensitivity: number;
+    readonly zoomSensitivity: number;
+    readonly zoomMin: number;
+    readonly zoomMax: number;
+    readonly invertY: boolean;
+    readonly distance: number;
+    readonly yaw: number;
+    readonly pitch: number;
+}
+/**
+ * Accumulated mouse input for a single frame.
+ * Fed to the system via mouseInputStore.
+ */
+interface MouseDragInput {
+    /** Horizontal pixel delta from mouse drag. */
+    readonly dx: number;
+    /** Vertical pixel delta from mouse drag. */
+    readonly dy: number;
+}
+/**
+ * Per-frame mouse input for the interaction system.
+ * Store accumulated drag and scroll events here before running the system.
+ */
+declare const mouseInputStore: Map<number, {
+    dragDx: number;
+    dragDy: number;
+    scrollDelta: number;
+}>;
+/**
+ * Clear accumulated mouse input. Call after the system processes input each frame.
+ */
+declare function clearMouseInputStore(): void;
+/**
+ * Feed mouse drag input for a viewport entity.
+ * Accumulates across multiple events within a frame.
+ *
+ * @param viewportEid - Viewport entity to apply drag to
+ * @param dx - Horizontal pixel delta
+ * @param dy - Vertical pixel delta
+ *
+ * @example
+ * ```typescript
+ * feedMouseDrag(viewportEid, event.movementX, event.movementY);
+ * ```
+ */
+declare function feedMouseDrag(viewportEid: Entity, dx: number, dy: number): void;
+/**
+ * Feed mouse scroll input for a viewport entity.
+ * Accumulates across multiple events within a frame.
+ *
+ * @param viewportEid - Viewport entity to apply scroll to
+ * @param delta - Scroll delta (positive = zoom out, negative = zoom in)
+ *
+ * @example
+ * ```typescript
+ * feedMouseScroll(viewportEid, event.deltaY > 0 ? 1 : -1);
+ * ```
+ */
+declare function feedMouseScroll(viewportEid: Entity, delta: number): void;
+/**
+ * Enable mouse interaction on a camera entity.
+ * Config is validated via Zod. Sets initial distance from the camera's current Z position.
+ *
+ * @param world - ECS world
+ * @param eid - Camera entity ID
+ * @param config - Mouse interaction configuration
+ * @param initialDistance - Initial camera distance from target (defaults to 5)
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * enableMouseInteraction(world, cameraEid, { rotationSensitivity: 0.005 });
+ * ```
+ */
+declare function enableMouseInteraction(world: World, eid: Entity, config?: MouseInteraction3DConfig, initialDistance?: number): Entity;
+/**
+ * Disable mouse interaction on a camera entity.
+ *
+ * @param world - ECS world
+ * @param eid - Camera entity ID
+ */
+declare function disableMouseInteraction(world: World, eid: Entity): void;
+/**
+ * Get mouse interaction data for an entity.
+ *
+ * @param world - ECS world
+ * @param eid - Entity ID
+ * @returns Mouse interaction data or undefined if component missing
+ */
+declare function getMouseInteraction3D(world: World, eid: Entity): MouseInteraction3DData | undefined;
+
+/**
+ * SoA component for 3D transforms: translation, rotation, scale, world matrix.
+ *
+ * @module 3d/components/transform3d
+ */
+
+/**
+ * Structure-of-Arrays 3D transform component.
+ * Stores local transform (translation, rotation, scale), computed world matrix,
+ * and a dirty flag for incremental recomputation.
+ *
+ * @example
+ * ```typescript
+ * Transform3D.tx[eid] = 5.0;
+ * Transform3D.dirty[eid] = 1;
+ * ```
+ */
+declare const Transform3D: {
+    tx: Float32Array<ArrayBuffer>;
+    ty: Float32Array<ArrayBuffer>;
+    tz: Float32Array<ArrayBuffer>;
+    rx: Float32Array<ArrayBuffer>;
+    ry: Float32Array<ArrayBuffer>;
+    rz: Float32Array<ArrayBuffer>;
+    sx: Float32Array<ArrayBuffer>;
+    sy: Float32Array<ArrayBuffer>;
+    sz: Float32Array<ArrayBuffer>;
+    worldMatrix: Float32Array<ArrayBuffer>;
+    dirty: Uint8Array<ArrayBuffer>;
+};
+/**
+ * Data returned from getTransform3D.
+ */
+interface Transform3DData {
+    readonly tx: number;
+    readonly ty: number;
+    readonly tz: number;
+    readonly rx: number;
+    readonly ry: number;
+    readonly rz: number;
+    readonly sx: number;
+    readonly sy: number;
+    readonly sz: number;
+}
+/**
+ * Set a 3D transform on an entity. Config is validated via Zod.
+ * Adds the component if not already present. Sets dirty flag.
+ *
+ * @param world - ECS world
+ * @param eid - Entity ID
+ * @param config - Transform configuration
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * setTransform3D(world, eid, { tx: 0, ty: 1, tz: -5, ry: Math.PI / 4 });
+ * ```
+ */
+declare function setTransform3D(world: World, eid: Entity, config: Transform3DConfig): Entity;
+/**
+ * Get the transform data for an entity.
+ *
+ * @param world - ECS world
+ * @param eid - Entity ID
+ * @returns Transform data or undefined if component missing
+ *
+ * @example
+ * ```typescript
+ * const transform = getTransform3D(world, eid);
+ * if (transform) console.log(transform.tx, transform.ty, transform.tz);
+ * ```
+ */
+declare function getTransform3D(world: World, eid: Entity): Transform3DData | undefined;
+/**
+ * Set the translation of an entity. Marks dirty.
+ *
+ * @param world - ECS world
+ * @param eid - Entity ID
+ * @param x - X translation
+ * @param y - Y translation
+ * @param z - Z translation
+ * @returns The entity ID for chaining
+ */
+declare function setTranslation(world: World, eid: Entity, x: number, y: number, z: number): Entity;
+/**
+ * Set the rotation of an entity (Euler angles in radians). Marks dirty.
+ *
+ * @param world - ECS world
+ * @param eid - Entity ID
+ * @param rx - Rotation around X axis
+ * @param ry - Rotation around Y axis
+ * @param rz - Rotation around Z axis
+ * @returns The entity ID for chaining
+ */
+declare function setRotation(world: World, eid: Entity, rx: number, ry: number, rz: number): Entity;
+/**
+ * Set the scale of an entity. Marks dirty.
+ *
+ * @param world - ECS world
+ * @param eid - Entity ID
+ * @param sx - X scale
+ * @param sy - Y scale
+ * @param sz - Z scale
+ * @returns The entity ID for chaining
+ */
+declare function setScale(world: World, eid: Entity, sx: number, sy: number, sz: number): Entity;
+/**
+ * Get the world matrix for an entity as a Float32Array subarray view.
+ *
+ * @param eid - Entity ID
+ * @returns 16-element Float32Array view into the worldMatrix
+ *
+ * @example
+ * ```typescript
+ * const matrix = getWorldMatrix(eid);
+ * // matrix is a live view; changes to worldMatrix are reflected
+ * ```
+ */
+declare function getWorldMatrix(eid: Entity): Float32Array;
+/**
+ * Mark an entity's transform as dirty (needs world matrix recomputation).
+ *
+ * @param eid - Entity ID
+ */
+declare function markDirty(eid: Entity): void;
+/**
+ * Check if an entity's transform is dirty.
+ *
+ * @param eid - Entity ID
+ * @returns True if the transform needs recomputation
+ */
+declare function isDirty(eid: Entity): boolean;
+
+/**
+ * SoA component for 3D viewports.
+ *
+ * A viewport defines a rectangular screen region that renders
+ * a 3D scene from a camera's perspective using a specific backend.
+ *
+ * @module 3d/components/viewport3d
+ */
+
+/**
+ * Structure-of-Arrays viewport component.
+ * Defines a screen region for 3D rendering.
+ *
+ * @example
+ * ```typescript
+ * Viewport3D.left[eid] = 5;
+ * Viewport3D.width[eid] = 80;
+ * ```
+ */
+declare const Viewport3D: {
+    left: Uint16Array<ArrayBuffer>;
+    top: Uint16Array<ArrayBuffer>;
+    width: Uint16Array<ArrayBuffer>;
+    height: Uint16Array<ArrayBuffer>;
+    /** Entity ID of the camera to render from */
+    cameraEntity: Uint32Array<ArrayBuffer>;
+    /** Backend type: 0=auto, 1=braille, 2=halfblock, 3=sextant, 4=sixel, 5=kitty */
+    backendType: Uint8Array<ArrayBuffer>;
+    /** Computed pixel width (depends on backend cell size) */
+    pixelWidth: Uint16Array<ArrayBuffer>;
+    /** Computed pixel height (depends on backend cell size) */
+    pixelHeight: Uint16Array<ArrayBuffer>;
+};
+/**
+ * Data returned from getViewport3D.
+ */
+interface Viewport3DData {
+    readonly left: number;
+    readonly top: number;
+    readonly width: number;
+    readonly height: number;
+    readonly cameraEntity: number;
+    readonly backendType: 'auto' | 'braille' | 'halfblock' | 'sextant' | 'sixel' | 'kitty';
+    readonly pixelWidth: number;
+    readonly pixelHeight: number;
+}
+/**
+ * Set viewport properties on an entity. Config is validated via Zod.
+ *
+ * @param world - ECS world
+ * @param eid - Entity ID
+ * @param config - Viewport configuration
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * setViewport3D(world, eid, {
+ *   left: 5, top: 2, width: 60, height: 20,
+ *   cameraEntity: cameraEid,
+ * });
+ * ```
+ */
+declare function setViewport3D(world: World, eid: Entity, config: Viewport3DConfig): Entity;
+/**
+ * Get viewport data for an entity.
+ *
+ * @param world - ECS world
+ * @param eid - Entity ID
+ * @returns Viewport data or undefined if component missing
+ */
+declare function getViewport3D(world: World, eid: Entity): Viewport3DData | undefined;
+
+/**
+ * Zod schemas for 3D model loading and mesh primitives.
+ * @module 3d/schemas/model
+ */
+
+/**
+ * Options for loading an OBJ file.
+ */
+declare const ObjLoadOptionsSchema: z.ZodObject<{
+    name: z.ZodString;
+    flipYZ: z.ZodDefault<z.ZodBoolean>;
+    scale: z.ZodDefault<z.ZodNumber>;
+    centerOrigin: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+type ObjLoadOptions = z.input<typeof ObjLoadOptionsSchema>;
+/**
+ * Options for creating a cube mesh primitive.
+ */
+declare const CubeMeshOptionsSchema: z.ZodObject<{
+    size: z.ZodDefault<z.ZodNumber>;
+    name: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+type CubeMeshOptions = z.input<typeof CubeMeshOptionsSchema>;
+/**
+ * Options for creating a sphere mesh primitive.
+ */
+declare const SphereMeshOptionsSchema: z.ZodObject<{
+    radius: z.ZodDefault<z.ZodNumber>;
+    widthSegments: z.ZodDefault<z.ZodNumber>;
+    heightSegments: z.ZodDefault<z.ZodNumber>;
+    name: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+type SphereMeshOptions = z.input<typeof SphereMeshOptionsSchema>;
+/**
+ * Options for creating a plane mesh primitive.
+ */
+declare const PlaneMeshOptionsSchema: z.ZodObject<{
+    width: z.ZodDefault<z.ZodNumber>;
+    height: z.ZodDefault<z.ZodNumber>;
+    widthSegments: z.ZodDefault<z.ZodNumber>;
+    heightSegments: z.ZodDefault<z.ZodNumber>;
+    name: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+type PlaneMeshOptions = z.input<typeof PlaneMeshOptionsSchema>;
+/**
+ * Options for creating a cylinder mesh primitive.
+ */
+declare const CylinderMeshOptionsSchema: z.ZodObject<{
+    radiusTop: z.ZodDefault<z.ZodNumber>;
+    radiusBottom: z.ZodDefault<z.ZodNumber>;
+    height: z.ZodDefault<z.ZodNumber>;
+    segments: z.ZodDefault<z.ZodNumber>;
+    name: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+type CylinderMeshOptions = z.input<typeof CylinderMeshOptionsSchema>;
+
+/**
+ * Types for 3D model loaders.
+ * @module 3d/loaders/types
+ */
+/**
+ * A parsed vertex position.
+ */
+interface ObjVertex {
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+}
+/**
+ * A parsed face with vertex, normal, and texcoord indices.
+ */
+interface ObjFace {
+    readonly vertexIndices: ReadonlyArray<number>;
+    readonly normalIndices?: ReadonlyArray<number>;
+    readonly texCoordIndices?: ReadonlyArray<number>;
+}
+/**
+ * A named group within an OBJ file.
+ */
+interface ObjGroup {
+    readonly name: string;
+    readonly startFace: number;
+}
+/**
+ * Result of parsing an OBJ file.
+ */
+interface ObjParseResult {
+    readonly vertices: ReadonlyArray<ObjVertex>;
+    readonly normals: ReadonlyArray<ObjVertex>;
+    readonly texCoords: ReadonlyArray<{
+        readonly u: number;
+        readonly v: number;
+    }>;
+    readonly faces: ReadonlyArray<ObjFace>;
+    readonly groups: ReadonlyArray<ObjGroup>;
+}
+
+/**
+ * Wavefront OBJ file parser and loader.
+ *
+ * Parses OBJ text into vertex/face data and loads it into meshStore.
+ *
+ * @module 3d/loaders/obj
+ */
+
+/**
+ * Parse a Wavefront OBJ file from a text string.
+ *
+ * Supports: v (vertex), vn (normal), vt (texcoord), f (face), g/o (group/object).
+ * Face formats: f v, f v/vt, f v/vt/vn, f v//vn.
+ * OBJ indices are 1-based and converted to 0-based.
+ * Negative indices are supported (relative to end of vertex list).
+ *
+ * @param source - OBJ file content as string
+ * @returns Parsed result with vertices, normals, texCoords, faces, and groups
+ *
+ * @example
+ * ```typescript
+ * const result = parseObj(`
+ *   v 0 0 0
+ *   v 1 0 0
+ *   v 0 1 0
+ *   f 1 2 3
+ * `);
+ * // result.vertices.length === 3
+ * // result.faces.length === 1
+ * ```
+ */
+declare function parseObj(source: string): ObjParseResult;
+/**
+ * Compute the axis-aligned bounding box of vertices.
+ *
+ * @param vertices - Array of vertex positions
+ * @returns Bounding box with min, max, and center
+ *
+ * @example
+ * ```typescript
+ * const bbox = computeBoundingBox(vertices);
+ * console.log(bbox.center);
+ * ```
+ */
+declare function computeBoundingBox(vertices: ReadonlyArray<ObjVertex>): {
+    min: ObjVertex;
+    max: ObjVertex;
+    center: ObjVertex;
+};
+/**
+ * Parse an OBJ file and load it into meshStore.
+ * Applies optional transforms (flip, scale, center).
+ *
+ * @param source - OBJ file content as string
+ * @param options - Load options (validated via Zod)
+ * @returns Mesh ID in meshStore
+ *
+ * @example
+ * ```typescript
+ * const meshId = loadObjAsMesh(objText, { name: 'teapot', scale: 0.5 });
+ * ```
+ */
+declare function loadObjAsMesh(source: string, options: ObjLoadOptions): number;
+
+/**
+ * Zod validation schemas for 3D math types.
+ * @module 3d/schemas/math
+ */
+
+/**
+ * Vec3 as a tuple of 3 numbers.
+ */
+declare const Vec3Schema: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+/**
+ * Vec3 input that accepts either tuple or object form.
+ * Use at API boundaries to be flexible with user input.
+ */
+declare const Vec3InputSchema: z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    z: z.ZodNumber;
+}, z.core.$strip>]>;
+type Vec3Input = z.infer<typeof Vec3InputSchema>;
+/**
+ * Mat4 must be a Float32Array of exactly 16 elements (column-major).
+ */
+declare const Mat4Schema: z.ZodCustom<Float32Array<ArrayBuffer>, Float32Array<ArrayBuffer>>;
+/**
+ * Euler angles in radians for rotation.
+ */
+declare const EulerAnglesSchema: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    z: z.ZodNumber;
+}, z.core.$strip>;
+type EulerAngles = z.infer<typeof EulerAnglesSchema>;
+/**
+ * Perspective projection configuration.
+ */
+declare const PerspectiveConfigSchema: z.ZodObject<{
+    fov: z.ZodNumber;
+    aspect: z.ZodNumber;
+    near: z.ZodNumber;
+    far: z.ZodNumber;
+}, z.core.$strip>;
+type PerspectiveConfig = z.infer<typeof PerspectiveConfigSchema>;
+/**
+ * Orthographic projection configuration.
+ */
+declare const OrthographicConfigSchema: z.ZodObject<{
+    left: z.ZodNumber;
+    right: z.ZodNumber;
+    bottom: z.ZodNumber;
+    top: z.ZodNumber;
+    near: z.ZodNumber;
+    far: z.ZodNumber;
+}, z.core.$strip>;
+type OrthographicConfig = z.infer<typeof OrthographicConfigSchema>;
+/**
+ * Viewport transform configuration (NDC to pixel coords).
+ */
+declare const ViewportConfigSchema: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+}, z.core.$strip>;
+type ViewportConfig = z.infer<typeof ViewportConfigSchema>;
+/**
+ * 2D clip rectangle for Cohen-Sutherland clipping.
+ */
+declare const ClipRectSchema: z.ZodObject<{
+    xMin: z.ZodNumber;
+    xMax: z.ZodNumber;
+    yMin: z.ZodNumber;
+    yMax: z.ZodNumber;
+}, z.core.$strip>;
+type ClipRect = z.infer<typeof ClipRectSchema>;
+
+/**
+ * Vec3 operations on Float32Array for the 3D pipeline.
+ * All functions are pure: they return new arrays and never mutate inputs.
+ * @module 3d/math/vec3
+ */
+/**
+ * A 3D vector stored as Float32Array of length 3: [x, y, z].
+ */
+type Vec3 = Float32Array;
+/**
+ * Create a Vec3 from x, y, z components.
+ *
+ * @param x - X component
+ * @param y - Y component
+ * @param z - Z component
+ * @returns A new Vec3
+ *
+ * @example
+ * ```typescript
+ * const v = vec3(1, 2, 3);
+ * // v[0] === 1, v[1] === 2, v[2] === 3
+ * ```
+ */
+declare function vec3(x: number, y: number, z: number): Vec3;
+/**
+ * Create a Vec3 from a number array, validated via Zod.
+ * Use at API boundaries where input is untrusted.
+ *
+ * @param arr - Array of exactly 3 numbers
+ * @returns A new Vec3
+ * @throws ZodError if input is not a valid 3-element number tuple
+ *
+ * @example
+ * ```typescript
+ * const v = vec3FromArray([1, 2, 3]); // OK
+ * vec3FromArray([1, 2]); // throws ZodError
+ * ```
+ */
+declare function vec3FromArray(arr: readonly number[]): Vec3;
+/**
+ * Add two vectors: a + b.
+ *
+ * @param a - First vector
+ * @param b - Second vector
+ * @returns A new Vec3 containing the sum
+ *
+ * @example
+ * ```typescript
+ * const sum = vec3Add(vec3(1, 0, 0), vec3(0, 1, 0));
+ * // sum = [1, 1, 0]
+ * ```
+ */
+declare function vec3Add(a: Vec3, b: Vec3): Vec3;
+/**
+ * Subtract two vectors: a - b.
+ *
+ * @param a - First vector
+ * @param b - Second vector
+ * @returns A new Vec3 containing the difference
+ *
+ * @example
+ * ```typescript
+ * const diff = vec3Sub(vec3(3, 2, 1), vec3(1, 1, 1));
+ * // diff = [2, 1, 0]
+ * ```
+ */
+declare function vec3Sub(a: Vec3, b: Vec3): Vec3;
+/**
+ * Scale a vector by a scalar: v * s.
+ *
+ * @param v - Vector to scale
+ * @param s - Scalar multiplier
+ * @returns A new scaled Vec3
+ *
+ * @example
+ * ```typescript
+ * const doubled = vec3Scale(vec3(1, 2, 3), 2);
+ * // doubled = [2, 4, 6]
+ * ```
+ */
+declare function vec3Scale(v: Vec3, s: number): Vec3;
+/**
+ * Dot product of two vectors.
+ *
+ * @param a - First vector
+ * @param b - Second vector
+ * @returns The scalar dot product
+ *
+ * @example
+ * ```typescript
+ * const d = vec3Dot(vec3(1, 0, 0), vec3(0, 1, 0));
+ * // d === 0 (perpendicular vectors)
+ * ```
+ */
+declare function vec3Dot(a: Vec3, b: Vec3): number;
+/**
+ * Cross product of two vectors: a x b.
+ *
+ * @param a - First vector
+ * @param b - Second vector
+ * @returns A new Vec3 perpendicular to both inputs
+ *
+ * @example
+ * ```typescript
+ * const up = vec3Cross(vec3(1, 0, 0), vec3(0, 1, 0));
+ * // up = [0, 0, 1] (right-hand rule)
+ * ```
+ */
+declare function vec3Cross(a: Vec3, b: Vec3): Vec3;
+/**
+ * Squared length of a vector. Avoids sqrt when only comparing magnitudes.
+ *
+ * @param v - Vector
+ * @returns The squared length
+ *
+ * @example
+ * ```typescript
+ * const lenSq = vec3LengthSq(vec3(3, 4, 0));
+ * // lenSq === 25
+ * ```
+ */
+declare function vec3LengthSq(v: Vec3): number;
+/**
+ * Length (magnitude) of a vector.
+ *
+ * @param v - Vector
+ * @returns The length
+ *
+ * @example
+ * ```typescript
+ * const len = vec3Length(vec3(3, 4, 0));
+ * // len === 5
+ * ```
+ */
+declare function vec3Length(v: Vec3): number;
+/**
+ * Normalize a vector to unit length.
+ * Returns a zero vector if input length is zero.
+ *
+ * @param v - Vector to normalize
+ * @returns A new unit-length Vec3
+ *
+ * @example
+ * ```typescript
+ * const unit = vec3Normalize(vec3(3, 0, 0));
+ * // unit = [1, 0, 0]
+ * ```
+ */
+declare function vec3Normalize(v: Vec3): Vec3;
+/**
+ * Linearly interpolate between two vectors.
+ *
+ * @param a - Start vector (t=0)
+ * @param b - End vector (t=1)
+ * @param t - Interpolation factor, clamped to [0, 1]
+ * @returns A new interpolated Vec3
+ *
+ * @example
+ * ```typescript
+ * const mid = vec3Lerp(vec3(0, 0, 0), vec3(10, 10, 10), 0.5);
+ * // mid = [5, 5, 5]
+ * ```
+ */
+declare function vec3Lerp(a: Vec3, b: Vec3, t: number): Vec3;
+/**
+ * Negate a vector: -v.
+ *
+ * @param v - Vector to negate
+ * @returns A new negated Vec3
+ *
+ * @example
+ * ```typescript
+ * const neg = vec3Negate(vec3(1, -2, 3));
+ * // neg = [-1, 2, -3]
+ * ```
+ */
+declare function vec3Negate(v: Vec3): Vec3;
+/**
+ * Distance between two points.
+ *
+ * @param a - First point
+ * @param b - Second point
+ * @returns The Euclidean distance
+ *
+ * @example
+ * ```typescript
+ * const d = vec3Distance(vec3(0, 0, 0), vec3(3, 4, 0));
+ * // d === 5
+ * ```
+ */
+declare function vec3Distance(a: Vec3, b: Vec3): number;
+/**
+ * Check if two vectors are approximately equal within an epsilon.
+ *
+ * @param a - First vector
+ * @param b - Second vector
+ * @param epsilon - Maximum allowed difference per component (default 1e-6)
+ * @returns True if all components are within epsilon
+ *
+ * @example
+ * ```typescript
+ * vec3Equals(vec3(1, 0, 0), vec3(1.0000001, 0, 0)); // true
+ * vec3Equals(vec3(1, 0, 0), vec3(2, 0, 0)); // false
+ * ```
+ */
+declare function vec3Equals(a: Vec3, b: Vec3, epsilon?: number): boolean;
+/**
+ * Create a zero vector [0, 0, 0].
+ *
+ * @returns A new zero Vec3
+ */
+declare function vec3Zero(): Vec3;
+
+/**
+ * Mat4 (4x4 matrix) operations on Float32Array(16) in column-major order.
+ * All functions are pure: they return new arrays and never mutate inputs.
+ * Column-major layout: element at [row][col] = arr[col * 4 + row].
+ * @module 3d/math/mat4
+ */
+
+/**
+ * A 4x4 matrix stored as Float32Array of length 16 in column-major order.
+ */
+type Mat4 = Float32Array;
+/**
+ * Create a new identity matrix.
+ *
+ * @returns A new 4x4 identity matrix
+ *
+ * @example
+ * ```typescript
+ * const m = mat4Identity();
+ * // Diagonal is 1, rest is 0
+ * ```
+ */
+declare function mat4Identity(): Mat4;
+/**
+ * Multiply two 4x4 matrices: a * b.
+ *
+ * @param a - Left matrix
+ * @param b - Right matrix
+ * @returns A new Mat4 containing the product
+ *
+ * @example
+ * ```typescript
+ * const result = mat4Multiply(mat4Identity(), someMatrix);
+ * // result equals someMatrix (identity * M = M)
+ * ```
+ */
+declare function mat4Multiply(a: Mat4, b: Mat4): Mat4;
+/**
+ * Apply translation to a matrix: m * T(x, y, z).
+ *
+ * @param m - Input matrix
+ * @param x - X translation
+ * @param y - Y translation
+ * @param z - Z translation
+ * @returns A new translated Mat4
+ *
+ * @example
+ * ```typescript
+ * const moved = mat4Translate(mat4Identity(), 10, 5, -3);
+ * ```
+ */
+declare function mat4Translate(m: Mat4, x: number, y: number, z: number): Mat4;
+/**
+ * Apply rotation around X axis.
+ *
+ * @param m - Input matrix
+ * @param radians - Rotation angle in radians
+ * @returns A new rotated Mat4
+ *
+ * @example
+ * ```typescript
+ * const rotated = mat4RotateX(mat4Identity(), Math.PI / 4);
+ * ```
+ */
+declare function mat4RotateX(m: Mat4, radians: number): Mat4;
+/**
+ * Apply rotation around Y axis.
+ *
+ * @param m - Input matrix
+ * @param radians - Rotation angle in radians
+ * @returns A new rotated Mat4
+ *
+ * @example
+ * ```typescript
+ * const rotated = mat4RotateY(mat4Identity(), Math.PI / 2);
+ * ```
+ */
+declare function mat4RotateY(m: Mat4, radians: number): Mat4;
+/**
+ * Apply rotation around Z axis.
+ *
+ * @param m - Input matrix
+ * @param radians - Rotation angle in radians
+ * @returns A new rotated Mat4
+ *
+ * @example
+ * ```typescript
+ * const rotated = mat4RotateZ(mat4Identity(), Math.PI);
+ * ```
+ */
+declare function mat4RotateZ(m: Mat4, radians: number): Mat4;
+/**
+ * Apply non-uniform scale to a matrix.
+ *
+ * @param m - Input matrix
+ * @param sx - X scale factor
+ * @param sy - Y scale factor
+ * @param sz - Z scale factor
+ * @returns A new scaled Mat4
+ *
+ * @example
+ * ```typescript
+ * const scaled = mat4Scale(mat4Identity(), 2, 2, 2);
+ * ```
+ */
+declare function mat4Scale(m: Mat4, sx: number, sy: number, sz: number): Mat4;
+/**
+ * Transpose a 4x4 matrix (swap rows and columns).
+ *
+ * @param m - Input matrix
+ * @returns A new transposed Mat4
+ *
+ * @example
+ * ```typescript
+ * const t = mat4Transpose(someMatrix);
+ * ```
+ */
+declare function mat4Transpose(m: Mat4): Mat4;
+/**
+ * Compute the determinant of a 4x4 matrix.
+ *
+ * @param m - Input matrix
+ * @returns The determinant value
+ *
+ * @example
+ * ```typescript
+ * const det = mat4Determinant(mat4Identity());
+ * // det === 1
+ * ```
+ */
+declare function mat4Determinant(m: Mat4): number;
+/**
+ * Invert a 4x4 matrix. Returns null if the matrix is singular.
+ *
+ * @param m - Input matrix
+ * @returns A new inverted Mat4 or null if singular
+ *
+ * @example
+ * ```typescript
+ * const inv = mat4Invert(someMatrix);
+ * if (inv) {
+ *   // mat4Multiply(someMatrix, inv) ~= identity
+ * }
+ * ```
+ */
+declare function mat4Invert(m: Mat4): Mat4 | null;
+/**
+ * Transform a 3D point by a 4x4 matrix (w=1, applies translation).
+ *
+ * @param m - Transformation matrix
+ * @param v - 3D point
+ * @returns A new transformed Vec3
+ *
+ * @example
+ * ```typescript
+ * const moved = mat4TransformVec3(mat4Translate(mat4Identity(), 5, 0, 0), vec3(0, 0, 0));
+ * // moved = [5, 0, 0]
+ * ```
+ */
+declare function mat4TransformVec3(m: Mat4, v: Vec3): Vec3;
+/**
+ * Transform a 3D direction by a 4x4 matrix (w=0, ignores translation).
+ *
+ * @param m - Transformation matrix
+ * @param v - 3D direction
+ * @returns A new transformed Vec3
+ *
+ * @example
+ * ```typescript
+ * const dir = mat4TransformDirection(mat4RotateY(mat4Identity(), Math.PI/2), vec3(1, 0, 0));
+ * // dir ~ [0, 0, -1]
+ * ```
+ */
+declare function mat4TransformDirection(m: Mat4, v: Vec3): Vec3;
+/**
+ * Build a 4x4 matrix from translation, euler rotation (XYZ order), and scale.
+ *
+ * @param translation - Translation vector
+ * @param rotation - Euler angles in radians (applied as X, then Y, then Z)
+ * @param scale - Scale vector
+ * @returns A new Mat4 combining TRS
+ *
+ * @example
+ * ```typescript
+ * const m = mat4FromTRS(vec3(10, 0, -5), vec3(0, Math.PI/4, 0), vec3(1, 1, 1));
+ * ```
+ */
+declare function mat4FromTRS(translation: Vec3, rotation: Vec3, scale: Vec3): Mat4;
+/**
+ * Check if a Mat4 is approximately the identity matrix.
+ *
+ * @param m - Matrix to check
+ * @param epsilon - Maximum allowed difference per element (default 1e-6)
+ * @returns True if the matrix is approximately identity
+ */
+declare function mat4IsIdentity(m: Mat4, epsilon?: number): boolean;
+/**
+ * Check if two Mat4 matrices are approximately equal.
+ *
+ * @param a - First matrix
+ * @param b - Second matrix
+ * @param epsilon - Maximum allowed difference per element (default 1e-5)
+ * @returns True if all elements are within epsilon
+ */
+declare function mat4Equals(a: Mat4, b: Mat4, epsilon?: number): boolean;
+
+/**
+ * Cohen-Sutherland line clipping and view frustum culling.
+ * @module 3d/math/clipping
+ */
+
+/**
+ * Result of a line clipping operation.
+ */
+interface ClippedLine {
+    readonly x0: number;
+    readonly y0: number;
+    readonly x1: number;
+    readonly y1: number;
+}
+/**
+ * A frustum plane defined by normal and distance from origin.
+ */
+interface FrustumPlane {
+    readonly normal: Vec3;
+    readonly distance: number;
+}
+/**
+ * Compute the 4-bit Cohen-Sutherland outcode for a point relative to a clip rectangle.
+ *
+ * @param x - Point X coordinate
+ * @param y - Point Y coordinate
+ * @param rect - Clip rectangle
+ * @returns 4-bit outcode
+ *
+ * @example
+ * ```typescript
+ * const code = computeOutcode(5, 5, { xMin: 0, xMax: 10, yMin: 0, yMax: 10 });
+ * // code === 0 (inside)
+ * ```
+ */
+declare function computeOutcode(x: number, y: number, rect: ClipRect): number;
+/**
+ * Clip a 2D line segment to a rectangle using Cohen-Sutherland algorithm.
+ * Returns null if the line is entirely outside.
+ *
+ * @param x0 - Start X
+ * @param y0 - Start Y
+ * @param x1 - End X
+ * @param y1 - End Y
+ * @param rect - Clip rectangle
+ * @returns Clipped line endpoints or null if fully outside
+ *
+ * @example
+ * ```typescript
+ * const result = clipLine(-5, 5, 15, 5, { xMin: 0, xMax: 10, yMin: 0, yMax: 10 });
+ * // result = { x0: 0, y0: 5, x1: 10, y1: 5 }
+ * ```
+ */
+declare function clipLine(x0: number, y0: number, x1: number, y1: number, rect: ClipRect): ClippedLine | null;
+/**
+ * Extract 6 frustum planes from a combined view-projection matrix.
+ * Plane normals point inward (toward the visible region).
+ *
+ * @param viewProj - Combined view-projection matrix
+ * @returns Array of 6 frustum planes: [left, right, bottom, top, near, far]
+ *
+ * @example
+ * ```typescript
+ * const planes = extractFrustumPlanes(vpMatrix);
+ * ```
+ */
+declare function extractFrustumPlanes(viewProj: Mat4): FrustumPlane[];
+/**
+ * Test if a point is inside all frustum planes.
+ *
+ * @param point - 3D point to test
+ * @param planes - Array of frustum planes (normals point inward)
+ * @returns True if the point is inside the frustum
+ *
+ * @example
+ * ```typescript
+ * const inside = isPointInFrustum(vec3(0, 0, -5), frustumPlanes);
+ * ```
+ */
+declare function isPointInFrustum(point: Vec3, planes: readonly FrustumPlane[]): boolean;
+/**
+ * Test if a bounding sphere intersects or is inside the frustum.
+ *
+ * @param center - Sphere center
+ * @param radius - Sphere radius
+ * @param planes - Frustum planes
+ * @returns True if the sphere is at least partially inside
+ *
+ * @example
+ * ```typescript
+ * const visible = isSphereInFrustum(vec3(0, 0, -5), 2.0, frustumPlanes);
+ * ```
+ */
+declare function isSphereInFrustum(center: Vec3, radius: number, planes: readonly FrustumPlane[]): boolean;
+
+/**
+ * Camera projection matrices and viewport transforms.
+ * @module 3d/math/projection
+ */
+
+/**
+ * Build a perspective projection matrix.
+ * Validated via PerspectiveConfigSchema at call time.
+ *
+ * @param config - Perspective configuration (fov, aspect, near, far)
+ * @returns A new perspective projection Mat4
+ *
+ * @example
+ * ```typescript
+ * const proj = perspectiveMatrix({ fov: Math.PI / 3, aspect: 16/9, near: 0.1, far: 100 });
+ * ```
+ */
+declare function perspectiveMatrix(config: PerspectiveConfig): Mat4;
+/**
+ * Build an orthographic projection matrix.
+ * Validated via OrthographicConfigSchema at call time.
+ *
+ * @param config - Orthographic bounds
+ * @returns A new orthographic projection Mat4
+ *
+ * @example
+ * ```typescript
+ * const proj = orthographicMatrix({ left: -10, right: 10, bottom: -10, top: 10, near: 0.1, far: 100 });
+ * ```
+ */
+declare function orthographicMatrix(config: OrthographicConfig): Mat4;
+/**
+ * Build a view matrix (camera looking at target).
+ *
+ * @param eye - Camera position
+ * @param target - Point the camera looks at
+ * @param up - Up direction vector
+ * @returns A new view Mat4
+ *
+ * @example
+ * ```typescript
+ * const view = lookAt(vec3(0, 0, 5), vec3(0, 0, 0), vec3(0, 1, 0));
+ * ```
+ */
+declare function lookAt(eye: Vec3, target: Vec3, up: Vec3): Mat4;
+/**
+ * Projected screen coordinates from viewport transform.
+ */
+interface ScreenCoord {
+    readonly x: number;
+    readonly y: number;
+    readonly depth: number;
+}
+/**
+ * Create a viewport transform function that maps NDC [-1,1] to pixel coordinates.
+ * Validated via ViewportConfigSchema at call time.
+ *
+ * @param config - Viewport rectangle
+ * @returns A function that transforms NDC coordinates to screen pixel coordinates
+ *
+ * @example
+ * ```typescript
+ * const transform = viewportTransform({ x: 0, y: 0, width: 160, height: 96 });
+ * const screen = transform(vec3(0, 0, 0.5)); // center of viewport
+ * ```
+ */
+declare function viewportTransform(config: ViewportConfig): (ndc: Vec3) => ScreenCoord;
+/**
+ * Project a 3D vertex through an MVP matrix to NDC coordinates.
+ *
+ * @param mvp - Model-View-Projection matrix
+ * @param vertex - 3D vertex position
+ * @returns NDC coordinates (x, y in [-1,1], z = depth)
+ *
+ * @example
+ * ```typescript
+ * const ndc = projectVertex(mvpMatrix, vec3(0, 0, -5));
+ * ```
+ */
+declare function projectVertex(mvp: Mat4, vertex: Vec3): Vec3;
+/**
+ * Unproject a screen position back to world coordinates.
+ *
+ * @param invMvp - Inverse of the MVP matrix
+ * @param screenPos - Screen position as Vec3 (x, y in viewport pixels, z = depth 0..1)
+ * @param viewport - Viewport configuration
+ * @returns World-space Vec3 or null if unproject fails
+ *
+ * @example
+ * ```typescript
+ * const worldPos = unprojectVertex(invMvp, vec3(80, 48, 0.5), { x: 0, y: 0, width: 160, height: 96 });
+ * ```
+ */
+declare function unprojectVertex(invMvp: Mat4, screenPos: Vec3, viewport: ViewportConfig): Vec3 | null;
+/**
+ * Build an MVP matrix from model, view, and projection matrices.
+ *
+ * @param model - Model (world) matrix
+ * @param view - View (camera) matrix
+ * @param projection - Projection matrix
+ * @returns Combined MVP matrix
+ */
+declare function buildMVP(model: Mat4, view: Mat4, projection: Mat4): Mat4;
+
+/**
+ * Bresenham line drawing with color and depth interpolation.
+ *
+ * @module 3d/rasterizer/line
+ */
+
+/**
+ * Draw a solid-color line using Bresenham's algorithm.
+ * No depth testing. Pixels outside the framebuffer are skipped.
+ *
+ * @param fb - Framebuffer to draw into
+ * @param x0 - Start X coordinate
+ * @param y0 - Start Y coordinate
+ * @param x1 - End X coordinate
+ * @param y1 - End Y coordinate
+ * @param r - Red component (0-255)
+ * @param g - Green component (0-255)
+ * @param b - Blue component (0-255)
+ * @param a - Alpha component (0-255, defaults to 255)
+ *
+ * @example
+ * ```typescript
+ * drawLine(fb, 0, 0, 100, 50, 255, 255, 255);
+ * ```
+ */
+declare function drawLine(fb: PixelFramebuffer, x0: number, y0: number, x1: number, y1: number, r: number, g: number, b: number, a?: number): void;
+/**
+ * Draw a line with linear depth interpolation and depth testing.
+ * Uses a single color from p0. Pixels that fail the depth test are skipped.
+ *
+ * @param fb - Framebuffer to draw into (must have depth buffer)
+ * @param p0 - Start endpoint with position, color, and depth
+ * @param p1 - End endpoint with position and depth
+ *
+ * @example
+ * ```typescript
+ * drawLineDepth(fb,
+ *   { x: 0, y: 0, depth: 0.2, r: 255, g: 0, b: 0 },
+ *   { x: 100, y: 50, depth: 0.8, r: 255, g: 0, b: 0 },
+ * );
+ * ```
+ */
+declare function drawLineDepth(fb: PixelFramebuffer, p0: LineEndpoint, p1: LineEndpoint): void;
+/**
+ * Draw a line with both color and depth interpolation.
+ * Color is linearly interpolated between endpoints.
+ *
+ * @param fb - Framebuffer to draw into (must have depth buffer for depth testing)
+ * @param p0 - Start endpoint with position, color, and depth
+ * @param p1 - End endpoint with position, color, and depth
+ *
+ * @example
+ * ```typescript
+ * drawLineColor(fb,
+ *   { x: 0, y: 0, depth: 0.2, r: 255, g: 0, b: 0 },
+ *   { x: 100, y: 50, depth: 0.8, r: 0, g: 0, b: 255 },
+ * );
+ * ```
+ */
+declare function drawLineColor(fb: PixelFramebuffer, p0: LineEndpoint, p1: LineEndpoint): void;
+
+/**
+ * Wu's anti-aliased line drawing algorithm.
+ *
+ * Produces smoother lines by drawing two pixels per step with
+ * fractional intensity. Best results on sixel/kitty backends
+ * where subpixel rendering is available.
+ *
+ * @module 3d/rasterizer/lineAA
+ */
+
+/**
+ * Blend a color with an existing pixel at the given intensity.
+ * Uses alpha blending: result = existing * (1 - intensity) + new * intensity.
+ *
+ * @param fb - Framebuffer to read/write
+ * @param x - X coordinate
+ * @param y - Y coordinate
+ * @param r - Red component (0-255)
+ * @param g - Green component (0-255)
+ * @param b - Blue component (0-255)
+ * @param a - Alpha component (0-255)
+ * @param intensity - Blend intensity (0.0 = fully transparent, 1.0 = fully opaque)
+ *
+ * @example
+ * ```typescript
+ * blendPixel(fb, 10, 20, 255, 255, 255, 255, 0.5);
+ * ```
+ */
+declare function blendPixel(fb: PixelFramebuffer, x: number, y: number, r: number, g: number, b: number, a: number, intensity: number): void;
+/**
+ * Draw an anti-aliased line using Wu's algorithm.
+ * Draws two pixels per column/row step with fractional intensity
+ * for smooth appearance.
+ *
+ * @param fb - Framebuffer to draw into
+ * @param x0 - Start X coordinate
+ * @param y0 - Start Y coordinate
+ * @param x1 - End X coordinate
+ * @param y1 - End Y coordinate
+ * @param r - Red component (0-255)
+ * @param g - Green component (0-255)
+ * @param b - Blue component (0-255)
+ * @param a - Alpha component (0-255, defaults to 255)
+ *
+ * @example
+ * ```typescript
+ * drawLineAA(fb, 0, 0, 100, 30, 255, 255, 255);
+ * ```
+ */
+declare function drawLineAA(fb: PixelFramebuffer, x0: number, y0: number, x1: number, y1: number, r: number, g: number, b: number, a?: number): void;
+
+/**
+ * Flat shading for 3D face rendering.
+ *
+ * Computes face normals and applies directional + ambient lighting
+ * to produce a single color per face.
+ *
+ * @module 3d/rasterizer/shading
+ */
+
+/**
+ * Compute the face normal of a triangle from its three vertices.
+ * The normal is computed as the normalized cross product of two edges.
+ *
+ * @param v0 - First vertex
+ * @param v1 - Second vertex
+ * @param v2 - Third vertex
+ * @returns Normalized face normal vector
+ *
+ * @example
+ * ```typescript
+ * import { vec3 } from '../math/vec3';
+ * const normal = computeFaceNormal(vec3(0,0,0), vec3(1,0,0), vec3(0,1,0));
+ * // normal ~ (0, 0, 1) for CCW triangle in XY plane
+ * ```
+ */
+declare function computeFaceNormal(v0: Vec3, v1: Vec3, v2: Vec3): Vec3;
+/**
+ * Compute flat shading color given a face normal, light, and base color.
+ *
+ * Uses Lambert's cosine law: diffuse = max(0, dot(normal, -lightDir)).
+ * Final color = (ambient + diffuse) * baseColor, clamped to [0, 255].
+ *
+ * @param normal - Normalized face normal
+ * @param light - Directional light source
+ * @param ambient - Ambient light
+ * @param baseColor - Base material color
+ * @returns Shaded RGBA color
+ *
+ * @example
+ * ```typescript
+ * const color = computeFlatShading(
+ *   faceNormal,
+ *   { direction: [0, -1, 0], intensity: 1.0 },
+ *   { intensity: 0.1 },
+ *   { r: 200, g: 100, b: 50, a: 255 },
+ * );
+ * ```
+ */
+declare function computeFlatShading(normal: Vec3, light: DirectionalLight, ambient: AmbientLight, baseColor: RGBAColor): RGBAColor;
+/**
+ * Convenience function: compute face normal and apply flat shading in one call.
+ *
+ * @param v0 - First vertex
+ * @param v1 - Second vertex
+ * @param v2 - Third vertex
+ * @param light - Directional light source
+ * @param ambient - Ambient light
+ * @param baseColor - Base material color
+ * @returns Shaded RGBA color for the face
+ *
+ * @example
+ * ```typescript
+ * import { vec3 } from '../math/vec3';
+ * const color = shadeFace(
+ *   vec3(0,0,0), vec3(1,0,0), vec3(0,1,0),
+ *   { direction: [0, 0, -1], intensity: 1.0 },
+ *   { intensity: 0.1 },
+ *   { r: 200, g: 100, b: 50, a: 255 },
+ * );
+ * ```
+ */
+declare function shadeFace(v0: Vec3, v1: Vec3, v2: Vec3, light: DirectionalLight, ambient: AmbientLight, baseColor: RGBAColor): RGBAColor;
+
+/**
+ * Scanline triangle rasterizer with depth buffer and color interpolation.
+ *
+ * @module 3d/rasterizer/triangle
+ */
+
+/**
+ * Bounding box for a triangle.
+ */
+interface TriangleBBox {
+    readonly minX: number;
+    readonly minY: number;
+    readonly maxX: number;
+    readonly maxY: number;
+}
+/**
+ * Compute the signed 2x area of a triangle.
+ * Positive = counter-clockwise (front-facing), negative = clockwise (back-facing).
+ *
+ * @param v0 - First vertex
+ * @param v1 - Second vertex
+ * @param v2 - Third vertex
+ * @returns Signed 2x area
+ *
+ * @example
+ * ```typescript
+ * const area = triangleArea2(
+ *   { x: 0, y: 0 },
+ *   { x: 10, y: 0 },
+ *   { x: 0, y: 10 },
+ * );
+ * // area = 100 (CCW, front-facing)
+ * ```
+ */
+declare function triangleArea2(v0: {
+    readonly x: number;
+    readonly y: number;
+}, v1: {
+    readonly x: number;
+    readonly y: number;
+}, v2: {
+    readonly x: number;
+    readonly y: number;
+}): number;
+/**
+ * Compute the axis-aligned bounding box of a triangle.
+ *
+ * @param v0 - First vertex
+ * @param v1 - Second vertex
+ * @param v2 - Third vertex
+ * @returns Bounding box
+ *
+ * @example
+ * ```typescript
+ * const bbox = triangleBoundingBox(v0, v1, v2);
+ * ```
+ */
+declare function triangleBoundingBox(v0: {
+    readonly x: number;
+    readonly y: number;
+}, v1: {
+    readonly x: number;
+    readonly y: number;
+}, v2: {
+    readonly x: number;
+    readonly y: number;
+}): TriangleBBox;
+/**
+ * Fill a triangle with per-vertex color and depth interpolation.
+ * Uses scanline rasterization with top-left fill rule.
+ * Skips degenerate triangles (area < 0.5).
+ *
+ * @param fb - Framebuffer to draw into
+ * @param v0 - First vertex
+ * @param v1 - Second vertex
+ * @param v2 - Third vertex
+ *
+ * @example
+ * ```typescript
+ * fillTriangle(fb,
+ *   { x: 10, y: 0, depth: 0.5, r: 255, g: 0, b: 0 },
+ *   { x: 0, y: 20, depth: 0.5, r: 0, g: 255, b: 0 },
+ *   { x: 20, y: 20, depth: 0.5, r: 0, g: 0, b: 255 },
+ * );
+ * ```
+ */
+declare function fillTriangle(fb: PixelFramebuffer, v0: TriangleVertex, v1: TriangleVertex, v2: TriangleVertex): void;
+/**
+ * Fill a triangle with a single flat color and depth interpolation.
+ * Faster than fillTriangle when per-vertex color is not needed.
+ *
+ * @param fb - Framebuffer to draw into
+ * @param v0 - First vertex
+ * @param v1 - Second vertex
+ * @param v2 - Third vertex
+ * @param color - Flat fill color
+ *
+ * @example
+ * ```typescript
+ * fillTriangleFlat(fb,
+ *   { x: 10, y: 0, depth: 0.5, r: 0, g: 0, b: 0 },
+ *   { x: 0, y: 20, depth: 0.5, r: 0, g: 0, b: 0 },
+ *   { x: 20, y: 20, depth: 0.5, r: 0, g: 0, b: 0 },
+ *   { r: 255, g: 128, b: 64, a: 255 },
+ * );
+ * ```
+ */
+declare function fillTriangleFlat(fb: PixelFramebuffer, v0: TriangleVertex, v1: TriangleVertex, v2: TriangleVertex, color: RGBAColor): void;
+
+/**
+ * Convenience functions for creating common 3D mesh primitives.
+ *
+ * @module 3d/stores/primitives
+ */
+
+/**
+ * Create a cube mesh centered at the origin.
+ *
+ * @param options - Cube configuration (validated via Zod)
+ * @returns Mesh ID in meshStore
+ *
+ * @example
+ * ```typescript
+ * const cubeId = createCubeMesh({ size: 2 });
+ * ```
+ */
+declare function createCubeMesh(options?: CubeMeshOptions): number;
+/**
+ * Create a UV sphere mesh centered at the origin.
+ *
+ * @param options - Sphere configuration (validated via Zod)
+ * @returns Mesh ID in meshStore
+ *
+ * @example
+ * ```typescript
+ * const sphereId = createSphereMesh({ radius: 2, widthSegments: 32 });
+ * ```
+ */
+declare function createSphereMesh(options?: SphereMeshOptions): number;
+/**
+ * Create a plane mesh in the XZ plane centered at the origin.
+ *
+ * @param options - Plane configuration (validated via Zod)
+ * @returns Mesh ID in meshStore
+ *
+ * @example
+ * ```typescript
+ * const planeId = createPlaneMesh({ width: 10, height: 10 });
+ * ```
+ */
+declare function createPlaneMesh(options?: PlaneMeshOptions): number;
+/**
+ * Create a cylinder mesh centered at the origin.
+ * If one radius is 0, creates a cone shape.
+ *
+ * @param options - Cylinder configuration (validated via Zod)
+ * @returns Mesh ID in meshStore
+ *
+ * @example
+ * ```typescript
+ * const cylinderId = createCylinderMesh({ segments: 32 });
+ * const coneId = createCylinderMesh({ radiusTop: 0, radiusBottom: 1 });
+ * ```
+ */
+declare function createCylinderMesh(options?: CylinderMeshOptions): number;
+
+/**
+ * 3D animation system: applies continuous rotation and orbital movement
+ * to entities with Animation3D + Transform3D components.
+ *
+ * Runs in the ANIMATION phase before sceneGraphSystem picks up dirty flags.
+ *
+ * @module 3d/systems/animation3dSystem
+ */
+
+/**
+ * Animation3D system. Updates Transform3D rotation and position based on
+ * Animation3D parameters and elapsed time.
+ *
+ * For each entity with both Animation3D and Transform3D:
+ * - Adds rotateSpeed * dt to current rotation axes
+ * - If orbiting: updates orbit angle and computes position on circle
+ * - Marks Transform3D as dirty so sceneGraphSystem recomputes the world matrix
+ *
+ * @param world - ECS world
+ * @returns The world (unmodified reference)
+ *
+ * @example
+ * ```typescript
+ * import { animation3DSystem } from 'blecsd/3d/systems';
+ *
+ * // Each frame:
+ * animation3DSystem(world);  // Updates rotations/orbits
+ * sceneGraphSystem(world);   // Recomputes world matrices
+ * ```
+ */
+declare const animation3DSystem: System;
+
+/**
+ * Mouse interaction system for 3D camera control.
+ *
+ * Processes accumulated mouse drag and scroll input to rotate and zoom
+ * the camera. Works with entities that have both MouseInteraction3D and
+ * Transform3D components (typically camera entities).
+ *
+ * The system reads from mouseInputStore (fed by feedMouseDrag/feedMouseScroll)
+ * and updates the camera's Transform3D position based on spherical coordinates
+ * (yaw, pitch, distance from origin).
+ *
+ * Run this system BEFORE sceneGraphSystem so that updated camera positions
+ * are picked up in the same frame.
+ *
+ * @module 3d/systems/mouseInteraction3dSystem
+ */
+
+/**
+ * Mouse interaction 3D system. Processes accumulated mouse input and applies
+ * camera rotation (drag) and zoom (scroll) to the camera's Transform3D.
+ *
+ * For each viewport with mouse input:
+ * 1. Looks up the camera entity from Viewport3D.cameraEntity
+ * 2. If the camera has MouseInteraction3D, applies drag to yaw/pitch
+ * 3. Applies scroll to distance (clamped by zoomMin/zoomMax)
+ * 4. Converts spherical coordinates (yaw, pitch, distance) to Cartesian (tx, ty, tz)
+ * 5. Sets camera rotation to look at origin (rx = -pitch, ry = -yaw)
+ * 6. Marks Transform3D as dirty
+ *
+ * After processing, clears the mouseInputStore.
+ *
+ * @param world - ECS world
+ * @returns The world (unmodified reference)
+ *
+ * @example
+ * ```typescript
+ * import { mouseInteraction3DSystem } from 'blecsd/3d/systems';
+ * import { feedMouseDrag, feedMouseScroll } from 'blecsd/3d/components';
+ *
+ * // On mouse drag event:
+ * feedMouseDrag(viewportEid, deltaX, deltaY);
+ *
+ * // On scroll event:
+ * feedMouseScroll(viewportEid, scrollTicks);
+ *
+ * // Each frame:
+ * mouseInteraction3DSystem(world);  // Applies input to camera
+ * sceneGraphSystem(world);           // Recomputes world matrices
+ * ```
+ */
+declare const mouseInteraction3DSystem: System;
+
+/**
+ * Projection system: builds view/projection matrices from Camera3D,
+ * then projects mesh vertices to 2D screen coordinates.
+ *
+ * For each Viewport3D entity:
+ * 1. Gets the camera entity and builds view/projection matrices
+ * 2. For each entity with Mesh + Transform3D, projects vertices to screen space
+ * 3. Stores results in projectionStore for use by rasterSystem
+ *
+ * @module 3d/systems/projectionSystem
+ */
+
+/**
+ * A single projected vertex in screen space.
+ */
+interface ProjectedVertex {
+    readonly x: number;
+    readonly y: number;
+    readonly depth: number;
+    readonly visible: boolean;
+}
+/**
+ * Projection results for a single mesh entity within a viewport.
+ */
+interface MeshProjection {
+    readonly meshEid: Entity;
+    readonly projectedVertices: ReadonlyArray<ProjectedVertex>;
+    readonly triangleIndices: Uint32Array;
+    readonly mvpMatrix: Mat4;
+}
+/**
+ * Projection results for a viewport.
+ */
+interface ViewportProjection {
+    readonly viewportEid: Entity;
+    readonly cameraEid: Entity;
+    readonly meshes: ReadonlyArray<MeshProjection>;
+    readonly vpMatrix: Mat4;
+    readonly pixelWidth: number;
+    readonly pixelHeight: number;
+}
+/**
+ * Per-frame projection store. Cleared and rebuilt each frame by the projection system.
+ * Keyed by viewport entity ID.
+ */
+declare const projectionStore: Map<number, ViewportProjection>;
+/**
+ * Clear the projection store. Useful for testing.
+ */
+declare function clearProjectionStore(): void;
+declare const projectionSystem: System;
+
+/**
+ * Raster system: draws wireframe edges and/or filled triangles to a PixelFramebuffer.
+ *
+ * Reads projected vertex data from projectionStore and Material settings to
+ * determine rendering mode (wireframe, filled, or both). Produces a
+ * PixelFramebuffer per viewport stored in framebufferStore.
+ *
+ * @module 3d/systems/rasterSystem
+ */
+
+/**
+ * Per-viewport framebuffer store. Created/resized as needed by the raster system.
+ */
+declare const framebufferStore: Map<number, PixelFramebuffer>;
+/**
+ * Clear the framebuffer store. Useful for testing.
+ */
+declare function clearFramebufferStore(): void;
+declare const rasterSystem: System;
+
+/**
+ * Scene graph system: computes world matrices from local transforms and parent hierarchy.
+ *
+ * Processes all entities with Transform3D that are dirty, composing local TRS
+ * (translation, rotation, scale) into a world matrix. For entities with parents,
+ * the world matrix is the product of the parent's world matrix and the local matrix.
+ *
+ * @module 3d/systems/sceneGraphSystem
+ */
+
+/**
+ * Scene graph system that computes world matrices from Transform3D + Hierarchy.
+ *
+ * Processing order: depth-first, parent before children.
+ * Only dirty entities and their descendants are recomputed.
+ *
+ * @param world - ECS world
+ * @returns The world (unmodified reference)
+ *
+ * @example
+ * ```typescript
+ * import { sceneGraphSystem } from 'blecsd/3d/systems';
+ *
+ * // Run manually
+ * sceneGraphSystem(world);
+ *
+ * // Or register with scheduler
+ * registerSceneGraphSystem(scheduler);
+ * ```
+ */
+declare const sceneGraphSystem: System;
+
+/**
+ * Viewport output system: encodes PixelFramebuffer via the selected backend
+ * and stores the encoded result for consumption by the rendering pipeline.
+ *
+ * For cell-based backends (braille, halfblock, sextant): produces cell arrays
+ * that can be written to a ScreenBuffer via setCell().
+ *
+ * For escape-based backends (sixel, kitty): produces raw escape sequences
+ * that can be written directly to the terminal output stream.
+ *
+ * @module 3d/systems/viewportOutputSystem
+ */
+
+/**
+ * Per-viewport cached backend instances. Created on first use and reused
+ * until the viewport's backend type changes.
+ */
+declare const backendStore: Map<number, RendererBackend>;
+/**
+ * Per-viewport encoded output from the last frame.
+ * Consumers read this to write cells to ScreenBuffer or escape sequences to terminal.
+ */
+declare const outputStore: Map<number, ViewportOutput>;
+/**
+ * Encoded output for a viewport, including positioning information.
+ */
+interface ViewportOutput {
+    /** The viewport entity this output belongs to. */
+    readonly viewportEid: Entity;
+    /** Screen column position (viewport left). */
+    readonly screenX: number;
+    /** Screen row position (viewport top). */
+    readonly screenY: number;
+    /** The backend that produced this output. */
+    readonly backendType: string;
+    /** The encoded output (cells and/or escape sequences). */
+    readonly encoded: EncodedOutput;
+}
+/**
+ * Clear the backend store. Useful for testing.
+ */
+declare function clearBackendStore(): void;
+/**
+ * Clear the output store. Useful for testing.
+ */
+declare function clearOutputStore(): void;
+/**
+ * Viewport output system. Encodes per-viewport framebuffers via their
+ * selected backend and stores the result in outputStore.
+ *
+ * Runs after rasterSystem in the RENDER phase.
+ *
+ * @param world - ECS world
+ * @returns The world (unmodified reference)
+ *
+ * @example
+ * ```typescript
+ * import { viewportOutputSystem, outputStore } from 'blecsd/3d/systems';
+ *
+ * viewportOutputSystem(world);
+ *
+ * for (const [vpEid, output] of outputStore) {
+ *   if (output.encoded.cells) {
+ *     for (const cell of output.encoded.cells) {
+ *       setCell(buffer, cell.x, cell.y, createCell(cell.char, cell.fg, cell.bg));
+ *     }
+ *   }
+ *   if (output.encoded.escape) {
+ *     process.stdout.write(output.encoded.escape);
+ *   }
+ * }
+ * ```
+ */
+declare const viewportOutputSystem: System;
+
+/**
+ * 3D rendering subsystem for blECSd.
+ *
+ * Provides a complete 3D pipeline: math, rasterization, ECS components/systems,
+ * renderer backends, and mesh loading/primitives.
+ *
+ * @module 3d
+ */
+
+type index_AmbientLight = AmbientLight;
+declare const index_AmbientLightSchema: typeof AmbientLightSchema;
+declare const index_Animation3D: typeof Animation3D;
+declare const index_Animation3DConfig: typeof Animation3DConfig;
+declare const index_Animation3DConfigSchema: typeof Animation3DConfigSchema;
+type index_Animation3DData = Animation3DData;
+type index_BackendCapabilities = BackendCapabilities;
+declare const index_BackendCapabilitiesSchema: typeof BackendCapabilitiesSchema;
+type index_BackendPreference = BackendPreference;
+declare const index_BackendPreferenceSchema: typeof BackendPreferenceSchema;
+type index_BackendSelection = BackendSelection;
+declare const index_BackendSelectionSchema: typeof BackendSelectionSchema;
+type index_BackendType = BackendType;
+declare const index_BackendTypeSchema: typeof BackendTypeSchema;
+type index_BrailleConfig = BrailleConfig;
+declare const index_BrailleConfigSchema: typeof BrailleConfigSchema;
+declare const index_Camera3D: typeof Camera3D;
+declare const index_Camera3DConfig: typeof Camera3DConfig;
+declare const index_Camera3DConfigSchema: typeof Camera3DConfigSchema;
+type index_Camera3DData = Camera3DData;
+type index_ClipRect = ClipRect;
+declare const index_ClipRectSchema: typeof ClipRectSchema;
+type index_ClippedLine = ClippedLine;
+type index_CubeMeshOptions = CubeMeshOptions;
+declare const index_CubeMeshOptionsSchema: typeof CubeMeshOptionsSchema;
+type index_CylinderMeshOptions = CylinderMeshOptions;
+declare const index_CylinderMeshOptionsSchema: typeof CylinderMeshOptionsSchema;
+type index_DirectionalLight = DirectionalLight;
+declare const index_DirectionalLightSchema: typeof DirectionalLightSchema;
+type index_EncodedCell = EncodedCell;
+declare const index_EncodedCellSchema: typeof EncodedCellSchema;
+type index_EncodedOutput = EncodedOutput;
+declare const index_EncodedOutputSchema: typeof EncodedOutputSchema;
+type index_EulerAngles = EulerAngles;
+declare const index_EulerAnglesSchema: typeof EulerAnglesSchema;
+type index_FrustumPlane = FrustumPlane;
+type index_GraphicsCapabilities = GraphicsCapabilities;
+type index_HalfBlockConfig = HalfBlockConfig;
+declare const index_HalfBlockConfigSchema: typeof HalfBlockConfigSchema;
+type index_KittyConfig = KittyConfig;
+declare const index_KittyConfigSchema: typeof KittyConfigSchema;
+type index_LineEndpoint = LineEndpoint;
+declare const index_LineEndpointSchema: typeof LineEndpointSchema;
+type index_Mat4 = Mat4;
+declare const index_Mat4Schema: typeof Mat4Schema;
+declare const index_Material3D: typeof Material3D;
+declare const index_Material3DConfig: typeof Material3DConfig;
+declare const index_Material3DConfigSchema: typeof Material3DConfigSchema;
+type index_Material3DData = Material3DData;
+declare const index_Mesh: typeof Mesh;
+type index_MeshData = MeshData;
+type index_MeshProjection = MeshProjection;
+type index_MouseDragInput = MouseDragInput;
+declare const index_MouseInteraction3D: typeof MouseInteraction3D;
+declare const index_MouseInteraction3DConfig: typeof MouseInteraction3DConfig;
+declare const index_MouseInteraction3DConfigSchema: typeof MouseInteraction3DConfigSchema;
+type index_MouseInteraction3DData = MouseInteraction3DData;
+type index_ObjFace = ObjFace;
+type index_ObjGroup = ObjGroup;
+type index_ObjLoadOptions = ObjLoadOptions;
+declare const index_ObjLoadOptionsSchema: typeof ObjLoadOptionsSchema;
+type index_ObjParseResult = ObjParseResult;
+type index_ObjVertex = ObjVertex;
+type index_OrthographicConfig = OrthographicConfig;
+declare const index_OrthographicConfigSchema: typeof OrthographicConfigSchema;
+type index_PerspectiveConfig = PerspectiveConfig;
+declare const index_PerspectiveConfigSchema: typeof PerspectiveConfigSchema;
+type index_PixelBufferConfig = PixelBufferConfig;
+declare const index_PixelBufferConfigSchema: typeof PixelBufferConfigSchema;
+type index_PixelFramebuffer = PixelFramebuffer;
+type index_PlaneMeshOptions = PlaneMeshOptions;
+declare const index_PlaneMeshOptionsSchema: typeof PlaneMeshOptionsSchema;
+type index_ProjectedVertex = ProjectedVertex;
+type index_RGBAColor = RGBAColor;
+declare const index_RGBAColorSchema: typeof RGBAColorSchema;
+type index_RendererBackend = RendererBackend;
+type index_ScreenCoord = ScreenCoord;
+type index_SextantConfig = SextantConfig;
+declare const index_SextantConfigSchema: typeof SextantConfigSchema;
+type index_SixelConfig = SixelConfig;
+declare const index_SixelConfigSchema: typeof SixelConfigSchema;
+type index_SphereMeshOptions = SphereMeshOptions;
+declare const index_SphereMeshOptionsSchema: typeof SphereMeshOptionsSchema;
+declare const index_Transform3D: typeof Transform3D;
+declare const index_Transform3DConfig: typeof Transform3DConfig;
+declare const index_Transform3DConfigSchema: typeof Transform3DConfigSchema;
+type index_Transform3DData = Transform3DData;
+type index_TriangleBBox = TriangleBBox;
+type index_TriangleVertex = TriangleVertex;
+declare const index_TriangleVertexSchema: typeof TriangleVertexSchema;
+type index_Vec3 = Vec3;
+type index_Vec3Input = Vec3Input;
+declare const index_Vec3InputSchema: typeof Vec3InputSchema;
+declare const index_Vec3Schema: typeof Vec3Schema;
+declare const index_Viewport3D: typeof Viewport3D;
+declare const index_Viewport3DConfig: typeof Viewport3DConfig;
+declare const index_Viewport3DConfigSchema: typeof Viewport3DConfigSchema;
+type index_Viewport3DData = Viewport3DData;
+declare const index_Viewport3DWidgetConfig: typeof Viewport3DWidgetConfig;
+declare const index_Viewport3DWidgetConfigSchema: typeof Viewport3DWidgetConfigSchema;
+type index_ViewportConfig = ViewportConfig;
+declare const index_ViewportConfigSchema: typeof ViewportConfigSchema;
+type index_ViewportOutput = ViewportOutput;
+type index_ViewportProjection = ViewportProjection;
+declare const index_animation3DSystem: typeof animation3DSystem;
+declare const index_backendStore: typeof backendStore;
+declare const index_blendPixel: typeof blendPixel;
+declare const index_buildMVP: typeof buildMVP;
+declare const index_clearBackendStore: typeof clearBackendStore;
+declare const index_clearFramebuffer: typeof clearFramebuffer;
+declare const index_clearFramebufferStore: typeof clearFramebufferStore;
+declare const index_clearMeshStore: typeof clearMeshStore;
+declare const index_clearMouseInputStore: typeof clearMouseInputStore;
+declare const index_clearOutputStore: typeof clearOutputStore;
+declare const index_clearProjectionStore: typeof clearProjectionStore;
+declare const index_clipLine: typeof clipLine;
+declare const index_computeBoundingBox: typeof computeBoundingBox;
+declare const index_computeFaceNormal: typeof computeFaceNormal;
+declare const index_computeFlatShading: typeof computeFlatShading;
+declare const index_computeOutcode: typeof computeOutcode;
+declare const index_createBackendByType: typeof createBackendByType;
+declare const index_createBrailleBackend: typeof createBrailleBackend;
+declare const index_createCubeMesh: typeof createCubeMesh;
+declare const index_createCylinderMesh: typeof createCylinderMesh;
+declare const index_createHalfBlockBackend: typeof createHalfBlockBackend;
+declare const index_createKittyBackend: typeof createKittyBackend;
+declare const index_createMeshFromArrays: typeof createMeshFromArrays;
+declare const index_createPixelFramebuffer: typeof createPixelFramebuffer;
+declare const index_createPlaneMesh: typeof createPlaneMesh;
+declare const index_createSextantBackend: typeof createSextantBackend;
+declare const index_createSixelBackend: typeof createSixelBackend;
+declare const index_createSphereMesh: typeof createSphereMesh;
+declare const index_detectBestBackend: typeof detectBestBackend;
+declare const index_disableMouseInteraction: typeof disableMouseInteraction;
+declare const index_drawLine: typeof drawLine;
+declare const index_drawLineAA: typeof drawLineAA;
+declare const index_drawLineColor: typeof drawLineColor;
+declare const index_drawLineDepth: typeof drawLineDepth;
+declare const index_enableMouseInteraction: typeof enableMouseInteraction;
+declare const index_extractFrustumPlanes: typeof extractFrustumPlanes;
+declare const index_feedMouseDrag: typeof feedMouseDrag;
+declare const index_feedMouseScroll: typeof feedMouseScroll;
+declare const index_fillRect: typeof fillRect;
+declare const index_fillTriangle: typeof fillTriangle;
+declare const index_fillTriangleFlat: typeof fillTriangleFlat;
+declare const index_framebufferStore: typeof framebufferStore;
+declare const index_getAnimation3D: typeof getAnimation3D;
+declare const index_getCamera3D: typeof getCamera3D;
+declare const index_getDepth: typeof getDepth;
+declare const index_getMaterial3D: typeof getMaterial3D;
+declare const index_getMesh: typeof getMesh;
+declare const index_getMeshCount: typeof getMeshCount;
+declare const index_getMeshData: typeof getMeshData;
+declare const index_getMouseInteraction3D: typeof getMouseInteraction3D;
+declare const index_getPixel: typeof getPixel;
+declare const index_getProjMatrix: typeof getProjMatrix;
+declare const index_getTransform3D: typeof getTransform3D;
+declare const index_getViewMatrix: typeof getViewMatrix;
+declare const index_getViewport3D: typeof getViewport3D;
+declare const index_getWorldMatrix: typeof getWorldMatrix;
+declare const index_isDirty: typeof isDirty;
+declare const index_isInBounds: typeof isInBounds;
+declare const index_isPointInFrustum: typeof isPointInFrustum;
+declare const index_isSphereInFrustum: typeof isSphereInFrustum;
+declare const index_loadObjAsMesh: typeof loadObjAsMesh;
+declare const index_lookAt: typeof lookAt;
+declare const index_markDirty: typeof markDirty;
+declare const index_mat4Determinant: typeof mat4Determinant;
+declare const index_mat4Equals: typeof mat4Equals;
+declare const index_mat4FromTRS: typeof mat4FromTRS;
+declare const index_mat4Identity: typeof mat4Identity;
+declare const index_mat4Invert: typeof mat4Invert;
+declare const index_mat4IsIdentity: typeof mat4IsIdentity;
+declare const index_mat4Multiply: typeof mat4Multiply;
+declare const index_mat4RotateX: typeof mat4RotateX;
+declare const index_mat4RotateY: typeof mat4RotateY;
+declare const index_mat4RotateZ: typeof mat4RotateZ;
+declare const index_mat4Scale: typeof mat4Scale;
+declare const index_mat4TransformDirection: typeof mat4TransformDirection;
+declare const index_mat4TransformVec3: typeof mat4TransformVec3;
+declare const index_mat4Translate: typeof mat4Translate;
+declare const index_mat4Transpose: typeof mat4Transpose;
+declare const index_mouseInputStore: typeof mouseInputStore;
+declare const index_mouseInteraction3DSystem: typeof mouseInteraction3DSystem;
+declare const index_orthographicMatrix: typeof orthographicMatrix;
+declare const index_outputStore: typeof outputStore;
+declare const index_parseObj: typeof parseObj;
+declare const index_perspectiveMatrix: typeof perspectiveMatrix;
+declare const index_projectVertex: typeof projectVertex;
+declare const index_projectionStore: typeof projectionStore;
+declare const index_projectionSystem: typeof projectionSystem;
+declare const index_rasterSystem: typeof rasterSystem;
+declare const index_registerMesh: typeof registerMesh;
+declare const index_sceneGraphSystem: typeof sceneGraphSystem;
+declare const index_setAnimation3D: typeof setAnimation3D;
+declare const index_setCamera3D: typeof setCamera3D;
+declare const index_setMaterial3D: typeof setMaterial3D;
+declare const index_setMesh: typeof setMesh;
+declare const index_setPixel: typeof setPixel;
+declare const index_setPixelUnsafe: typeof setPixelUnsafe;
+declare const index_setRotation: typeof setRotation;
+declare const index_setScale: typeof setScale;
+declare const index_setTransform3D: typeof setTransform3D;
+declare const index_setTranslation: typeof setTranslation;
+declare const index_setViewport3D: typeof setViewport3D;
+declare const index_shadeFace: typeof shadeFace;
+declare const index_testAndSetDepth: typeof testAndSetDepth;
+declare const index_triangleArea2: typeof triangleArea2;
+declare const index_triangleBoundingBox: typeof triangleBoundingBox;
+declare const index_unprojectVertex: typeof unprojectVertex;
+declare const index_unregisterMesh: typeof unregisterMesh;
+declare const index_vec3: typeof vec3;
+declare const index_vec3Add: typeof vec3Add;
+declare const index_vec3Cross: typeof vec3Cross;
+declare const index_vec3Distance: typeof vec3Distance;
+declare const index_vec3Dot: typeof vec3Dot;
+declare const index_vec3Equals: typeof vec3Equals;
+declare const index_vec3FromArray: typeof vec3FromArray;
+declare const index_vec3Length: typeof vec3Length;
+declare const index_vec3LengthSq: typeof vec3LengthSq;
+declare const index_vec3Lerp: typeof vec3Lerp;
+declare const index_vec3Negate: typeof vec3Negate;
+declare const index_vec3Normalize: typeof vec3Normalize;
+declare const index_vec3Scale: typeof vec3Scale;
+declare const index_vec3Sub: typeof vec3Sub;
+declare const index_vec3Zero: typeof vec3Zero;
+declare const index_viewportOutputSystem: typeof viewportOutputSystem;
+declare const index_viewportTransform: typeof viewportTransform;
+declare namespace index {
+  export { type index_AmbientLight as AmbientLight, index_AmbientLightSchema as AmbientLightSchema, index_Animation3D as Animation3D, index_Animation3DConfig as Animation3DConfig, index_Animation3DConfigSchema as Animation3DConfigSchema, type index_Animation3DData as Animation3DData, type index_BackendCapabilities as BackendCapabilities, index_BackendCapabilitiesSchema as BackendCapabilitiesSchema, type index_BackendPreference as BackendPreference, index_BackendPreferenceSchema as BackendPreferenceSchema, type index_BackendSelection as BackendSelection, index_BackendSelectionSchema as BackendSelectionSchema, type index_BackendType as BackendType, index_BackendTypeSchema as BackendTypeSchema, type index_BrailleConfig as BrailleConfig, index_BrailleConfigSchema as BrailleConfigSchema, index_Camera3D as Camera3D, index_Camera3DConfig as Camera3DConfig, index_Camera3DConfigSchema as Camera3DConfigSchema, type index_Camera3DData as Camera3DData, type index_ClipRect as ClipRect, index_ClipRectSchema as ClipRectSchema, type index_ClippedLine as ClippedLine, type index_CubeMeshOptions as CubeMeshOptions, index_CubeMeshOptionsSchema as CubeMeshOptionsSchema, type index_CylinderMeshOptions as CylinderMeshOptions, index_CylinderMeshOptionsSchema as CylinderMeshOptionsSchema, type index_DirectionalLight as DirectionalLight, index_DirectionalLightSchema as DirectionalLightSchema, type index_EncodedCell as EncodedCell, index_EncodedCellSchema as EncodedCellSchema, type index_EncodedOutput as EncodedOutput, index_EncodedOutputSchema as EncodedOutputSchema, type index_EulerAngles as EulerAngles, index_EulerAnglesSchema as EulerAnglesSchema, type index_FrustumPlane as FrustumPlane, type index_GraphicsCapabilities as GraphicsCapabilities, type index_HalfBlockConfig as HalfBlockConfig, index_HalfBlockConfigSchema as HalfBlockConfigSchema, type index_KittyConfig as KittyConfig, index_KittyConfigSchema as KittyConfigSchema, type index_LineEndpoint as LineEndpoint, index_LineEndpointSchema as LineEndpointSchema, type index_Mat4 as Mat4, index_Mat4Schema as Mat4Schema, index_Material3D as Material3D, index_Material3DConfig as Material3DConfig, index_Material3DConfigSchema as Material3DConfigSchema, type index_Material3DData as Material3DData, index_Mesh as Mesh, type index_MeshData as MeshData, type index_MeshProjection as MeshProjection, type index_MouseDragInput as MouseDragInput, index_MouseInteraction3D as MouseInteraction3D, index_MouseInteraction3DConfig as MouseInteraction3DConfig, index_MouseInteraction3DConfigSchema as MouseInteraction3DConfigSchema, type index_MouseInteraction3DData as MouseInteraction3DData, type index_ObjFace as ObjFace, type index_ObjGroup as ObjGroup, type index_ObjLoadOptions as ObjLoadOptions, index_ObjLoadOptionsSchema as ObjLoadOptionsSchema, type index_ObjParseResult as ObjParseResult, type index_ObjVertex as ObjVertex, type index_OrthographicConfig as OrthographicConfig, index_OrthographicConfigSchema as OrthographicConfigSchema, type index_PerspectiveConfig as PerspectiveConfig, index_PerspectiveConfigSchema as PerspectiveConfigSchema, type index_PixelBufferConfig as PixelBufferConfig, index_PixelBufferConfigSchema as PixelBufferConfigSchema, type index_PixelFramebuffer as PixelFramebuffer, type index_PlaneMeshOptions as PlaneMeshOptions, index_PlaneMeshOptionsSchema as PlaneMeshOptionsSchema, type index_ProjectedVertex as ProjectedVertex, type index_RGBAColor as RGBAColor, index_RGBAColorSchema as RGBAColorSchema, type index_RendererBackend as RendererBackend, type index_ScreenCoord as ScreenCoord, type index_SextantConfig as SextantConfig, index_SextantConfigSchema as SextantConfigSchema, type index_SixelConfig as SixelConfig, index_SixelConfigSchema as SixelConfigSchema, type index_SphereMeshOptions as SphereMeshOptions, index_SphereMeshOptionsSchema as SphereMeshOptionsSchema, index_Transform3D as Transform3D, index_Transform3DConfig as Transform3DConfig, index_Transform3DConfigSchema as Transform3DConfigSchema, type index_Transform3DData as Transform3DData, type index_TriangleBBox as TriangleBBox, type index_TriangleVertex as TriangleVertex, index_TriangleVertexSchema as TriangleVertexSchema, type index_Vec3 as Vec3, type index_Vec3Input as Vec3Input, index_Vec3InputSchema as Vec3InputSchema, index_Vec3Schema as Vec3Schema, index_Viewport3D as Viewport3D, index_Viewport3DConfig as Viewport3DConfig, index_Viewport3DConfigSchema as Viewport3DConfigSchema, type index_Viewport3DData as Viewport3DData, index_Viewport3DWidgetConfig as Viewport3DWidgetConfig, index_Viewport3DWidgetConfigSchema as Viewport3DWidgetConfigSchema, type index_ViewportConfig as ViewportConfig, index_ViewportConfigSchema as ViewportConfigSchema, type index_ViewportOutput as ViewportOutput, type index_ViewportProjection as ViewportProjection, index_animation3DSystem as animation3DSystem, index_backendStore as backendStore, index_blendPixel as blendPixel, index_buildMVP as buildMVP, index_clearBackendStore as clearBackendStore, index_clearFramebuffer as clearFramebuffer, index_clearFramebufferStore as clearFramebufferStore, index_clearMeshStore as clearMeshStore, index_clearMouseInputStore as clearMouseInputStore, index_clearOutputStore as clearOutputStore, index_clearProjectionStore as clearProjectionStore, index_clipLine as clipLine, index_computeBoundingBox as computeBoundingBox, index_computeFaceNormal as computeFaceNormal, index_computeFlatShading as computeFlatShading, index_computeOutcode as computeOutcode, index_createBackendByType as createBackendByType, index_createBrailleBackend as createBrailleBackend, index_createCubeMesh as createCubeMesh, index_createCylinderMesh as createCylinderMesh, index_createHalfBlockBackend as createHalfBlockBackend, index_createKittyBackend as createKittyBackend, index_createMeshFromArrays as createMeshFromArrays, index_createPixelFramebuffer as createPixelFramebuffer, index_createPlaneMesh as createPlaneMesh, index_createSextantBackend as createSextantBackend, index_createSixelBackend as createSixelBackend, index_createSphereMesh as createSphereMesh, index_detectBestBackend as detectBestBackend, index_disableMouseInteraction as disableMouseInteraction, index_drawLine as drawLine, index_drawLineAA as drawLineAA, index_drawLineColor as drawLineColor, index_drawLineDepth as drawLineDepth, index_enableMouseInteraction as enableMouseInteraction, index_extractFrustumPlanes as extractFrustumPlanes, index_feedMouseDrag as feedMouseDrag, index_feedMouseScroll as feedMouseScroll, index_fillRect as fillRect, index_fillTriangle as fillTriangle, index_fillTriangleFlat as fillTriangleFlat, index_framebufferStore as framebufferStore, index_getAnimation3D as getAnimation3D, index_getCamera3D as getCamera3D, index_getDepth as getDepth, index_getMaterial3D as getMaterial3D, index_getMesh as getMesh, index_getMeshCount as getMeshCount, index_getMeshData as getMeshData, index_getMouseInteraction3D as getMouseInteraction3D, index_getPixel as getPixel, index_getProjMatrix as getProjMatrix, index_getTransform3D as getTransform3D, index_getViewMatrix as getViewMatrix, index_getViewport3D as getViewport3D, index_getWorldMatrix as getWorldMatrix, index_isDirty as isDirty, index_isInBounds as isInBounds, index_isPointInFrustum as isPointInFrustum, index_isSphereInFrustum as isSphereInFrustum, index_loadObjAsMesh as loadObjAsMesh, index_lookAt as lookAt, index_markDirty as markDirty, index_mat4Determinant as mat4Determinant, index_mat4Equals as mat4Equals, index_mat4FromTRS as mat4FromTRS, index_mat4Identity as mat4Identity, index_mat4Invert as mat4Invert, index_mat4IsIdentity as mat4IsIdentity, index_mat4Multiply as mat4Multiply, index_mat4RotateX as mat4RotateX, index_mat4RotateY as mat4RotateY, index_mat4RotateZ as mat4RotateZ, index_mat4Scale as mat4Scale, index_mat4TransformDirection as mat4TransformDirection, index_mat4TransformVec3 as mat4TransformVec3, index_mat4Translate as mat4Translate, index_mat4Transpose as mat4Transpose, index_mouseInputStore as mouseInputStore, index_mouseInteraction3DSystem as mouseInteraction3DSystem, index_orthographicMatrix as orthographicMatrix, index_outputStore as outputStore, index_parseObj as parseObj, index_perspectiveMatrix as perspectiveMatrix, index_projectVertex as projectVertex, index_projectionStore as projectionStore, index_projectionSystem as projectionSystem, index_rasterSystem as rasterSystem, index_registerMesh as registerMesh, index_sceneGraphSystem as sceneGraphSystem, index_setAnimation3D as setAnimation3D, index_setCamera3D as setCamera3D, index_setMaterial3D as setMaterial3D, index_setMesh as setMesh, index_setPixel as setPixel, index_setPixelUnsafe as setPixelUnsafe, index_setRotation as setRotation, index_setScale as setScale, index_setTransform3D as setTransform3D, index_setTranslation as setTranslation, index_setViewport3D as setViewport3D, index_shadeFace as shadeFace, index_testAndSetDepth as testAndSetDepth, index_triangleArea2 as triangleArea2, index_triangleBoundingBox as triangleBoundingBox, index_unprojectVertex as unprojectVertex, index_unregisterMesh as unregisterMesh, index_vec3 as vec3, index_vec3Add as vec3Add, index_vec3Cross as vec3Cross, index_vec3Distance as vec3Distance, index_vec3Dot as vec3Dot, index_vec3Equals as vec3Equals, index_vec3FromArray as vec3FromArray, index_vec3Length as vec3Length, index_vec3LengthSq as vec3LengthSq, index_vec3Lerp as vec3Lerp, index_vec3Negate as vec3Negate, index_vec3Normalize as vec3Normalize, index_vec3Scale as vec3Scale, index_vec3Sub as vec3Sub, index_vec3Zero as vec3Zero, index_viewportOutputSystem as viewportOutputSystem, index_viewportTransform as viewportTransform };
+}
+
+export { ObjLoadOptionsSchema as $, type AmbientLight as A, type BackendCapabilities as B, Camera3D as C, type DirectionalLight as D, type EncodedCell as E, EulerAnglesSchema as F, type FrustumPlane as G, type GraphicsCapabilities as H, type HalfBlockConfig as I, HalfBlockConfigSchema as J, type KittyConfig as K, KittyConfigSchema as L, type LineEndpoint as M, LineEndpointSchema as N, type Mat4 as O, Mat4Schema as P, Material3D as Q, type Material3DData as R, Mesh as S, type MeshData as T, type MeshProjection as U, type MouseDragInput as V, MouseInteraction3D as W, type MouseInteraction3DData as X, type ObjFace as Y, type ObjGroup as Z, type ObjLoadOptions as _, AmbientLightSchema as a, createSixelBackend as a$, type ObjParseResult as a0, type ObjVertex as a1, type OrthographicConfig as a2, OrthographicConfigSchema as a3, type PerspectiveConfig as a4, PerspectiveConfigSchema as a5, type PixelBufferConfig as a6, PixelBufferConfigSchema as a7, type PixelFramebuffer as a8, type PlaneMeshOptions as a9, type ViewportProjection as aA, animation3DSystem as aB, backendStore as aC, blendPixel as aD, buildMVP as aE, clearBackendStore as aF, clearFramebuffer as aG, clearFramebufferStore as aH, clearMeshStore as aI, clearMouseInputStore as aJ, clearOutputStore as aK, clearProjectionStore as aL, clipLine as aM, computeBoundingBox as aN, computeFaceNormal as aO, computeFlatShading as aP, computeOutcode as aQ, createBackendByType as aR, createBrailleBackend as aS, createCubeMesh as aT, createCylinderMesh as aU, createHalfBlockBackend as aV, createKittyBackend as aW, createMeshFromArrays as aX, createPixelFramebuffer as aY, createPlaneMesh as aZ, createSextantBackend as a_, PlaneMeshOptionsSchema as aa, type ProjectedVertex as ab, type RGBAColor as ac, RGBAColorSchema as ad, type RendererBackend as ae, type ScreenCoord as af, type SextantConfig as ag, SextantConfigSchema as ah, type SixelConfig as ai, SixelConfigSchema as aj, type SphereMeshOptions as ak, SphereMeshOptionsSchema as al, Transform3D as am, type Transform3DData as an, type TriangleBBox as ao, type TriangleVertex as ap, TriangleVertexSchema as aq, type Vec3 as ar, type Vec3Input as as, Vec3InputSchema as at, Vec3Schema as au, Viewport3D as av, type Viewport3DData as aw, type ViewportConfig as ax, ViewportConfigSchema as ay, type ViewportOutput as az, Animation3D as b, setAnimation3D as b$, createSphereMesh as b0, detectBestBackend as b1, disableMouseInteraction as b2, drawLine as b3, drawLineAA as b4, drawLineColor as b5, drawLineDepth as b6, enableMouseInteraction as b7, extractFrustumPlanes as b8, feedMouseDrag as b9, mat4Determinant as bA, mat4Equals as bB, mat4FromTRS as bC, mat4Identity as bD, mat4Invert as bE, mat4IsIdentity as bF, mat4Multiply as bG, mat4RotateX as bH, mat4RotateY as bI, mat4RotateZ as bJ, mat4Scale as bK, mat4TransformDirection as bL, mat4TransformVec3 as bM, mat4Translate as bN, mat4Transpose as bO, mouseInputStore as bP, mouseInteraction3DSystem as bQ, orthographicMatrix as bR, outputStore as bS, parseObj as bT, perspectiveMatrix as bU, projectVertex as bV, projectionStore as bW, projectionSystem as bX, rasterSystem as bY, registerMesh as bZ, sceneGraphSystem as b_, feedMouseScroll as ba, fillRect as bb, fillTriangle as bc, fillTriangleFlat as bd, framebufferStore as be, getAnimation3D as bf, getCamera3D as bg, getDepth as bh, getMaterial3D as bi, getMesh as bj, getMeshCount as bk, getMeshData as bl, getMouseInteraction3D as bm, getPixel as bn, getProjMatrix as bo, getTransform3D as bp, getViewMatrix as bq, getViewport3D as br, getWorldMatrix as bs, isDirty as bt, isInBounds as bu, isPointInFrustum as bv, isSphereInFrustum as bw, loadObjAsMesh as bx, lookAt as by, markDirty as bz, type Animation3DData as c, setCamera3D as c0, setMaterial3D as c1, setMesh as c2, setPixel as c3, setPixelUnsafe as c4, setRotation as c5, setScale as c6, setTransform3D as c7, setTranslation as c8, setViewport3D as c9, shadeFace as ca, testAndSetDepth as cb, triangleArea2 as cc, triangleBoundingBox as cd, unprojectVertex as ce, unregisterMesh as cf, vec3 as cg, vec3Add as ch, vec3Cross as ci, vec3Distance as cj, vec3Dot as ck, vec3Equals as cl, vec3FromArray as cm, vec3Length as cn, vec3LengthSq as co, vec3Lerp as cp, vec3Negate as cq, vec3Normalize as cr, vec3Scale as cs, vec3Sub as ct, vec3Zero as cu, viewportOutputSystem as cv, viewportTransform as cw, BackendCapabilitiesSchema as d, type BackendPreference as e, BackendPreferenceSchema as f, type BackendSelection as g, BackendSelectionSchema as h, index as i, type BackendType as j, BackendTypeSchema as k, type BrailleConfig as l, BrailleConfigSchema as m, type Camera3DData as n, type ClipRect as o, ClipRectSchema as p, type ClippedLine as q, type CubeMeshOptions as r, CubeMeshOptionsSchema as s, type CylinderMeshOptions as t, CylinderMeshOptionsSchema as u, DirectionalLightSchema as v, EncodedCellSchema as w, type EncodedOutput as x, EncodedOutputSchema as y, type EulerAngles as z };