@codexo/exojs 0.8.4 → 0.10.0

package/dist/esm/audio/worklets/granular.worklet.js

@@ -0,0 +1,89 @@
+const granularWorkletSource = `
+const sampleRate = globalThis.sampleRate;
+
+class GranularProcessor extends AudioWorkletProcessor {
+    static get parameterDescriptors() {
+        return [
+            { name: 'grainSize', defaultValue: 0.05, minValue: 0.005, maxValue: 0.5, automationRate: 'k-rate' },
+            { name: 'density', defaultValue: 50, minValue: 1, maxValue: 500, automationRate: 'k-rate' },
+            { name: 'spread', defaultValue: 0.5, minValue: 0, maxValue: 1.0, automationRate: 'k-rate' },
+            { name: 'pitchMin', defaultValue: 1.0, minValue: 0.25, maxValue: 4.0, automationRate: 'k-rate' },
+            { name: 'pitchMax', defaultValue: 1.0, minValue: 0.25, maxValue: 4.0, automationRate: 'k-rate' },
+            { name: 'wet', defaultValue: 1.0, minValue: 0, maxValue: 1.0, automationRate: 'k-rate' },
+        ];
+    }
+
+    constructor(options) {
+        super();
+        const opts = options.processorOptions ?? {};
+        const bufferSeconds = opts.bufferSeconds ?? 2;
+        this._bufferLength = Math.floor(bufferSeconds * sampleRate);
+        this._buffer = new Float32Array(this._bufferLength);
+        this._writePos = 0;
+        this._timeUntilNextGrainSamples = 0;
+        this._grains = [];  // { startPos, ageSamples, lengthSamples, pitch }
+    }
+
+    process(inputs, outputs, parameters) {
+        const input = inputs[0]?.[0];
+        const output = outputs[0]?.[0];
+        if (!input || !output) return true;
+
+        const grainSize = parameters.grainSize[0];
+        const density = parameters.density[0];
+        const spread = parameters.spread[0];
+        const pitchMin = parameters.pitchMin[0];
+        const pitchMax = parameters.pitchMax[0];
+        const wet = parameters.wet[0];
+
+        const grainSizeSamples = Math.max(8, Math.floor(grainSize * sampleRate));
+        const samplesPerGrain = sampleRate / Math.max(1, density);
+
+        for (let i = 0; i < input.length; i++) {
+            // Write input to circular buffer
+            this._buffer[this._writePos] = input[i];
+            this._writePos = (this._writePos + 1) % this._bufferLength;
+
+            // Spawn new grain if scheduled
+            this._timeUntilNextGrainSamples -= 1;
+            if (this._timeUntilNextGrainSamples <= 0) {
+                // Random offset into recent past, biased by spread
+                const maxOffset = Math.floor(spread * this._bufferLength);
+                const offset = Math.floor(Math.random() * Math.max(1, maxOffset));
+                const startPos = (this._writePos - offset - grainSizeSamples + this._bufferLength) % this._bufferLength;
+                // Random pitch in [pitchMin, pitchMax]
+                const pitch = pitchMin + Math.random() * Math.max(0, pitchMax - pitchMin);
+
+                this._grains.push({ startPos, ageSamples: 0, lengthSamples: grainSizeSamples, pitch });
+                this._timeUntilNextGrainSamples = samplesPerGrain;
+            }
+
+            // Mix all active grains (apply Hann window)
+            let grainSum = 0;
+            for (let g = this._grains.length - 1; g >= 0; g--) {
+                const grain = this._grains[g];
+                if (grain.ageSamples >= grain.lengthSamples) {
+                    this._grains.splice(g, 1);
+                    continue;
+                }
+
+                const phase = grain.ageSamples / grain.lengthSamples;
+                const window = 0.5 * (1 - Math.cos(2 * Math.PI * phase));
+                const readPos = grain.startPos + grain.ageSamples * grain.pitch;
+                const sampleIndex = Math.floor(readPos) % this._bufferLength;
+                const safeIndex = (sampleIndex + this._bufferLength) % this._bufferLength;
+                grainSum += this._buffer[safeIndex] * window;
+
+                grain.ageSamples++;
+            }
+
+            output[i] = (1 - wet) * input[i] + wet * grainSum;
+        }
+        return true;
+    }
+}
+registerProcessor('exojs-granular', GranularProcessor);
+`;
+
+export { granularWorkletSource };
+//# sourceMappingURL=granular.worklet.js.map

package/dist/esm/audio/worklets/granular.worklet.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"granular.worklet.js","sources":["../../../../../src/audio/worklets/granular.worklet.ts"],"sourcesContent":[null],"names":[],"mappings":"AAAO,MAAM,qBAAqB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/esm/audio/worklets/pitch-shift.worklet.d.ts

@@ -0,0 +1 @@
+export declare const pitchShiftWorkletSource = "\nclass PitchShiftProcessor extends AudioWorkletProcessor {\n    static get parameterDescriptors() {\n        return [\n            { name: 'pitch', defaultValue: 1.0, minValue: 0.25, maxValue: 4.0, automationRate: 'k-rate' },\n            { name: 'wet', defaultValue: 1.0, minValue: 0, maxValue: 1.0, automationRate: 'k-rate' },\n        ];\n    }\n\n    constructor(options) {\n        super();\n        const grainSize = options.processorOptions?.grainSize ?? 1024;\n        this._grainSize = grainSize;\n        this._bufferLength = grainSize * 4;\n        this._buffer = new Float32Array(this._bufferLength);\n        this._writePos = 0;\n        // Two staggered read positions for overlap-add\n        this._readPosA = 0;\n        this._readPosB = grainSize / 2;\n        this._hannWindow = this._buildHannWindow(grainSize);\n    }\n\n    _buildHannWindow(n) {\n        const w = new Float32Array(n);\n        for (let i = 0; i < n; i++) {\n            w[i] = 0.5 * (1 - Math.cos(2 * Math.PI * i / (n - 1)));\n        }\n        return w;\n    }\n\n    _readGrain(readPos) {\n        const grainSize = this._grainSize;\n        const sampleIndex = Math.floor(readPos);\n        const phase = sampleIndex % grainSize;  // position within the grain envelope\n        const win = this._hannWindow[phase];\n        const bufferIndex = ((this._writePos - this._bufferLength + sampleIndex) % this._bufferLength + this._bufferLength) % this._bufferLength;\n        return this._buffer[bufferIndex] * win;\n    }\n\n    process(inputs, outputs, parameters) {\n        const input = inputs[0]?.[0];\n        const output = outputs[0]?.[0];\n        if (!input || !output) return true;\n\n        const pitch = parameters.pitch[0];\n        const wet = parameters.wet[0];\n\n        for (let i = 0; i < input.length; i++) {\n            // Write to circular buffer\n            this._buffer[this._writePos] = input[i];\n            this._writePos = (this._writePos + 1) % this._bufferLength;\n\n            // Read two grains and sum\n            const grainA = this._readGrain(this._readPosA);\n            const grainB = this._readGrain(this._readPosB);\n            const shifted = grainA + grainB;\n\n            // Mix with dry\n            output[i] = (1 - wet) * input[i] + wet * shifted;\n\n            // Advance read positions at pitch rate\n            this._readPosA += pitch;\n            this._readPosB += pitch;\n            if (this._readPosA >= this._grainSize) this._readPosA -= this._grainSize;\n            if (this._readPosB >= this._grainSize) this._readPosB -= this._grainSize;\n        }\n        return true;\n    }\n}\nregisterProcessor('exojs-pitch-shift', PitchShiftProcessor);\n";

package/dist/esm/audio/worklets/pitch-shift.worklet.js

@@ -0,0 +1,74 @@
+const pitchShiftWorkletSource = `
+class PitchShiftProcessor extends AudioWorkletProcessor {
+    static get parameterDescriptors() {
+        return [
+            { name: 'pitch', defaultValue: 1.0, minValue: 0.25, maxValue: 4.0, automationRate: 'k-rate' },
+            { name: 'wet', defaultValue: 1.0, minValue: 0, maxValue: 1.0, automationRate: 'k-rate' },
+        ];
+    }
+
+    constructor(options) {
+        super();
+        const grainSize = options.processorOptions?.grainSize ?? 1024;
+        this._grainSize = grainSize;
+        this._bufferLength = grainSize * 4;
+        this._buffer = new Float32Array(this._bufferLength);
+        this._writePos = 0;
+        // Two staggered read positions for overlap-add
+        this._readPosA = 0;
+        this._readPosB = grainSize / 2;
+        this._hannWindow = this._buildHannWindow(grainSize);
+    }
+
+    _buildHannWindow(n) {
+        const w = new Float32Array(n);
+        for (let i = 0; i < n; i++) {
+            w[i] = 0.5 * (1 - Math.cos(2 * Math.PI * i / (n - 1)));
+        }
+        return w;
+    }
+
+    _readGrain(readPos) {
+        const grainSize = this._grainSize;
+        const sampleIndex = Math.floor(readPos);
+        const phase = sampleIndex % grainSize;  // position within the grain envelope
+        const win = this._hannWindow[phase];
+        const bufferIndex = ((this._writePos - this._bufferLength + sampleIndex) % this._bufferLength + this._bufferLength) % this._bufferLength;
+        return this._buffer[bufferIndex] * win;
+    }
+
+    process(inputs, outputs, parameters) {
+        const input = inputs[0]?.[0];
+        const output = outputs[0]?.[0];
+        if (!input || !output) return true;
+
+        const pitch = parameters.pitch[0];
+        const wet = parameters.wet[0];
+
+        for (let i = 0; i < input.length; i++) {
+            // Write to circular buffer
+            this._buffer[this._writePos] = input[i];
+            this._writePos = (this._writePos + 1) % this._bufferLength;
+
+            // Read two grains and sum
+            const grainA = this._readGrain(this._readPosA);
+            const grainB = this._readGrain(this._readPosB);
+            const shifted = grainA + grainB;
+
+            // Mix with dry
+            output[i] = (1 - wet) * input[i] + wet * shifted;
+
+            // Advance read positions at pitch rate
+            this._readPosA += pitch;
+            this._readPosB += pitch;
+            if (this._readPosA >= this._grainSize) this._readPosA -= this._grainSize;
+            if (this._readPosB >= this._grainSize) this._readPosB -= this._grainSize;
+        }
+        return true;
+    }
+}
+registerProcessor('exojs-pitch-shift', PitchShiftProcessor);
+`;
+
+export { pitchShiftWorkletSource };
+//# sourceMappingURL=pitch-shift.worklet.js.map

package/dist/esm/audio/worklets/pitch-shift.worklet.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pitch-shift.worklet.js","sources":["../../../../../src/audio/worklets/pitch-shift.worklet.ts"],"sourcesContent":[null],"names":[],"mappings":"AAAO,MAAM,uBAAuB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/esm/audio/worklets/vocoder.worklet.d.ts

@@ -0,0 +1 @@
+export declare const vocoderWorkletSource = "\nconst sampleRate = globalThis.sampleRate;\n\nclass VocoderProcessor extends AudioWorkletProcessor {\n    static get parameterDescriptors() {\n        return [\n            { name: 'wet', defaultValue: 1.0, minValue: 0, maxValue: 1.0, automationRate: 'k-rate' },\n            { name: 'envelopeSmoothing', defaultValue: 0.005, minValue: 0.0001, maxValue: 0.1, automationRate: 'k-rate' },\n        ];\n    }\n\n    constructor(options) {\n        super();\n        const opts = options.processorOptions ?? {};\n        const bandCount = opts.numBands ?? 16;\n        const minHz = opts.minHz ?? 80;\n        const maxHz = opts.maxHz ?? 8000;\n        const Q = opts.bandQ ?? 4;\n\n        // Log-spaced band centers + biquad coefficients\n        this._bands = [];\n        for (let i = 0; i < bandCount; i++) {\n            const ratio = bandCount === 1 ? 0 : i / (bandCount - 1);\n            const centerHz = minHz * Math.pow(maxHz / minHz, ratio);\n            const omega = 2 * Math.PI * centerHz / sampleRate;\n            const cos = Math.cos(omega);\n            const sin = Math.sin(omega);\n            const alpha = sin / (2 * Q);\n\n            // Bandpass (constant 0 dB peak) biquad\n            const a0 = 1 + alpha;\n            const b0 = alpha / a0;\n            const b1 = 0;\n            const b2 = -alpha / a0;\n            const a1 = (-2 * cos) / a0;\n            const a2 = (1 - alpha) / a0;\n            this._bands.push({ b0, b1, b2, a1, a2 });\n        }\n\n        // Per-band biquad state (one for carrier, one for modulator)\n        this._carrierStates = this._bands.map(() => ({ x1: 0, x2: 0, y1: 0, y2: 0 }));\n        this._modulatorStates = this._bands.map(() => ({ x1: 0, x2: 0, y1: 0, y2: 0 }));\n\n        // Per-band envelope follower\n        this._envelopes = new Float32Array(bandCount);\n    }\n\n    _processBiquad(state, coef, x) {\n        const y = coef.b0 * x + coef.b1 * state.x1 + coef.b2 * state.x2 - coef.a1 * state.y1 - coef.a2 * state.y2;\n        state.x2 = state.x1; state.x1 = x;\n        state.y2 = state.y1; state.y1 = y;\n        return y;\n    }\n\n    process(inputs, outputs, parameters) {\n        const carrier = inputs[0]?.[0];\n        const modulator = inputs[1]?.[0];\n        const output = outputs[0]?.[0];\n        if (!carrier || !output) return true;\n\n        const wet = parameters.wet[0];\n        const envSmoothing = parameters.envelopeSmoothing[0];\n        const bandCount = this._bands.length;\n\n        for (let i = 0; i < carrier.length; i++) {\n            const carrierSample = carrier[i];\n            const modulatorSample = modulator?.[i] ?? 0;\n\n            let bandSum = 0;\n            for (let b = 0; b < bandCount; b++) {\n                const coef = this._bands[b];\n\n                // Modulator band \u2192 envelope follower\n                const modBand = this._processBiquad(this._modulatorStates[b], coef, modulatorSample);\n                const target = Math.abs(modBand);\n                this._envelopes[b] += (target - this._envelopes[b]) * envSmoothing;\n\n                // Carrier band, scaled by modulator envelope\n                const carBand = this._processBiquad(this._carrierStates[b], coef, carrierSample);\n                bandSum += carBand * this._envelopes[b];\n            }\n\n            output[i] = (1 - wet) * carrierSample + wet * bandSum;\n        }\n        return true;\n    }\n}\nregisterProcessor('exojs-vocoder', VocoderProcessor);\n";

package/dist/esm/audio/worklets/vocoder.worklet.js

@@ -0,0 +1,92 @@
+const vocoderWorkletSource = `
+const sampleRate = globalThis.sampleRate;
+
+class VocoderProcessor extends AudioWorkletProcessor {
+    static get parameterDescriptors() {
+        return [
+            { name: 'wet', defaultValue: 1.0, minValue: 0, maxValue: 1.0, automationRate: 'k-rate' },
+            { name: 'envelopeSmoothing', defaultValue: 0.005, minValue: 0.0001, maxValue: 0.1, automationRate: 'k-rate' },
+        ];
+    }
+
+    constructor(options) {
+        super();
+        const opts = options.processorOptions ?? {};
+        const bandCount = opts.numBands ?? 16;
+        const minHz = opts.minHz ?? 80;
+        const maxHz = opts.maxHz ?? 8000;
+        const Q = opts.bandQ ?? 4;
+
+        // Log-spaced band centers + biquad coefficients
+        this._bands = [];
+        for (let i = 0; i < bandCount; i++) {
+            const ratio = bandCount === 1 ? 0 : i / (bandCount - 1);
+            const centerHz = minHz * Math.pow(maxHz / minHz, ratio);
+            const omega = 2 * Math.PI * centerHz / sampleRate;
+            const cos = Math.cos(omega);
+            const sin = Math.sin(omega);
+            const alpha = sin / (2 * Q);
+
+            // Bandpass (constant 0 dB peak) biquad
+            const a0 = 1 + alpha;
+            const b0 = alpha / a0;
+            const b1 = 0;
+            const b2 = -alpha / a0;
+            const a1 = (-2 * cos) / a0;
+            const a2 = (1 - alpha) / a0;
+            this._bands.push({ b0, b1, b2, a1, a2 });
+        }
+
+        // Per-band biquad state (one for carrier, one for modulator)
+        this._carrierStates = this._bands.map(() => ({ x1: 0, x2: 0, y1: 0, y2: 0 }));
+        this._modulatorStates = this._bands.map(() => ({ x1: 0, x2: 0, y1: 0, y2: 0 }));
+
+        // Per-band envelope follower
+        this._envelopes = new Float32Array(bandCount);
+    }
+
+    _processBiquad(state, coef, x) {
+        const y = coef.b0 * x + coef.b1 * state.x1 + coef.b2 * state.x2 - coef.a1 * state.y1 - coef.a2 * state.y2;
+        state.x2 = state.x1; state.x1 = x;
+        state.y2 = state.y1; state.y1 = y;
+        return y;
+    }
+
+    process(inputs, outputs, parameters) {
+        const carrier = inputs[0]?.[0];
+        const modulator = inputs[1]?.[0];
+        const output = outputs[0]?.[0];
+        if (!carrier || !output) return true;
+
+        const wet = parameters.wet[0];
+        const envSmoothing = parameters.envelopeSmoothing[0];
+        const bandCount = this._bands.length;
+
+        for (let i = 0; i < carrier.length; i++) {
+            const carrierSample = carrier[i];
+            const modulatorSample = modulator?.[i] ?? 0;
+
+            let bandSum = 0;
+            for (let b = 0; b < bandCount; b++) {
+                const coef = this._bands[b];
+
+                // Modulator band → envelope follower
+                const modBand = this._processBiquad(this._modulatorStates[b], coef, modulatorSample);
+                const target = Math.abs(modBand);
+                this._envelopes[b] += (target - this._envelopes[b]) * envSmoothing;
+
+                // Carrier band, scaled by modulator envelope
+                const carBand = this._processBiquad(this._carrierStates[b], coef, carrierSample);
+                bandSum += carBand * this._envelopes[b];
+            }
+
+            output[i] = (1 - wet) * carrierSample + wet * bandSum;
+        }
+        return true;
+    }
+}
+registerProcessor('exojs-vocoder', VocoderProcessor);
+`;
+
+export { vocoderWorkletSource };
+//# sourceMappingURL=vocoder.worklet.js.map

package/dist/esm/audio/worklets/vocoder.worklet.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vocoder.worklet.js","sources":["../../../../../src/audio/worklets/vocoder.worklet.ts"],"sourcesContent":[null],"names":[],"mappings":"AAAO,MAAM,oBAAoB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/esm/core/Application.d.ts

@@ -5,37 +5,59 @@ import type { GamepadSlotStrategy } from '@/input/InputManager';
 import { InputManager } from '@/input/InputManager';
 import { InteractionManager } from '@/input/InteractionManager';
 import type { RenderBackend } from '@/rendering/RenderBackend';
+import { RenderingContext, type RenderToOptions } from '@/rendering/RenderingContext';
+import { type RenderNode } from '@/rendering/RenderNode';
+import type { RenderTexture } from '@/rendering/texture/RenderTexture';
 import { Texture } from '@/rendering/texture/Texture';
-import type { CacheStore } from '@/resources/CacheStore';
-import { Loader } from '@/resources/Loader';
+import { Loader, type LoaderOptions } from '@/resources/Loader';
 import { Capabilities } from './capabilities';
 import { Color } from './Color';
 import type { Scene } from './Scene';
 import { SceneManager } from './SceneManager';
 import { Signal } from './Signal';
-import type { Time } from './Time';
+import { Time } from './Time';
 export declare enum ApplicationStatus {
     Loading = 1,
     Running = 2,
     Halting = 3,
     Stopped = 4
 }
+export interface CanvasApplicationOptions {
+    /** Existing canvas element to use. If omitted, Application creates one. */
+    element?: HTMLCanvasElement;
+    /** Logical canvas width. Default: 800. */
+    width?: number;
+    /** Logical canvas height. Default: 600. */
+    height?: number;
+    /** Device/render pixel ratio applied to the backing buffer. Default: 1. */
+    pixelRatio?: number;
+    /** Canvas tabIndex. Default: -1, preserving current behavior. */
+    tabIndex?: number;
+    /** CSS image-rendering hint applied to the canvas style. */
+    imageRendering?: 'auto' | 'pixelated' | 'crisp-edges';
+}
+export interface RenderingApplicationOptions {
+    /** WebGL2-only debug wrapper. Ignored by WebGPU. */
+    debug?: boolean;
+    /** WebGL2 context attributes. Ignored by WebGPU. */
+    webglAttributes?: WebGLContextAttributes;
+    /** WebGL2 sprite renderer batch size. Ignored by WebGPU. */
+    spriteRendererBatchSize?: number;
+    /** WebGL2 particle renderer batch size. Ignored by WebGPU. */
+    particleRendererBatchSize?: number;
+}
+export interface InputApplicationOptions {
+    gamepadDefinitions?: GamepadDefinition[];
+    gamepadSlotStrategy?: GamepadSlotStrategy;
+    pointerDistanceThreshold?: number;
+}
 export interface ApplicationOptions {
-    canvas: HTMLCanvasElement;
-    width: number;
-    height: number;
-    debug: boolean;
-    clearColor: Color;
-    spriteRendererBatchSize: number;
-    particleRendererBatchSize: number;
-    gamepadDefinitions: GamepadDefinition[];
-    gamepadSlotStrategy: GamepadSlotStrategy;
-    pointerDistanceThreshold: number;
-    webglAttributes: WebGLContextAttributes;
-    resourcePath: string;
-    requestOptions: RequestInit;
-    cache?: CacheStore | readonly CacheStore[];
+    clearColor?: Color;
     backend?: BackendConfig;
+    canvas?: CanvasApplicationOptions;
+    loader?: LoaderOptions;
+    rendering?: RenderingApplicationOptions;
+    input?: InputApplicationOptions;
 }
 export interface WebGl2BackendConfig {
     type: 'webgl2';
@@ -46,11 +68,6 @@ export interface WebGpuBackendConfig {
 export interface AutoBackendConfig {
     type: 'auto';
 }
-/**
- * Discriminated union of backend selection options. `'auto'` picks WebGPU
- * when available, falling back to WebGL2 if adapter acquisition fails;
- * the explicit values pin the choice and skip the fallback path.
- */
 export type BackendConfig = AutoBackendConfig | WebGl2BackendConfig | WebGpuBackendConfig;
 /**
  * Top-level engine instance. Owns the canvas, render backend, scene-stack
@@ -81,7 +98,7 @@ export declare class Application {
     readonly loader: Loader;
     readonly input: InputManager;
     readonly interaction: InteractionManager;
-    readonly sceneManager: SceneManager;
+    readonly scene: SceneManager;
     readonly tweens: TweenManager;
     readonly onResize: Signal<[number, number, Application]>;
     readonly onFrame: Signal<[Time]>;
@@ -95,21 +112,37 @@ export declare class Application {
     private readonly _activeClock;
     private readonly _frameClock;
     private _status;
+    private _pixelRatio;
     private _frameCount;
     private _frameRequest;
     private _backendType;
     private _backend;
+    private _rendering;
     private _capabilities;
     private _documentVisible;
     private _cursor;
     private readonly _visibilityChangeHandler;
-    constructor(appSettings?: Partial<ApplicationOptions>);
+    constructor(appSettings?: ApplicationOptions);
     get status(): ApplicationStatus;
     get startupTime(): Time;
     get activeTime(): Time;
     get frameTime(): Time;
     get frameCount(): number;
+    /**
+     * Low-level render backend. Prefer the high-level
+     * {@link Application.rendering} render context for normal rendering.
+     * Direct backend access is an escape hatch for custom render passes
+     * and advanced GPU work.
+     * @advanced
+     */
     get backend(): RenderBackend;
+    /**
+     * High-level rendering context. Routes scene drawing through the
+     * RenderPlan pipeline (build → optimize → play) and provides off-screen
+     * capture via {@link RenderingContext.renderTo}. Exposes the raw
+     * {@link RenderBackend} for advanced / custom-renderer use.
+     */
+    get rendering(): RenderingContext;
     /**
      * Resolved capabilities for the host browser. Available after
      * {@link Application.start} resolves; reading before that throws.
@@ -130,10 +163,27 @@ export declare class Application {
     start(scene: Scene): Promise<this>;
     /**
      * One iteration of the per-frame loop. Invoked by `requestAnimationFrame`.
-     * Skips the body when the document is hidden and `pauseOnHidden` is
-     * `true`. Order: reset render stats → input + interaction update →
-     * audio update → tween update → optional view runtime update →
-     * scene-graph update → onFrame dispatch → backend flush → reschedule.
+     * When the document is hidden and `pauseOnHidden` is `true`, the frame
+     * clock is reset and the body is skipped — preventing a large delta spike
+     * on the first visible frame after resume.
+     *
+     * Each normal frame runs two distinct phases:
+     *
+     * **Update phase** — input and interaction flush, audio update, tween
+     * advancement, optional view runtime update, then `scene.update(delta)` for
+     * each participating scene in stack order.
+     *
+     * **Render phase** — `scene.draw(context)` for each participating scene in
+     * stack order, followed by the transition overlay when active.
+     *
+     * **Frame dispatch / flush** — `onFrame` signal, backend GPU flush,
+     * frame-time stat write, RAF reschedule.
+     *
+     * The simulation `delta` forwarded to all update recipients is clamped to
+     * an internal maximum (100 ms) so that debugger pauses, device sleep/resume,
+     * or severe browser scheduling gaps cannot produce runaway animation
+     * advancement. Real wall-clock time and RAF cadence are unaffected; the raw
+     * elapsed delta is recorded separately in `backend.stats.rawFrameDeltaMs`.
      */
     update(): this;
     /**
@@ -155,6 +205,12 @@ export declare class Application {
      * scratch canvas and used as the cursor image.
      */
     setCursor(cursor: string | Texture | HTMLImageElement | HTMLCanvasElement): this;
+    /**
+     * Renders `node` into an off-screen {@link RenderTexture} and returns it.
+     *
+     * Convenience wrapper that delegates to {@link RenderingContext.renderTo}.
+     */
+    renderTo(node: RenderNode, options: RenderToOptions): RenderTexture;
     /**
      * Tear down every owned subsystem (loader, interaction, input, tweens,
      * backend, scene manager, all clocks, all signals) and release event
@@ -164,6 +220,7 @@ export declare class Application {
     private _onDocumentVisibilityChange;
     private resolveInitialBackendType;
     private createBackend;
-    private initializeRenderManager;
+    private initializeBackend;
     private canUseWebGpu;
+    private _applyCanvasSize;
 }