layershift 0.2.1 → 0.3.0

package/dist/types/precomputed-depth.d.ts

@@ -15,66 +15,24 @@ export interface BinaryDownloadProgress {
     fraction: number;
 }
 /**
- * Worker-backed depth frame interpolator.
+ * Depth frame interpolator — synchronous keyframe blending.
  *
- * Offloads the bilateral filter, interpolation, and resize to a Web Worker
- * so the main thread stays free for smooth rendering. Uses double-buffering:
- * the main thread always has a ready-to-use depth frame while the worker
- * computes the next one in parallel.
+ * Interpolates between precomputed depth keyframes at ~5fps and returns
+ * raw Uint8 depth data for GPU upload. The bilateral filter runs on the
+ * GPU as a dedicated shader pass (see parallax-renderer.ts), so this
+ * class only handles temporal interpolation.
  *
- * ## Double-buffer strategy
- *
- * - `currentBuffer` — the latest completed depth frame, always available
- *   for synchronous reads via `sample()`.
- * - When the render loop calls `sample(timeSec)`, it returns `currentBuffer`
- *   immediately (zero main-thread work) and posts a request to the worker
- *   for the new time if it differs from the last requested time.
- * - When the worker responds, `currentBuffer` is swapped to the new result.
- * - During the 1-2 frames of latency, the previous depth frame is shown —
- *   this is imperceptible since depth only changes at ~5fps.
+ * Frame-change caching avoids redundant computation: depth only changes
+ * at ~5fps (keyframe transitions), but the render loop calls sample()
+ * at 60fps. Caching skips recomputation for ~12 identical frames.
  */
-export declare class WorkerDepthInterpolator {
-    private worker;
-    private currentBuffer;
-    private pendingTimeSec;
-    private workerBusy;
-    private disposed;
-    private constructor();
-    /**
-     * Create a WorkerDepthInterpolator, initializing the worker with frame data.
-     *
-     * The frame ArrayBuffers are transferred (zero-copy) to the worker.
-     * After this call, the original depthData.frames arrays are neutered
-     * and should not be accessed.
-     */
-    static create(depthData: PrecomputedDepthData, targetWidth: number, targetHeight: number): Promise<WorkerDepthInterpolator>;
-    /**
-     * Get the current depth frame — always synchronous, zero main-thread work.
-     *
-     * Returns the latest completed depth frame from the worker. If the worker
-     * hasn't finished processing the current time yet, returns the previous
-     * frame (1-2 frame latency is imperceptible at ~5fps depth changes).
-     *
-     * Automatically requests the worker to process the new time in the background.
-     */
-    sample(timeSec: number): Uint8Array;
-    /** Send a sample request to the worker if it's not busy. */
-    private requestSample;
-    /** Terminate the worker and release resources. */
-    dispose(): void;
-}
 export declare class DepthFrameInterpolator {
     private readonly depthData;
-    private readonly targetWidth;
-    private readonly targetHeight;
-    private readonly interpolatedDepth;
-    private readonly resizedDepth;
-    private readonly bilateralOutput;
     private readonly uint8Output;
     private lastFrameIndex;
     private lastNextFrameIndex;
     private lastLerpFactor;
-    constructor(depthData: PrecomputedDepthData, targetWidth: number, targetHeight: number);
+    constructor(depthData: PrecomputedDepthData);
     sample(timeSec: number): Uint8Array;
 }
 export declare function loadPrecomputedDepth(depthDataUrl: string, depthMetaUrl: string, onProgress?: (progress: BinaryDownloadProgress) => void): Promise<PrecomputedDepthData>;

package/dist/types/precomputed-depth.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"precomputed-depth.d.ts","sourceRoot":"","sources":["../../src/precomputed-depth.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,SAAS;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,SAAS,CAAC;IAChB,MAAM,EAAE,UAAU,EAAE,CAAC;CACtB;AAED,MAAM,WAAW,sBAAsB;IACrC,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,uBAAuB;IAClC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,aAAa,CAAa;IAClC,OAAO,CAAC,cAAc,CAAuB;IAC7C,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,QAAQ,CAAS;IAEzB,OAAO;IAQP;;;;;;OAMG;WACU,MAAM,CACjB,SAAS,EAAE,oBAAoB,EAC/B,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,uBAAuB,CAAC;IAqEnC;;;;;;;;OAQG;IACH,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU;IAKnC,4DAA4D;IAC5D,OAAO,CAAC,aAAa;IAarB,kDAAkD;IAClD,OAAO,IAAI,IAAI;CAIhB;AAED,qBAAa,sBAAsB;IAe/B,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,YAAY;IAhB/B,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAe;IACjD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAe;IAC5C,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAe;IAC/C,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAa;IAMzC,OAAO,CAAC,cAAc,CAAM;IAC5B,OAAO,CAAC,kBAAkB,CAAM;IAChC,OAAO,CAAC,cAAc,CAAM;gBAGT,SAAS,EAAE,oBAAoB,EAC/B,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,MAAM;IAUvC,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU;CA8DpC;AAED,wBAAsB,oBAAoB,CACxC,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,MAAM,EACpB,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,sBAAsB,KAAK,IAAI,GACtD,OAAO,CAAC,oBAAoB,CAAC,CAO/B"}
+{"version":3,"file":"precomputed-depth.d.ts","sourceRoot":"","sources":["../../src/precomputed-depth.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,SAAS;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,SAAS,CAAC;IAChB,MAAM,EAAE,UAAU,EAAE,CAAC;CACtB;AAED,MAAM,WAAW,sBAAsB;IACrC,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,sBAAsB;IAS/B,OAAO,CAAC,QAAQ,CAAC,SAAS;IAR5B,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAa;IAGzC,OAAO,CAAC,cAAc,CAAM;IAC5B,OAAO,CAAC,kBAAkB,CAAM;IAChC,OAAO,CAAC,cAAc,CAAM;gBAGT,SAAS,EAAE,oBAAoB;IAMlD,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU;CA4BpC;AAED,wBAAsB,oBAAoB,CACxC,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,MAAM,EACpB,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,sBAAsB,KAAK,IAAI,GACtD,OAAO,CAAC,oBAAoB,CAAC,CAO/B"}

package/dist/types/quality.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Adaptive Quality Scaling — device capability probing and tier classification.
+ *
+ * Probes WebGL context + navigator APIs once at init time, classifies the
+ * device into a quality tier (high / medium / low), and resolves concrete
+ * parameters that both renderers and Web Components consume to adjust:
+ *
+ * - **Render resolution** — DPR cap (2.0 / 1.5 / 1.0)
+ * - **Depth resolution** — depth texture max dimension (512 / 512 / 256)
+ * - **Sample count** — POM steps (16 / 16 / 8), bilateral kernel (5×5 / 5×5 / 3×3)
+ * - **JFA resolution** — distance field divisor (2 / 2 / 4) for portal effect
+ *
+ * Override precedence (unchanged): explicit config > quality-derived > calibrated defaults.
+ *
+ * @see ADR-012 for the architectural decision and rationale.
+ */
+/** Device quality classification. */
+export type QualityTier = 'high' | 'medium' | 'low';
+/** Concrete rendering parameters resolved from a quality tier. */
+export interface QualityParams {
+    readonly tier: QualityTier;
+    /** Maximum device pixel ratio (2.0 / 1.5 / 1.0). */
+    readonly dprCap: number;
+    /** Maximum depth texture dimension — depth maps larger than this are downscaled (512 / 512 / 256). */
+    readonly depthMaxDim: number;
+    /** POM ray-march step count (16 / 16 / 8). */
+    readonly pomSteps: number;
+    /** Bilateral filter kernel radius in texels — kernel is (2r+1)×(2r+1) (2 / 2 / 1). */
+    readonly bilateralRadius: number;
+    /** JFA distance field resolution divisor (2 = half-res, 4 = quarter-res). */
+    readonly jfaDivisor: number;
+}
+/** Raw device capability probe results. */
+export interface DeviceCapabilities {
+    /** GPU renderer string from WEBGL_debug_renderer_info, or 'unknown'. */
+    readonly gpuRenderer: string;
+    /** GL_MAX_TEXTURE_SIZE. */
+    readonly maxTextureSize: number;
+    /** navigator.hardwareConcurrency (logical cores), or 0 if unavailable. */
+    readonly hardwareConcurrency: number;
+    /** navigator.deviceMemory in GB, or 0 if unavailable. */
+    readonly deviceMemory: number;
+    /** window.devicePixelRatio. */
+    readonly devicePixelRatio: number;
+    /** Total screen pixels (width × height). */
+    readonly screenPixels: number;
+    /** Whether the device appears to be mobile (touch + small screen). */
+    readonly isMobile: boolean;
+}
+/**
+ * Probe device capabilities from the WebGL context and navigator APIs.
+ *
+ * This is intentionally lightweight — it reads values that are already
+ * available (no async, no benchmarks). Called once at init time.
+ */
+export declare function probeCapabilities(gl: WebGL2RenderingContext): DeviceCapabilities;
+/**
+ * Classify device capabilities into a quality tier using a score-based heuristic.
+ *
+ * Weighted signals are summed to produce a score:
+ * - Score >= 0 → high
+ * - Score -25 to -1 → medium
+ * - Score < -25 → low
+ */
+export declare function classifyDevice(caps: DeviceCapabilities): QualityTier;
+/**
+ * Resolve quality parameters for a renderer.
+ *
+ * - If `quality` is a specific tier ('high' | 'medium' | 'low'), return
+ *   that tier's parameters directly (no probing).
+ * - If `quality` is 'auto' or undefined, probe device capabilities and
+ *   classify automatically.
+ *
+ * Called once per renderer at construction time. The returned params are
+ * stored as `private readonly qualityParams` and read during init and resize.
+ *
+ * @param gl - WebGL 2 rendering context (used for GPU probing).
+ * @param quality - Explicit tier, 'auto', or undefined (defaults to 'auto').
+ */
+export declare function resolveQuality(gl: WebGL2RenderingContext, quality?: 'auto' | QualityTier): QualityParams;
+/**
+ * Probe device capabilities from a WebGPU adapter.
+ *
+ * Extracts the same `DeviceCapabilities` shape as the WebGL2 probe,
+ * allowing the shared `classifyDevice()` scoring logic to work for both backends.
+ */
+export declare function probeCapabilitiesWebGPU(adapterInfo: GPUAdapterInfo): DeviceCapabilities;
+/**
+ * Resolve quality parameters for a WebGPU renderer.
+ *
+ * Same logic as `resolveQuality()` but accepts a `GPUAdapterInfo` instead
+ * of a WebGL context.
+ */
+export declare function resolveQualityWebGPU(adapterInfo: GPUAdapterInfo, quality?: 'auto' | QualityTier): QualityParams;
+//# sourceMappingURL=quality.d.ts.map

package/dist/types/quality.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quality.d.ts","sourceRoot":"","sources":["../../src/quality.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAMH,qCAAqC;AACrC,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;AAEpD,kEAAkE;AAClE,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,oDAAoD;IACpD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,sGAAsG;IACtG,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,8CAA8C;IAC9C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,sFAAsF;IACtF,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,6EAA6E;IAC7E,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED,2CAA2C;AAC3C,MAAM,WAAW,kBAAkB;IACjC,wEAAwE;IACxE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,2BAA2B;IAC3B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,0EAA0E;IAC1E,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,yDAAyD;IACzD,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,+BAA+B;IAC/B,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,4CAA4C;IAC5C,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,sEAAsE;IACtE,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;CAC5B;AAkCD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,sBAAsB,GAAG,kBAAkB,CA0ChF;AA2CD;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,kBAAkB,GAAG,WAAW,CAmCpE;AAMD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAC5B,EAAE,EAAE,sBAAsB,EAC1B,OAAO,CAAC,EAAE,MAAM,GAAG,WAAW,GAC7B,aAAa,CAMf;AAMD;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,WAAW,EAAE,cAAc,GAAG,kBAAkB,CAkCvF;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,WAAW,EAAE,cAAc,EAC3B,OAAO,CAAC,EAAE,MAAM,GAAG,WAAW,GAC7B,aAAa,CAMf"}

package/dist/types/render-pass-webgpu.d.ts

@@ -0,0 +1,76 @@
+/**
+ * WebGPU Render Pass Framework — pipeline and bind group management.
+ *
+ * Parallel to `render-pass.ts` (WebGL2) but with idiomatic WebGPU patterns:
+ * - Pipeline state objects bake blend/stencil/depth config at creation
+ * - Bind groups replace individual uniform calls
+ * - No mutable state machine
+ *
+ * @see render-pass.ts for the WebGL2 counterpart.
+ */
+/** A single WebGPU render pass with its pipeline and bind group layout. */
+export interface WebGPURenderPass {
+    readonly name: string;
+    readonly pipeline: GPURenderPipeline;
+    readonly bindGroupLayout: GPUBindGroupLayout;
+    dispose(): void;
+}
+/** A WebGPU render pass that outputs to an offscreen texture. */
+export interface WebGPUFBOPass extends WebGPURenderPass {
+    outputTexture: GPUTexture;
+    outputView: GPUTextureView;
+    width: number;
+    height: number;
+    resize(device: GPUDevice, w: number, h: number, format?: GPUTextureFormat): void;
+}
+/** Configuration for creating a WebGPU render pass. */
+export interface WebGPURenderPassConfig {
+    readonly name: string;
+    readonly vertexShader: string;
+    readonly fragmentShader: string;
+    readonly vertexBufferLayouts: GPUVertexBufferLayout[];
+    readonly colorTargets: GPUColorTargetState[];
+    readonly depthStencil?: GPUDepthStencilState;
+    readonly primitive?: GPUPrimitiveState;
+    /** Explicit bind group layout entries. If omitted, uses auto layout. */
+    readonly bindGroupLayoutEntries?: GPUBindGroupLayoutEntry[];
+}
+/** Configuration for creating a WebGPU FBO pass. */
+export interface WebGPUFBOPassConfig extends WebGPURenderPassConfig {
+    readonly outputWidth: number;
+    readonly outputHeight: number;
+    readonly outputFormat?: GPUTextureFormat;
+}
+/**
+ * Create a WebGPU render pass with explicit bind group layout.
+ */
+export declare function createWebGPUPass(device: GPUDevice, config: WebGPURenderPassConfig): WebGPURenderPass;
+/**
+ * Create a WebGPU FBO pass that renders to an offscreen texture.
+ */
+export declare function createWebGPUFBOPass(device: GPUDevice, config: WebGPUFBOPassConfig): WebGPUFBOPass;
+/**
+ * Shared texture registry for WebGPU — manages texture unit allocation.
+ *
+ * Unlike WebGL2, WebGPU doesn't have numbered texture units. Instead,
+ * textures are referenced by bind group entries. This registry provides
+ * a consistent naming scheme across passes.
+ */
+export declare class WebGPUTextureRegistry {
+    private readonly textures;
+    register(name: string, texture: GPUTexture): GPUTextureView;
+    get(name: string): {
+        texture: GPUTexture;
+        view: GPUTextureView;
+    } | undefined;
+    dispose(): void;
+}
+/** Fullscreen quad vertex buffer layout: position (vec2). */
+export declare const FULLSCREEN_QUAD_LAYOUT: GPUVertexBufferLayout;
+/** Mesh vertex buffer layout: position (vec2) only. */
+export declare const MESH_POSITION_LAYOUT: GPUVertexBufferLayout;
+/** Boundary vertex buffer layout: position (vec2) + normal (vec2). */
+export declare const BOUNDARY_VERTEX_LAYOUT: GPUVertexBufferLayout;
+/** Chamfer vertex buffer layout: position (vec2) + normal3 (vec3) + lerpT (float). */
+export declare const CHAMFER_VERTEX_LAYOUT: GPUVertexBufferLayout;
+//# sourceMappingURL=render-pass-webgpu.d.ts.map

package/dist/types/render-pass-webgpu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-pass-webgpu.d.ts","sourceRoot":"","sources":["../../src/render-pass-webgpu.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAMH,2EAA2E;AAC3E,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,CAAC;IACrC,QAAQ,CAAC,eAAe,EAAE,kBAAkB,CAAC;IAC7C,OAAO,IAAI,IAAI,CAAC;CACjB;AAED,iEAAiE;AACjE,MAAM,WAAW,aAAc,SAAQ,gBAAgB;IACrD,aAAa,EAAE,UAAU,CAAC;IAC1B,UAAU,EAAE,cAAc,CAAC;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,MAAM,EAAE,SAAS,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,gBAAgB,GAAG,IAAI,CAAC;CAClF;AAED,uDAAuD;AACvD,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,mBAAmB,EAAE,qBAAqB,EAAE,CAAC;IACtD,QAAQ,CAAC,YAAY,EAAE,mBAAmB,EAAE,CAAC;IAC7C,QAAQ,CAAC,YAAY,CAAC,EAAE,oBAAoB,CAAC;IAC7C,QAAQ,CAAC,SAAS,CAAC,EAAE,iBAAiB,CAAC;IACvC,wEAAwE;IACxE,QAAQ,CAAC,sBAAsB,CAAC,EAAE,uBAAuB,EAAE,CAAC;CAC7D;AAED,oDAAoD;AACpD,MAAM,WAAW,mBAAoB,SAAQ,sBAAsB;IACjE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,YAAY,CAAC,EAAE,gBAAgB,CAAC;CAC1C;AAMD;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,sBAAsB,GAC7B,gBAAgB,CAqClB;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,mBAAmB,GAC1B,aAAa,CA4Bf;AAMD;;;;;;GAMG;AACH,qBAAa,qBAAqB;IAChC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAoE;IAE7F,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,GAAG,cAAc;IAM3D,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG;QAAE,OAAO,EAAE,UAAU,CAAC;QAAC,IAAI,EAAE,cAAc,CAAA;KAAE,GAAG,SAAS;IAI5E,OAAO,IAAI,IAAI;CAMhB;AAuBD,6DAA6D;AAC7D,eAAO,MAAM,sBAAsB,EAAE,qBAKpC,CAAC;AAEF,uDAAuD;AACvD,eAAO,MAAM,oBAAoB,EAAE,qBAKlC,CAAC;AAEF,sEAAsE;AACtE,eAAO,MAAM,sBAAsB,EAAE,qBAMpC,CAAC;AAEF,sFAAsF;AACtF,eAAO,MAAM,qBAAqB,EAAE,qBAOnC,CAAC"}

package/dist/types/render-pass.d.ts

@@ -0,0 +1,171 @@
+/**
+ * Shared render pass framework for compositing and effect stacking.
+ *
+ * Provides standardized interfaces (`RenderPass`, `FBOPass`) and a
+ * `TextureRegistry` for unit allocation. Both the parallax and portal
+ * renderers adopt this framework to structure their multi-pass GPU
+ * pipelines consistently.
+ *
+ * ## Design principles
+ *
+ * - **Geometry-agnostic** — passes may use fullscreen quads, indexed
+ *   meshes, or any other geometry. The framework doesn't assume.
+ * - **No common execute()** — passes have wildly different execute
+ *   signatures (bilateral needs raw depth data; JFA flood is iterative;
+ *   parallax just draws). Each renderer calls passes type-safely.
+ * - **Zero per-frame overhead** — TextureRegistry allocates at init
+ *   time. Hot-path code reads slot references directly.
+ * - **Pragmatic** — ~250 lines, not a game engine.
+ */
+/**
+ * A self-contained render pass: owns its shader program, uniform cache,
+ * and knows how to clean itself up.
+ *
+ * `program` and `uniforms` are exposed directly so the render loop can
+ * set per-frame uniforms (e.g., `uOffset`) without method-call overhead.
+ */
+export interface RenderPass {
+    /** Display name for debugging (e.g., "bilateral-filter", "jfa-flood"). */
+    readonly name: string;
+    /** The compiled + linked shader program. */
+    readonly program: WebGLProgram;
+    /** Cached uniform locations. */
+    readonly uniforms: Record<string, WebGLUniformLocation | null>;
+    /** Release GPU resources owned by this pass (program, FBOs). */
+    dispose(gl: WebGL2RenderingContext): void;
+}
+/** A single FBO color attachment descriptor. */
+export interface FBOAttachment {
+    /** The texture backing this attachment. */
+    texture: WebGLTexture;
+    /** Assigned texture unit (e.g., `gl.TEXTURE2` maps to unit 2). */
+    unit: number;
+    /** GL color attachment point (e.g., `gl.COLOR_ATTACHMENT0`). */
+    attachment: number;
+}
+/**
+ * A render pass that writes to an FBO rather than the default framebuffer.
+ *
+ * Manages its own framebuffer and output texture(s). Supports both
+ * single-output passes (bilateral filter → R8) and MRT passes
+ * (portal interior → RGBA8 color + RGBA8 depth).
+ */
+export interface FBOPass extends RenderPass {
+    /** The framebuffer object. Null before first `resize()`. */
+    fbo: WebGLFramebuffer | null;
+    /** Output textures written by this pass. */
+    readonly outputs: readonly FBOAttachment[];
+    /** Width of the FBO in pixels. */
+    width: number;
+    /** Height of the FBO in pixels. */
+    height: number;
+    /**
+     * Resize or recreate the FBO and its attachment textures.
+     * Called on viewport resize, not per-frame.
+     */
+    resize(gl: WebGL2RenderingContext, width: number, height: number): void;
+}
+/**
+ * Ordered list of render passes. Execute in array order.
+ *
+ * This is intentionally a thin type alias, not a class. The dual-loop
+ * architecture (RVFC + RAF) means passes are NOT all executed in one
+ * sequence, so orchestration stays in each renderer's render loop.
+ */
+export type RenderPipeline = readonly RenderPass[];
+/** A named texture with its assigned unit. */
+export interface TextureSlot {
+    /** Human-readable name (e.g., "video", "filteredDepth"). */
+    readonly name: string;
+    /** Assigned texture unit number (0, 1, 2, ...). */
+    readonly unit: number;
+    /** The WebGL texture handle. Null until allocated. */
+    texture: WebGLTexture | null;
+}
+/**
+ * Tracks texture unit assignments for a renderer.
+ *
+ * All allocation happens at init time via `register()`. The hot-path
+ * render loop accesses slots directly by cached reference — no map
+ * lookups per frame.
+ *
+ * Usage:
+ * ```ts
+ * const textures = new TextureRegistry();
+ * const videoSlot = textures.register('video');      // unit 0
+ * const depthSlot = textures.register('filteredDepth'); // unit 1
+ *
+ * // In render loop (hot path) — direct reference, zero lookup:
+ * gl.activeTexture(gl.TEXTURE0 + videoSlot.unit);
+ * gl.bindTexture(gl.TEXTURE_2D, videoSlot.texture);
+ * ```
+ */
+export declare class TextureRegistry {
+    private readonly slots;
+    private nextUnit;
+    /**
+     * Reserve a texture unit for a named texture.
+     *
+     * @returns The `TextureSlot` — hold a reference for hot-path access.
+     * @throws If the name is already registered.
+     */
+    register(name: string): TextureSlot;
+    /**
+     * Get a previously registered slot by name.
+     *
+     * @throws If the name was not registered.
+     */
+    get(name: string): TextureSlot;
+    /** Delete all textures and reset slots to null. */
+    disposeAll(gl: WebGL2RenderingContext): void;
+    /** Number of registered slots. */
+    get size(): number;
+}
+/**
+ * Create a `RenderPass` from vertex/fragment shader source.
+ *
+ * Compiles shaders, links program, caches uniform locations.
+ * The returned pass owns its program and cleans it up on `dispose()`.
+ */
+export declare function createPass(gl: WebGL2RenderingContext, name: string, vertexSource: string, fragmentSource: string, uniformNames: readonly string[]): RenderPass;
+/** Options for creating a single-output FBO pass. */
+export interface FBOPassOptions {
+    /** GL internal format (e.g., `gl.R8`, `gl.RGBA8`, `gl.RG16F`). */
+    internalFormat: number;
+    /** GL format for texImage2D (e.g., `gl.RED`, `gl.RGBA`, `gl.RG`). */
+    format: number;
+    /** GL type for texImage2D (e.g., `gl.UNSIGNED_BYTE`, `gl.FLOAT`). */
+    type: number;
+    /** Texture unit to assign to the output texture. */
+    textureUnit: number;
+    /** Initial FBO width. */
+    width: number;
+    /** Initial FBO height. */
+    height: number;
+}
+/**
+ * Create an `FBOPass` with a single color attachment.
+ *
+ * The FBO and its output texture are created immediately at the given
+ * dimensions. Call `resize()` to recreate at a different size.
+ */
+export declare function createFBOPass(gl: WebGL2RenderingContext, name: string, vertexSource: string, fragmentSource: string, uniformNames: readonly string[], options: FBOPassOptions): FBOPass;
+/** Descriptor for one MRT color attachment. */
+export interface MRTAttachment {
+    /** GL internal format (e.g., `gl.RGBA8`). */
+    internalFormat: number;
+    /** GL format (e.g., `gl.RGBA`). */
+    format: number;
+    /** GL type (e.g., `gl.UNSIGNED_BYTE`). */
+    type: number;
+    /** Texture unit to assign. */
+    textureUnit: number;
+}
+/**
+ * Create an `FBOPass` with multiple color attachments (MRT).
+ *
+ * Used by the portal interior pass which writes both color and depth
+ * to separate textures in a single draw call via `gl.drawBuffers()`.
+ */
+export declare function createMRTPass(gl: WebGL2RenderingContext, name: string, vertexSource: string, fragmentSource: string, uniformNames: readonly string[], attachments: readonly MRTAttachment[], width: number, height: number): FBOPass;
+//# sourceMappingURL=render-pass.d.ts.map

package/dist/types/render-pass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-pass.d.ts","sourceRoot":"","sources":["../../src/render-pass.ts"],"names":[],"mappings":"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"}

package/dist/types/renderer-base.d.ts

@@ -0,0 +1,124 @@
+/**
+ * Abstract base class for Layershift renderers.
+ *
+ * Extracts shared non-GPU logic common to both the parallax and portal
+ * renderers (and their future WebGPU counterparts):
+ *
+ * - Canvas creation + container attachment
+ * - Dual-loop animation management (RVFC + RAF)
+ * - Resize handling with debounce
+ * - Depth dimension clamping + CPU subsampling
+ * - Cover-fit UV computation
+ * - WebGL context loss handling
+ *
+ * Subclasses implement the GPU-specific abstract methods:
+ * `onRenderFrame()`, `onDepthUpdate()`, `recalculateViewportLayout()`,
+ * `disposeRenderer()`, and `onContextRestored()`.
+ */
+import type { ParallaxInput } from './input-handler';
+import type { QualityParams } from './quality';
+export declare abstract class RendererBase {
+    protected static readonly RESIZE_DEBOUNCE_MS = 100;
+    protected readonly canvas: HTMLCanvasElement;
+    protected readonly container: HTMLElement;
+    /** GPU texture dimensions (may be clamped by quality tier). */
+    protected depthWidth: number;
+    protected depthHeight: number;
+    /** Original source depth dimensions (from precomputed data). */
+    protected sourceDepthWidth: number;
+    protected sourceDepthHeight: number;
+    /** Reusable buffer for subsampling depth data when GPU dims < source dims. */
+    protected depthSubsampleBuffer: Uint8Array | null;
+    protected videoAspect: number;
+    protected uvOffset: number[];
+    protected uvScale: number[];
+    protected readDepth: ((timeSec: number) => Uint8Array) | null;
+    protected readInput: (() => ParallaxInput) | null;
+    protected playbackVideo: HTMLVideoElement | null;
+    /**
+     * Optional callback invoked on each new video frame (from RVFC).
+     * The Web Component uses this to dispatch frame events.
+     */
+    protected onVideoFrame: ((currentTime: number, frameNumber: number) => void) | null;
+    protected animationFrameHandle: number;
+    /** requestVideoFrameCallback handle (0 = inactive). */
+    protected rvfcHandle: number;
+    /** Whether RVFC is supported on the current video element. */
+    protected rvfcSupported: boolean;
+    protected resizeObserver: ResizeObserver | null;
+    protected resizeTimer: number | null;
+    /** Adaptive quality parameters. Set by subclass constructor after GL init. */
+    protected qualityParams: QualityParams;
+    constructor(parent: HTMLElement);
+    /**
+     * Begin the render loop.
+     *
+     * When `requestVideoFrameCallback` is available, two loops run:
+     * 1. RVFC loop — fires once per new video frame, handles depth update.
+     * 2. RAF loop — fires at display refresh rate, handles input + render.
+     *
+     * When RVFC is not available, falls back to a single RAF loop.
+     */
+    start(video: HTMLVideoElement, readDepth: (timeSec: number) => Uint8Array, readInput: () => ParallaxInput, onVideoFrame?: (currentTime: number, frameNumber: number) => void): void;
+    /** Stop both render loops and release callbacks. */
+    stop(): void;
+    /** Stop rendering and release all GPU resources. */
+    dispose(): void;
+    /** Check whether requestVideoFrameCallback is available. */
+    protected static isRVFCSupported(): boolean;
+    /**
+     * RAF loop — fires at display refresh rate.
+     * Delegates to subclass `onRenderFrame()` for the actual render work.
+     */
+    private readonly _rafLoop;
+    /**
+     * RVFC callback — fires only when the browser presents a new video frame.
+     * Delegates to subclass `onDepthUpdate()` for depth texture upload.
+     */
+    private readonly _videoFrameLoop;
+    private readonly _handleContextLost;
+    private readonly _handleContextRestored;
+    /**
+     * Set up a ResizeObserver on the container element and a fallback
+     * window resize listener. Called by subclass after GPU init.
+     */
+    protected setupResizeHandling(): void;
+    /** Debounce resize events to avoid expensive layout recalculations. */
+    protected readonly scheduleResizeRecalculate: () => void;
+    /** Read the container's pixel dimensions, with a minimum of 1x1. */
+    protected getViewportSize(): {
+        width: number;
+        height: number;
+    };
+    /**
+     * Clamp depth dimensions to the quality tier's maximum and allocate
+     * the subsample buffer if needed. Called during `initialize()`.
+     */
+    protected clampDepthDimensions(sourceWidth: number, sourceHeight: number, maxDim: number): void;
+    /**
+     * CPU nearest-neighbor depth subsampling.
+     *
+     * Returns the original data if no subsampling is needed, otherwise
+     * fills and returns the pre-allocated subsample buffer.
+     */
+    protected subsampleDepth(depthData: Uint8Array): Uint8Array;
+    /**
+     * Compute cover-fit + overscan UV transform.
+     *
+     * The video fills the viewport (cover-fit), and overscan adds extra
+     * visible area so parallax displacement doesn't reveal edges.
+     * Updates `this.uvOffset` and `this.uvScale`.
+     */
+    protected computeCoverFitUV(parallaxStrength: number, overscanPadding: number): void;
+    /** Main render frame logic (called from RAF loop at display refresh rate). */
+    protected abstract onRenderFrame(): void;
+    /** Depth texture upload + filter (called from RVFC loop at video frame rate). */
+    protected abstract onDepthUpdate(timeSec: number): void;
+    /** Recalculate canvas size, FBOs, UV transform on resize. */
+    protected abstract recalculateViewportLayout(): void;
+    /** Release all GPU resources (called from dispose()). */
+    protected abstract disposeRenderer(): void;
+    /** Rebuild GPU state after context restoration. */
+    protected abstract onContextRestored(): void;
+}
+//# sourceMappingURL=renderer-base.d.ts.map

package/dist/types/renderer-base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderer-base.d.ts","sourceRoot":"","sources":["../../src/renderer-base.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAM/C,8BAAsB,YAAY;IAChC,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,kBAAkB,OAAO;IAGnD,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,iBAAiB,CAAC;IAC7C,SAAS,CAAC,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC;IAG1C,+DAA+D;IAC/D,SAAS,CAAC,UAAU,SAAK;IACzB,SAAS,CAAC,WAAW,SAAK;IAC1B,gEAAgE;IAChE,SAAS,CAAC,gBAAgB,SAAK;IAC/B,SAAS,CAAC,iBAAiB,SAAK;IAChC,8EAA8E;IAC9E,SAAS,CAAC,oBAAoB,EAAE,UAAU,GAAG,IAAI,CAAQ;IAGzD,SAAS,CAAC,WAAW,SAAU;IAG/B,SAAS,CAAC,QAAQ,WAAU;IAC5B,SAAS,CAAC,OAAO,WAAU;IAG3B,SAAS,CAAC,SAAS,EAAE,CAAC,CAAC,OAAO,EAAE,MAAM,KAAK,UAAU,CAAC,GAAG,IAAI,CAAQ;IACrE,SAAS,CAAC,SAAS,EAAE,CAAC,MAAM,aAAa,CAAC,GAAG,IAAI,CAAQ;IACzD,SAAS,CAAC,aAAa,EAAE,gBAAgB,GAAG,IAAI,CAAQ;IACxD;;;OAGG;IACH,SAAS,CAAC,YAAY,EAAE,CAAC,CAAC,WAAW,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,KAAK,IAAI,CAAC,GAAG,IAAI,CAAQ;IAG3F,SAAS,CAAC,oBAAoB,SAAK;IACnC,uDAAuD;IACvD,SAAS,CAAC,UAAU,SAAK;IACzB,8DAA8D;IAC9D,SAAS,CAAC,aAAa,UAAS;IAChC,SAAS,CAAC,cAAc,EAAE,cAAc,GAAG,IAAI,CAAQ;IACvD,SAAS,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAQ;IAG5C,8EAA8E;IAC9E,SAAS,CAAC,aAAa,EAAG,aAAa,CAAC;gBAE5B,MAAM,EAAE,WAAW;IAe/B;;;;;;;;OAQG;IACH,KAAK,CACH,KAAK,EAAE,gBAAgB,EACvB,SAAS,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,UAAU,EAC1C,SAAS,EAAE,MAAM,aAAa,EAC9B,YAAY,CAAC,EAAE,CAAC,WAAW,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,KAAK,IAAI,GAChE,IAAI;IAmBP,oDAAoD;IACpD,IAAI,IAAI,IAAI;IAkBZ,oDAAoD;IACpD,OAAO,IAAI,IAAI;IAuBf,4DAA4D;IAC5D,SAAS,CAAC,MAAM,CAAC,eAAe,IAAI,OAAO;IAQ3C;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAGvB;IAEF;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,eAAe,CAe9B;IAMF,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAMjC;IAEF,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAErC;IAMF;;;OAGG;IACH,SAAS,CAAC,mBAAmB,IAAI,IAAI;IAYrC,uEAAuE;IACvE,SAAS,CAAC,QAAQ,CAAC,yBAAyB,aAQ1C;IAEF,oEAAoE;IACpE,SAAS,CAAC,eAAe,IAAI;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE;IAU9D;;;OAGG;IACH,SAAS,CAAC,oBAAoB,CAC5B,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,MAAM,GACb,IAAI;IAqBP;;;;;OAKG;IACH,SAAS,CAAC,cAAc,CAAC,SAAS,EAAE,UAAU,GAAG,UAAU;IAwB3D;;;;;;OAMG;IACH,SAAS,CAAC,iBAAiB,CACzB,gBAAgB,EAAE,MAAM,EACxB,eAAe,EAAE,MAAM,GACtB,IAAI;IA0BP,8EAA8E;IAC9E,SAAS,CAAC,QAAQ,CAAC,aAAa,IAAI,IAAI;IAExC,iFAAiF;IACjF,SAAS,CAAC,QAAQ,CAAC,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAEvD,6DAA6D;IAC7D,SAAS,CAAC,QAAQ,CAAC,yBAAyB,IAAI,IAAI;IAEpD,yDAAyD;IACzD,SAAS,CAAC,QAAQ,CAAC,eAAe,IAAI,IAAI;IAE1C,mDAAmD;IACnD,SAAS,CAAC,QAAQ,CAAC,iBAAiB,IAAI,IAAI;CAC7C"}

package/dist/types/webgl-utils.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Shared WebGL 2 utilities — compile, link, uniform caching, fullscreen quad.
+ *
+ * Used by both the parallax renderer and the portal renderer to avoid
+ * duplicating boilerplate GL setup code.
+ */
+/** Compile a GLSL shader, throwing on error. */
+export declare function compileShader(gl: WebGL2RenderingContext, type: number, source: string): WebGLShader;
+/** Link a shader program, throwing on error. */
+export declare function linkProgram(gl: WebGL2RenderingContext, vertShader: WebGLShader, fragShader: WebGLShader): WebGLProgram;
+/**
+ * Cache uniform locations for a set of uniform names.
+ *
+ * Returns a record mapping each name to its `WebGLUniformLocation | null`.
+ * Avoids repeated `getUniformLocation` calls per frame.
+ */
+export declare function getUniformLocations(gl: WebGL2RenderingContext, program: WebGLProgram, names: readonly string[]): Record<string, WebGLUniformLocation | null>;
+/**
+ * Create a VAO for the standard fullscreen quad.
+ *
+ * The VAO binds a VBO with 4 clip-space vertices to the `aPosition`
+ * attribute (looked up from the given program). Draw with
+ * `gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4)`.
+ *
+ * @param gl - WebGL 2 context
+ * @param program - Shader program to look up `aPosition` attribute location
+ */
+export declare function createFullscreenQuadVao(gl: WebGL2RenderingContext, program: WebGLProgram): WebGLVertexArrayObject;
+//# sourceMappingURL=webgl-utils.d.ts.map

package/dist/types/webgl-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webgl-utils.d.ts","sourceRoot":"","sources":["../../src/webgl-utils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,gDAAgD;AAChD,wBAAgB,aAAa,CAC3B,EAAE,EAAE,sBAAsB,EAC1B,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,GACb,WAAW,CAWb;AAED,gDAAgD;AAChD,wBAAgB,WAAW,CACzB,EAAE,EAAE,sBAAsB,EAC1B,UAAU,EAAE,WAAW,EACvB,UAAU,EAAE,WAAW,GACtB,YAAY,CAiBd;AAMD;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,EAAE,EAAE,sBAAsB,EAC1B,OAAO,EAAE,YAAY,EACrB,KAAK,EAAE,SAAS,MAAM,EAAE,GACvB,MAAM,CAAC,MAAM,EAAE,oBAAoB,GAAG,IAAI,CAAC,CAM7C;AAiBD;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CACrC,EAAE,EAAE,sBAAsB,EAC1B,OAAO,EAAE,YAAY,GACpB,sBAAsB,CAiBxB"}

package/dist/types/webgpu-utils.d.ts

@@ -0,0 +1,42 @@
+/**
+ * WebGPU Utilities — shared helpers for WebGPU renderers.
+ *
+ * Parallel to `webgl-utils.ts` but for the WebGPU backend.
+ * Provides buffer creation, sampler factories, and fullscreen quad geometry.
+ */
+/**
+ * Create a GPU buffer containing a fullscreen quad (triangle strip, 4 vertices).
+ */
+export declare function createFullscreenQuadBuffer(device: GPUDevice): GPUBuffer;
+/**
+ * Create a GPU vertex buffer from Float32Array data.
+ */
+export declare function createVertexBuffer(device: GPUDevice, data: Float32Array): GPUBuffer;
+/**
+ * Create a GPU index buffer from Uint16Array data.
+ */
+export declare function createIndexBuffer(device: GPUDevice, data: Uint16Array): GPUBuffer;
+/**
+ * Create a GPU uniform buffer of the given byte size.
+ */
+export declare function createUniformBuffer(device: GPUDevice, byteSize: number): GPUBuffer;
+/**
+ * Create a 2D texture with common defaults for render targets.
+ */
+export declare function createRenderTexture(device: GPUDevice, width: number, height: number, format?: GPUTextureFormat): GPUTexture;
+/**
+ * Create a 2D texture for sampling (e.g., video frame, depth data).
+ */
+export declare function createSampleTexture(device: GPUDevice, width: number, height: number, format?: GPUTextureFormat): GPUTexture;
+/** Create a linear-filtering, clamp-to-edge sampler. */
+export declare function createLinearSampler(device: GPUDevice): GPUSampler;
+/** Create a nearest-filtering, clamp-to-edge sampler. */
+export declare function createNearestSampler(device: GPUDevice): GPUSampler;
+/**
+ * Import a video frame into a WebGPU texture using `copyExternalImageToTexture`.
+ *
+ * This is the WebGPU equivalent of `gl.texImage2D(gl.TEXTURE_2D, ..., video)`.
+ * On supported browsers, this is a zero-copy operation.
+ */
+export declare function importVideoFrame(device: GPUDevice, texture: GPUTexture, video: HTMLVideoElement, flipY?: boolean): void;
+//# sourceMappingURL=webgpu-utils.d.ts.map

package/dist/types/webgpu-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webgpu-utils.d.ts","sourceRoot":"","sources":["../../src/webgpu-utils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAcH;;GAEG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,SAAS,GAAG,SAAS,CASvE;AAMD;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE,YAAY,GAAG,SAAS,CASnF;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE,WAAW,GAAG,SAAS,CASjF;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,GAAG,SAAS,CAOlF;AAMD;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,SAAS,EACjB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,MAAM,GAAE,gBAA+B,GACtC,UAAU,CAMZ;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,SAAS,EACjB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,MAAM,GAAE,gBAA+B,GACtC,UAAU,CASZ;AAMD,wDAAwD;AACxD,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,GAAG,UAAU,CAOjE;AAED,yDAAyD;AACzD,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,SAAS,GAAG,UAAU,CAOlE;AAMD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,SAAS,EACjB,OAAO,EAAE,UAAU,EACnB,KAAK,EAAE,gBAAgB,EACvB,KAAK,UAAO,GACX,IAAI,CAMN"}