shaders 2.5.135 → 3.0.437

package/dist/core/gpu/index.d.ts

@@ -0,0 +1,190 @@
+import { TgpuRoot } from 'typegpu';
+import { NodeHandles, FieldInit } from './uniformStore';
+import { GpuShaderDefinition } from './contract';
+import { SizeConversion } from '../utilities/dimensionalProps';
+import { PerformanceStats } from '../performanceTracker';
+import { NodeMetadata, ToneMappingMode } from '../types';
+
+export { acquireRoot, configureCanvasContext, getRootForDevice } from './root';
+export type { AcquireRootOptions, RootContext } from './root';
+/**
+ * One prop's registration input. Carries the plain current `value` plus the CPU `transform`
+ * and the compile-time flags. The uniform store applies the transform when seeding/patching the
+ * packed struct field (see uniformStore.FieldHandle). The framework templates produce this
+ * shape.
+ */
+export interface GpuUniformInput {
+    /** Current value (raw, or dimensionally-resolved for shape props). The store transforms it. */
+    value: unknown;
+    /** CPU transform (transformColor / transformPosition / transformAngle / …). */
+    transform?: (value: unknown) => unknown;
+    /** Recompiles the composition when this prop changes (baked into the WGSL at build). */
+    compileTime?: boolean;
+    /** Recompiles only when the predicate fires (e.g. blur crossing 0). */
+    compileTimeWhen?: (previousValue: unknown, newValue: unknown) => boolean;
+    /** @internal last value a compileTimeWhen recompose was keyed to. */
+    _lastCompiledValue?: unknown;
+    /** @internal raw (px / DimensionalValue) value for resize re-resolution of shape props. */
+    _rawDimensional?: unknown;
+    /** String / JSON / origin / select props — CPU-only, never enter the packed struct. */
+    cpu?: boolean;
+    /** Explicit WGSL schema override (else inferred from the transformed value). */
+    schema?: import('typegpu/data').AnyWgslData;
+}
+/** A node's registration input, keyed by prop name. */
+export type GpuUniformsMap = Record<string, GpuUniformInput>;
+export interface GpuInitializeOptions {
+    canvas: HTMLCanvasElement;
+    /** Element to observe for resize. Defaults to `canvas.parentElement`. */
+    resizeTarget?: HTMLElement;
+    enablePerformanceTracking?: boolean;
+    colorSpace?: 'p3-linear' | 'srgb';
+    toneMapping?: ToneMappingMode;
+    /** Inject a shared device (Projects multi-tile) — one root per device. */
+    gpu?: {
+        device: GPUDevice;
+        adapter?: GPUAdapter;
+    };
+    forceFullFrameRate?: boolean;
+    /** When false, skips ResizeObserver + IntersectionObserver — use resize()/start()/stop(). */
+    observeElement?: boolean;
+    /** Shared wall-clock time origin (performance.now ms) for synced multi-renderer animation. */
+    timeOrigin?: number;
+    /**
+     * REJECTED. This renderer is WebGPU-only and throws a descriptive error if a context is
+     * passed. Present only to give a clear error, not for use.
+     */
+    context?: unknown;
+}
+interface MouseDriverState {
+    currentX: number;
+    currentY: number;
+    velocityX: number;
+    velocityY: number;
+    /** Live pre-flip box-local point for UI readback (mouse-position). */
+    liveX?: number;
+    liveY?: number;
+    /** Live resolved scalar for UI readback (mouse-map range). */
+    liveScalar?: number;
+}
+/** Resolved map/mouse remap bounds (plain numbers), refreshed on metadata + resize. */
+interface MapValues {
+    inputMin: number;
+    inputMax: number;
+    outputMin: number;
+    outputMax: number;
+    curve: number;
+}
+interface GpuNodeInfo {
+    id: string;
+    componentName: string;
+    parentId: string | null;
+    definition: GpuShaderDefinition;
+    metadata: NodeMetadata;
+    uniforms: GpuUniformsMap;
+    domCanvas?: HTMLCanvasElement;
+    requiresRTT: boolean;
+    requiresChild: boolean;
+    blendWithChildren: boolean;
+    acceptsUVContext: boolean;
+    providesUVContextViaCompute: boolean;
+    usesPointer: boolean;
+    hasUvRemap: boolean;
+    boundingBoxDeclaration?: GpuShaderDefinition['boundingBoxDeclaration'];
+    wantsBoundsParams: boolean;
+    extraDimProps?: Map<string, SizeConversion>;
+    mouseDriverState: Record<string, MouseDriverState>;
+    autoAnimateState: Record<string, {}>;
+    mapValues: Record<string, MapValues>;
+    /** Live per-field handles from the CURRENTLY BOUND composition's store (props + synthetic). */
+    _liveHandles: NodeHandles | null;
+}
+interface QueuedRegistration {
+    id: string;
+    definition: GpuShaderDefinition;
+    parentId: string | null;
+    metadata: NodeMetadata | null;
+    uniforms: GpuUniformsMap;
+    domCanvas?: HTMLCanvasElement;
+}
+/**
+ * Construct a WebGPU renderer instance.
+ */
+export declare function shaderRendererGPU(): {
+    initialize: (options: GpuInitializeOptions) => Promise<void>;
+    cleanup: () => void;
+    registerNode: (id: string, fragmentNodeFunc: GpuShaderDefinition["fragment"] | null, parentId: string | null, metadata: NodeMetadata | null, uniforms?: GpuUniformsMap, componentDefinition?: GpuShaderDefinition, domCanvas?: HTMLCanvasElement) => void;
+    removeNode: (id: string) => void;
+    updateUniformValue: (nodeId: string, uniformName: string, value: unknown) => void;
+    updateNodeMetadata: (nodeId: string, metadata: Partial<NodeMetadata>) => void;
+    isInitialized: () => boolean;
+    resize: (width: number, height: number) => void;
+    startAnimation: () => void;
+    stopAnimation: () => void;
+    renderAndWait: () => Promise<void>;
+    renderSyntheticFrame: (deltaSeconds: number) => Promise<void>;
+    getPerformanceStats: () => PerformanceStats;
+    getLiveDriverValue: (nodeId: string, propName: string) => {
+        x: number;
+        y: number;
+    } | null;
+    getLiveScalarValue: (nodeId: string, propName: string) => number | null;
+    getNodeRegistry: () => {
+        nodes: ReadonlyMap<string, GpuNodeInfo>;
+    };
+    /** Always 'webgpu' (type kept wide for source-compat with callers expecting a union). */
+    getRendererType: () => "webgpu" | "webgl" | null;
+    /** The renderer context object: `{ device, adapter?, root }`. */
+    getInternalRenderer: () => {
+        device: GPUDevice;
+        adapter?: GPUAdapter;
+        root: TgpuRoot;
+    } | null;
+    setForceFullFrameRate: (enabled: boolean) => boolean;
+    beginRecordingResolution: (targetWidth: number, targetHeight: number, ratio: number) => (() => void);
+    setResolutionScale: (scale: number) => void;
+    setTimeOrigin: (origin: number | null) => void;
+    setOnReady: (callback: (() => void) | null) => void;
+    setOnDeviceLost: (callback: ((reason: string) => void) | null) => void;
+    __testing: {
+        needsTransformation: (transform: import('./kit/uvTransform').TransformConfig | undefined) => boolean;
+        findChildNodes: (parentId: string) => GpuNodeInfo[];
+        /** The per-node FieldInit set the store registers (props + synthetic `_`-fields). */
+        buildFieldInits: (id: string) => FieldInit[] | null;
+        /** Advance + read a node's `_animTime` accumulator without a device (driver test). */
+        stepAnimatedTime: (deltaTime: number) => void;
+        getAnimatedTimeValue: (id: string) => number | null;
+        writeExtraField: (id: string, name: string, value: number | number[]) => void;
+        readExtraField: (id: string, name: string) => unknown;
+        getNodeRegistry: () => {
+            nodes: Map<string, GpuNodeInfo>;
+            rootId: string | null;
+            parentToChildren: Map<string | null, Set<string>>;
+        };
+        getParentToChildren: () => Map<string | null, Set<string>>;
+        getPendingRegistrations: () => QueuedRegistration[];
+        /** Passive read of the live frame-timing/pointer state (RAF-loop diagnosis). */
+        getFrameDiagnostics: () => {
+            deltaTime: number;
+            pointerX: number;
+            pointerY: number;
+            pointerActive: boolean;
+            globalElapsedTime: number;
+            lastRenderTime: number;
+            isVisible: boolean;
+            forceFullFrameRate: boolean;
+            sharedTimeOrigin: number | null;
+            animating: boolean;
+            mouseListenersNeeded: boolean;
+        };
+        computeStructuralHash: () => string | null;
+        isStructuralDirty: () => boolean;
+        clearStructuralDirty: () => void;
+        /** Force the renderer "ready" WITHOUT a device, for registration/scheduling tests. */
+        setTestReady: (dims?: {
+            width: number;
+            height: number;
+        }) => void;
+    };
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/core/gpu/index.d.ts.map

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

package/dist/core/gpu/kit/blend.d.ts

@@ -0,0 +1,66 @@
+import { d } from './index';
+
+/** Luminance (ITU-R BT.709). */
+export declare const luminance: import('typegpu').TgpuFn<(rgb: d.Vec3f) => d.F32>;
+/**
+ * Premultiplied-alpha → straight-alpha. RTT boundaries produce premultiplied data (the "over"
+ * composite accumulates RGB weighted by alpha), so effects that SAMPLE an RTT and return into the
+ * blend pipeline (which expects straight alpha) must convert back. No-op at alpha 1. Used by the
+ * uvRemap-distortion / RTT-filter effects (Twirl, Bulge, Liquify, …).
+ *   straightRGB = alpha > 0.001 ? rgb / alpha : vec3(0); returns vec4(straightRGB, alpha).
+ */
+export declare const unpremultiplyAlpha: import('typegpu').TgpuFn<(color: d.Vec4f) => d.Vec4f>;
+export declare const normal: import('typegpu').TgpuFn<(base: d.Vec4f, overlay: d.Vec4f, opacity: d.F32) => d.Vec4f>;
+export declare const normalOklch: import('typegpu').TgpuFn<(base: d.Vec4f, overlay: d.Vec4f, opacity: d.F32) => d.Vec4f>;
+export declare const normalOklab: import('typegpu').TgpuFn<(base: d.Vec4f, overlay: d.Vec4f, opacity: d.F32) => d.Vec4f>;
+export declare const multiply: import('typegpu').TgpuFn<(base: d.Vec4f, overlay: d.Vec4f, opacity: d.F32) => d.Vec4f>;
+export declare const screen: import('typegpu').TgpuFn<(base: d.Vec4f, overlay: d.Vec4f, opacity: d.F32) => d.Vec4f>;
+export declare const linearDodge: import('typegpu').TgpuFn<(base: d.Vec4f, overlay: d.Vec4f, opacity: d.F32) => d.Vec4f>;
+export declare const overlay: import('typegpu').TgpuFn<(base: d.Vec4f, overlay: d.Vec4f, opacity: d.F32) => d.Vec4f>;
+export declare const difference: import('typegpu').TgpuFn<(base: d.Vec4f, overlay: d.Vec4f, opacity: d.F32) => d.Vec4f>;
+export declare const colorDodge: import('typegpu').TgpuFn<(base: d.Vec4f, overlay: d.Vec4f, opacity: d.F32) => d.Vec4f>;
+export declare const exclusion: import('typegpu').TgpuFn<(base: d.Vec4f, overlay: d.Vec4f, opacity: d.F32) => d.Vec4f>;
+export declare const color: import('typegpu').TgpuFn<(base: d.Vec4f, overlay: d.Vec4f, opacity: d.F32) => d.Vec4f>;
+export declare const luminosity: import('typegpu').TgpuFn<(base: d.Vec4f, overlay: d.Vec4f, opacity: d.F32) => d.Vec4f>;
+export declare const darken: import('typegpu').TgpuFn<(base: d.Vec4f, overlay: d.Vec4f, opacity: d.F32) => d.Vec4f>;
+export declare const lighten: import('typegpu').TgpuFn<(base: d.Vec4f, overlay: d.Vec4f, opacity: d.F32) => d.Vec4f>;
+export declare const colorBurn: import('typegpu').TgpuFn<(base: d.Vec4f, overlay: d.Vec4f, opacity: d.F32) => d.Vec4f>;
+export declare const linearBurn: import('typegpu').TgpuFn<(base: d.Vec4f, overlay: d.Vec4f, opacity: d.F32) => d.Vec4f>;
+export declare const softLight: import('typegpu').TgpuFn<(base: d.Vec4f, overlay: d.Vec4f, opacity: d.F32) => d.Vec4f>;
+export declare const hardLight: import('typegpu').TgpuFn<(base: d.Vec4f, overlay: d.Vec4f, opacity: d.F32) => d.Vec4f>;
+export declare const hue: import('typegpu').TgpuFn<(base: d.Vec4f, overlay: d.Vec4f, opacity: d.F32) => d.Vec4f>;
+export declare const saturation: import('typegpu').TgpuFn<(base: d.Vec4f, overlay: d.Vec4f, opacity: d.F32) => d.Vec4f>;
+/**
+ * All 20 blend modes keyed by the exact mode names used by the design editor / presets.
+ * The composer references these as externals.
+ */
+export declare const blendModes: {
+    readonly normal: import('typegpu').TgpuFn<(base: d.Vec4f, overlay: d.Vec4f, opacity: d.F32) => d.Vec4f>;
+    readonly 'normal-oklch': import('typegpu').TgpuFn<(base: d.Vec4f, overlay: d.Vec4f, opacity: d.F32) => d.Vec4f>;
+    readonly 'normal-oklab': import('typegpu').TgpuFn<(base: d.Vec4f, overlay: d.Vec4f, opacity: d.F32) => d.Vec4f>;
+    readonly multiply: import('typegpu').TgpuFn<(base: d.Vec4f, overlay: d.Vec4f, opacity: d.F32) => d.Vec4f>;
+    readonly screen: import('typegpu').TgpuFn<(base: d.Vec4f, overlay: d.Vec4f, opacity: d.F32) => d.Vec4f>;
+    readonly linearDodge: import('typegpu').TgpuFn<(base: d.Vec4f, overlay: d.Vec4f, opacity: d.F32) => d.Vec4f>;
+    readonly overlay: import('typegpu').TgpuFn<(base: d.Vec4f, overlay: d.Vec4f, opacity: d.F32) => d.Vec4f>;
+    readonly difference: import('typegpu').TgpuFn<(base: d.Vec4f, overlay: d.Vec4f, opacity: d.F32) => d.Vec4f>;
+    readonly colorDodge: import('typegpu').TgpuFn<(base: d.Vec4f, overlay: d.Vec4f, opacity: d.F32) => d.Vec4f>;
+    readonly exclusion: import('typegpu').TgpuFn<(base: d.Vec4f, overlay: d.Vec4f, opacity: d.F32) => d.Vec4f>;
+    readonly color: import('typegpu').TgpuFn<(base: d.Vec4f, overlay: d.Vec4f, opacity: d.F32) => d.Vec4f>;
+    readonly luminosity: import('typegpu').TgpuFn<(base: d.Vec4f, overlay: d.Vec4f, opacity: d.F32) => d.Vec4f>;
+    readonly darken: import('typegpu').TgpuFn<(base: d.Vec4f, overlay: d.Vec4f, opacity: d.F32) => d.Vec4f>;
+    readonly lighten: import('typegpu').TgpuFn<(base: d.Vec4f, overlay: d.Vec4f, opacity: d.F32) => d.Vec4f>;
+    readonly colorBurn: import('typegpu').TgpuFn<(base: d.Vec4f, overlay: d.Vec4f, opacity: d.F32) => d.Vec4f>;
+    readonly linearBurn: import('typegpu').TgpuFn<(base: d.Vec4f, overlay: d.Vec4f, opacity: d.F32) => d.Vec4f>;
+    readonly softLight: import('typegpu').TgpuFn<(base: d.Vec4f, overlay: d.Vec4f, opacity: d.F32) => d.Vec4f>;
+    readonly hardLight: import('typegpu').TgpuFn<(base: d.Vec4f, overlay: d.Vec4f, opacity: d.F32) => d.Vec4f>;
+    readonly hue: import('typegpu').TgpuFn<(base: d.Vec4f, overlay: d.Vec4f, opacity: d.F32) => d.Vec4f>;
+    readonly saturation: import('typegpu').TgpuFn<(base: d.Vec4f, overlay: d.Vec4f, opacity: d.F32) => d.Vec4f>;
+};
+export type BlendMode = keyof typeof blendModes;
+/**
+ * Blend two colors using the named mode — CPU/builder-level dispatcher. `blendMode` is
+ * compile-time (part of the pipeline hash), so selection stays on the CPU. Inside a `'use gpu'`
+ * body, reference `blendModes[mode]` (a `tgpu.fn`) instead.
+ */
+export declare const applyBlendMode: (base: d.v4f, overlay: d.v4f, blendMode?: BlendMode, opacity?: number) => d.v4f;
+//# sourceMappingURL=blend.d.ts.map

package/dist/core/gpu/kit/blend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blend.d.ts","sourceRoot":"","sources":["../../../src/gpu/kit/blend.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,EAAC,CAAC,EAAY,MAAM,SAAS,CAAA;AAGpC,gCAAgC;AAChC,eAAO,MAAM,SAAS,mDAGpB,CAAA;AAqBF;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,uDAM7B,CAAA;AAEF,eAAO,MAAM,MAAM,wFAIjB,CAAA;AAEF,eAAO,MAAM,WAAW,wFAUtB,CAAA;AAEF,eAAO,MAAM,WAAW,wFAUtB,CAAA;AAEF,eAAO,MAAM,QAAQ,wFAKnB,CAAA;AAEF,eAAO,MAAM,MAAM,wFAKjB,CAAA;AAEF,eAAO,MAAM,WAAW,wFAOtB,CAAA;AAEF,eAAO,MAAM,OAAO,wFAOlB,CAAA;AAEF,eAAO,MAAM,UAAU,wFAKrB,CAAA;AAEF,eAAO,MAAM,UAAU,wFAWrB,CAAA;AAEF,eAAO,MAAM,SAAS,wFAMpB,CAAA;AAEF,eAAO,MAAM,KAAK,wFAShB,CAAA;AAEF,eAAO,MAAM,UAAU,wFASrB,CAAA;AAEF,eAAO,MAAM,MAAM,wFAKjB,CAAA;AAEF,eAAO,MAAM,OAAO,wFAKlB,CAAA;AAEF,eAAO,MAAM,SAAS,wFAOpB,CAAA;AAEF,eAAO,MAAM,UAAU,wFAMrB,CAAA;AAEF,eAAO,MAAM,SAAS,wFAWpB,CAAA;AAEF,eAAO,MAAM,SAAS,wFAOpB,CAAA;AAEF,eAAO,MAAM,GAAG,wFAmBd,CAAA;AAEF,eAAO,MAAM,UAAU,wFAkBrB,CAAA;AAEF;;;GAGG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;CAqBb,CAAA;AAEV,MAAM,MAAM,SAAS,GAAG,MAAM,OAAO,UAAU,CAAA;AAE/C;;;;GAIG;AACH,eAAO,MAAM,cAAc,SACjB,CAAC,CAAC,GAAG,WACF,CAAC,CAAC,GAAG,cACH,SAAS,YACX,MAAM,KAChB,CAAC,CAAC,GAGJ,CAAA"}

package/dist/core/gpu/kit/blur.d.ts

@@ -0,0 +1,209 @@
+import { TgpuRoot, TgpuTexture, TgpuTextureView } from 'typegpu';
+import { ComputeStep } from '../compute';
+
+import * as d from 'typegpu/data';
+/** Default compute resolution. ~655k pixels — comparable to 0.5× of a 1080p canvas.
+ *  Memory per RGBA32F texture: ~10 MB. Heavy presets (Glow with 4 storage textures) total
+ *  ~40 MB regardless of canvas size. Callers can override for memory-tight scenarios or
+ *  higher quality. */
+export declare const DEFAULT_COMPUTE_WIDTH = 1024;
+export declare const DEFAULT_COMPUTE_HEIGHT = 640;
+/** Storage format of the variable-blur radius map (caller-written). */
+export declare const BLUR_MAP_FORMAT: "rgba32float";
+/**
+ * Bindable source-texture forms accepted by the blur (the RTT being blurred). A `TgpuTexture`
+ * must carry `sampled` usage; callers may also pass a KitTexture's underlying view.
+ */
+export type BlurInputTexture = TgpuTextureView | TgpuTexture | GPUTextureView;
+/**
+ * Full symmetric Gaussian weights over the whole kernel (no truncation), normalized to 1.
+ * Used by the variable-radius blur, whose per-pixel tap spread is scaled at sample time so the
+ * weights describe SHAPE only.
+ */
+export declare function buildFixedWeights(halfKernel: number): number[];
+/**
+ * Truncated + renormalized Gaussian for one pass. Taps beyond ~3σ contribute nothing visible,
+ * so the active half-kernel is `clamp(ceil(3σ), 1, halfKernel)`; weights outside it are zero and
+ * the remaining support is renormalized to sum to 1. Returns the full-length weight array (zeros
+ * padded outside the active window) plus the active half so the kernel loop walks only that far.
+ * Pulled out of the per-frame `updateWeights` closure so it can be golden-tested on the CPU.
+ */
+export declare function buildTruncatedWeights(halfKernel: number, sigma: number): {
+    weights: number[];
+    activeHalf: number;
+};
+export interface GaussianBlurComputeResult {
+    /**
+     * Ordered compute steps: [horizontal pass, vertical pass]. Dispatch via the compute
+     * dispatcher. The horizontal pass reads the input texture; when the input is bound late
+     * (via `setInputTexture` — see blur-run note below) this array's H entry is swapped in place,
+     * so a caller that holds this array reference always dispatches the currently-bound H pass.
+     */
+    computeSteps: ComputeStep[];
+    /** rgba16float, storage + sampled. The buffer consumers bilinear-sample at canvas resolution. */
+    outputTexture: TgpuTexture;
+    updateRadius: (pixelRadius: number) => void;
+    /** Fixed compute resolution — exposed so callers know the buffer's pixel size. */
+    computeWidth: number;
+    computeHeight: number;
+    /** Update input-canvas dimensions on resize. Doesn't trigger any rebuild. */
+    setInputDimensions: (width: number, height: number) => void;
+    /**
+     * blur-run: (re)bind the source texture the H pass reads. Needed when the input is an RTT
+     * boundary the composition renders — the pass manager allocates that texture AFTER
+     * composition, so the consumer defers the input and binds it here once it exists (and rebinds
+     * on recompose). Rebuilds only the H bind group; the V pass is input-independent.
+     */
+    setInputTexture: (input: BlurInputTexture) => void;
+}
+export interface VariableBlurComputeResult {
+    computeSteps: ComputeStep[];
+    outputTexture: TgpuTexture;
+    /**
+     * rgba32float, storage. Stores the desired blur radius (input/canvas pixels) per compute
+     * pixel in its .r channel. The CALLER fills it in their own compute pass by binding it to a
+     * `{ storageTexture: d.textureStorage2d(BLUR_MAP_FORMAT, 'write-only') }` layout entry.
+     */
+    blurMapTexture: TgpuTexture;
+    computeWidth: number;
+    computeHeight: number;
+    setInputDimensions: (width: number, height: number) => void;
+    /** blur-run: (re)bind the source texture the H pass reads (see GaussianBlurComputeResult). */
+    setInputTexture: (input: BlurInputTexture) => void;
+}
+/**
+ * GPU-free construction of the fixed-blur node graph: bind-group layouts + kernel fns. No
+ * device is touched, so the kernels can be `tgpu.resolve`d for WGSL snapshots. `createGaussian
+ * BlurCompute` calls this and then allocates the resources + pipelines.
+ */
+export declare function buildFixedBlurGraph(halfKernel: number, computeWidth: number, computeHeight: number): {
+    hLayout: import('typegpu').TgpuBindGroupLayout<{
+        input: {
+            texture: d.WgslTexture2d<d.F32>;
+        };
+        intermediate: {
+            storageTexture: d.WgslStorageTexture2d<"rgba32float", string>;
+        };
+        weights: {
+            storage: d.WgslArray<d.F32>;
+            access: "readonly";
+        };
+        params: {
+            uniform: d.WgslStruct<{
+                activeHalf: d.I32;
+                inputWidth: d.F32;
+                inputHeight: d.F32;
+            }>;
+        };
+    }>;
+    vLayout: import('typegpu').TgpuBindGroupLayout<{
+        src: {
+            storageTexture: d.WgslStorageTexture2d<"rgba32float", string>;
+        };
+        output: {
+            storageTexture: d.WgslStorageTexture2d<"rgba16float", string>;
+        };
+        weights: {
+            storage: d.WgslArray<d.F32>;
+            access: "readonly";
+        };
+        params: {
+            uniform: d.WgslStruct<{
+                activeHalf: d.I32;
+            }>;
+        };
+    }>;
+    kernelH: import('typegpu').TgpuFn<(cx: d.U32, cy: d.U32) => d.Void>;
+    kernelV: import('typegpu').TgpuFn<(cx: d.U32, cy: d.U32) => d.Void>;
+    HParams: d.WgslStruct<{
+        activeHalf: d.I32;
+        inputWidth: d.F32;
+        inputHeight: d.F32;
+    }>;
+    VParams: d.WgslStruct<{
+        activeHalf: d.I32;
+    }>;
+    KERNEL_SIZE: number;
+};
+/**
+ * 2-pass separable Gaussian blur backed by compute shaders, fixed-resolution output. The
+ * fragment shader samples the result at canvas-resolution screenUV (bilinear handles up/downscale).
+ *
+ * @param root - the TypeGPU root (device).
+ * @param inputTexture - source texture view to blur (typically a `convertToTexture` RTT).
+ * @param inputWidth/inputHeight - source dimensions (canvas size).
+ * @param onCleanup - cleanup callback registration.
+ * @param halfKernel - half-kernel width (default 24 → 49 taps per pass).
+ * @param computeWidth/computeHeight - fixed internal compute resolution (never reallocated).
+ */
+export declare function createGaussianBlurCompute(root: TgpuRoot, inputTexture: BlurInputTexture | null, inputWidth: number, inputHeight: number, onCleanup: (cb: () => void) => void, halfKernel?: number, computeWidth?: number, computeHeight?: number): GaussianBlurComputeResult;
+/**
+ * GPU-free construction of the variable-blur node graph. `jitterTaps` is a build-time constant
+ * baked into the kernel bodies (comptime), so enabling it changes the emitted WGSL.
+ */
+export declare function buildVariableBlurGraph(halfKernel: number, computeWidth: number, computeHeight: number, jitterTaps: boolean): {
+    hLayout: import('typegpu').TgpuBindGroupLayout<{
+        blurMap: {
+            storageTexture: d.WgslStorageTexture2d<"rgba32float", string>;
+        };
+        input: {
+            texture: d.WgslTexture2d<d.F32>;
+        };
+        intermediate: {
+            storageTexture: d.WgslStorageTexture2d<"rgba32float", string>;
+        };
+        weights: {
+            storage: d.WgslArray<d.F32>;
+            access: "readonly";
+        };
+        params: {
+            uniform: d.WgslStruct<{
+                inputWidth: d.F32;
+                inputHeight: d.F32;
+            }>;
+        };
+    }>;
+    vLayout: import('typegpu').TgpuBindGroupLayout<{
+        blurMap: {
+            storageTexture: d.WgslStorageTexture2d<"rgba32float", string>;
+        };
+        src: {
+            storageTexture: d.WgslStorageTexture2d<"rgba32float", string>;
+        };
+        output: {
+            storageTexture: d.WgslStorageTexture2d<"rgba16float", string>;
+        };
+        weights: {
+            storage: d.WgslArray<d.F32>;
+            access: "readonly";
+        };
+        params: {
+            uniform: d.WgslStruct<{
+                scaleY: d.F32;
+            }>;
+        };
+    }>;
+    kernelH: import('typegpu').TgpuFn<(cx: d.U32, cy: d.U32) => d.Void>;
+    kernelV: import('typegpu').TgpuFn<(cx: d.U32, cy: d.U32) => d.Void>;
+    HParams: d.WgslStruct<{
+        inputWidth: d.F32;
+        inputHeight: d.F32;
+    }>;
+    VParams: d.WgslStruct<{
+        scaleY: d.F32;
+    }>;
+    KERNEL_SIZE: number;
+};
+/**
+ * Variable-radius (per-pixel) Gaussian blur with fixed-resolution output. The blur map texture is
+ * at compute resolution and stores the desired blur radius (input/canvas pixels) per compute
+ * pixel. The CALLER fills the map in their own compute pass by binding `blurMapTexture` to a
+ * write-only storage-texture entry (the `blurMapWriteNode` replacement).
+ *
+ * @param options.jitterTaps - opt-in interleaved-gradient-noise tap jitter (decorrelates the
+ *   fixed tap comb's moiré against periodic content). Baked into the WGSL at build time.
+ */
+export declare function createVariableGaussianBlurCompute(root: TgpuRoot, inputTexture: BlurInputTexture | null, inputWidth: number, inputHeight: number, onCleanup: (cb: () => void) => void, halfKernel?: number, computeWidth?: number, computeHeight?: number, options?: {
+    jitterTaps?: boolean;
+}): VariableBlurComputeResult;
+//# sourceMappingURL=blur.d.ts.map

package/dist/core/gpu/kit/blur.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blur.d.ts","sourceRoot":"","sources":["../../../src/gpu/kit/blur.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,OAAa,EAAC,KAAK,QAAQ,EAAE,KAAK,WAAW,EAAE,KAAK,eAAe,EAAC,MAAM,SAAS,CAAA;AACnF,OAAO,KAAK,CAAC,MAAM,cAAc,CAAA;AAEjC,OAAO,EAAuB,KAAK,WAAW,EAA0B,MAAM,YAAY,CAAA;AAI1F;;;sBAGsB;AACtB,eAAO,MAAM,qBAAqB,OAAO,CAAA;AACzC,eAAO,MAAM,sBAAsB,MAAM,CAAA;AAUzC,uEAAuE;AACvE,eAAO,MAAM,eAAe,EAAG,aAAsB,CAAA;AAErD;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG,eAAe,GAAG,WAAW,GAAG,cAAc,CAAA;AAE7E;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,CAY9D;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG;IAAC,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAC,CAchH;AAED,MAAM,WAAW,yBAAyB;IACtC;;;;;OAKG;IACH,YAAY,EAAE,WAAW,EAAE,CAAA;IAC3B,iGAAiG;IACjG,aAAa,EAAE,WAAW,CAAA;IAC1B,YAAY,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,IAAI,CAAA;IAC3C,kFAAkF;IAClF,YAAY,EAAE,MAAM,CAAA;IACpB,aAAa,EAAE,MAAM,CAAA;IACrB,6EAA6E;IAC7E,kBAAkB,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,CAAA;IAC3D;;;;;OAKG;IACH,eAAe,EAAE,CAAC,KAAK,EAAE,gBAAgB,KAAK,IAAI,CAAA;CACrD;AAED,MAAM,WAAW,yBAAyB;IACtC,YAAY,EAAE,WAAW,EAAE,CAAA;IAC3B,aAAa,EAAE,WAAW,CAAA;IAC1B;;;;OAIG;IACH,cAAc,EAAE,WAAW,CAAA;IAC3B,YAAY,EAAE,MAAM,CAAA;IACpB,aAAa,EAAE,MAAM,CAAA;IACrB,kBAAkB,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,CAAA;IAC3D,8FAA8F;IAC9F,eAAe,EAAE,CAAC,KAAK,EAAE,gBAAgB,KAAK,IAAI,CAAA;CACrD;AAWD;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgElG;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,yBAAyB,CACrC,IAAI,EAAE,QAAQ,EACd,YAAY,EAAE,gBAAgB,GAAG,IAAI,EACrC,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,CAAC,EAAE,EAAE,MAAM,IAAI,KAAK,IAAI,EACnC,UAAU,GAAE,MAA4B,EACxC,YAAY,GAAE,MAA8B,EAC5C,aAAa,GAAE,MAA+B,GAC/C,yBAAyB,CAmG3B;AAUD;;;GAGG;AACH,wBAAgB,sBAAsB,CAClC,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,MAAM,EACpB,aAAa,EAAE,MAAM,EACrB,UAAU,EAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmFtB;AAED;;;;;;;;GAQG;AACH,wBAAgB,iCAAiC,CAC7C,IAAI,EAAE,QAAQ,EACd,YAAY,EAAE,gBAAgB,GAAG,IAAI,EACrC,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,CAAC,EAAE,EAAE,MAAM,IAAI,KAAK,IAAI,EACnC,UAAU,GAAE,MAA4B,EACxC,YAAY,GAAE,MAA8B,EAC5C,aAAa,GAAE,MAA+B,EAC9C,OAAO,CAAC,EAAE;IAAC,UAAU,CAAC,EAAE,OAAO,CAAA;CAAC,GACjC,yBAAyB,CAqE3B"}

package/dist/core/gpu/kit/colorMixing.d.ts

@@ -0,0 +1,112 @@
+import { d } from './index';
+
+/** P3-linear → sRGB-linear (D65). */
+export declare const p3ToSRGB: import('typegpu').TgpuFn<(p3: d.Vec3f) => d.Vec3f>;
+/** sRGB-linear → P3-linear (inverse of p3ToSRGB). */
+export declare const sRGBToP3: import('typegpu').TgpuFn<(srgb: d.Vec3f) => d.Vec3f>;
+/** sRGB-linear → OKLab (Björn Ottosson). Sign-preserving cube root for negative lobes. */
+export declare const rgbToOklab: import('typegpu').TgpuFn<(rgb: d.Vec3f) => d.Vec3f>;
+/** OKLab → sRGB-linear. */
+export declare const oklabToRgb: import('typegpu').TgpuFn<(lab: d.Vec3f) => d.Vec3f>;
+/** OKLab → OKLCh (cylindrical). */
+export declare const oklabToOklch: import('typegpu').TgpuFn<(lab: d.Vec3f) => d.Vec3f>;
+/** OKLCh → OKLab. */
+export declare const oklchToOklab: import('typegpu').TgpuFn<(lch: d.Vec3f) => d.Vec3f>;
+/**
+ * Select RGB components for a hue sector (0-5), shared by HSL/HSV → RGB.
+ *   0:[0,1)→(c,x,0) 1:[1,2)→(x,c,0) 2:[2,3)→(0,c,x) 3:[3,4)→(0,x,c) 4:[4,5)→(x,0,c) 5:[5,6)→(c,0,x)
+ */
+export declare const selectRGBBySector: import('typegpu').TgpuFn<(c: d.F32, x: d.F32, sector: d.F32) => d.Vec3f>;
+/** sRGB-linear → HSL (hue in radians, 0..2π). */
+export declare const rgbToHsl: import('typegpu').TgpuFn<(rgb: d.Vec3f) => d.Vec3f>;
+/** HSL → sRGB-linear. */
+export declare const hslToRgb: import('typegpu').TgpuFn<(hsl: d.Vec3f) => d.Vec3f>;
+/** sRGB-linear → HSV (hue in radians). */
+export declare const rgbToHsv: import('typegpu').TgpuFn<(rgb: d.Vec3f) => d.Vec3f>;
+/** HSV → sRGB-linear. */
+export declare const hsvToRgb: import('typegpu').TgpuFn<(hsv: d.Vec3f) => d.Vec3f>;
+/** sRGB-linear → CIE Lab (D65). */
+export declare const rgbToLab: import('typegpu').TgpuFn<(rgb: d.Vec3f) => d.Vec3f>;
+/** CIE Lab → sRGB-linear. */
+export declare const labToRgb: import('typegpu').TgpuFn<(lab: d.Vec3f) => d.Vec3f>;
+/** CIE Lab → LCh (cylindrical). */
+export declare const labToLch: import('typegpu').TgpuFn<(lab: d.Vec3f) => d.Vec3f>;
+/** LCh → CIE Lab. */
+export declare const lchToLab: import('typegpu').TgpuFn<(lch: d.Vec3f) => d.Vec3f>;
+/**
+ * Six pre-transpiled `mixColors` variants — full round-trip mix for each color space.
+ * Alpha weighting ensures transparent colors (alpha=0) never contribute their RGB; output
+ * alpha is the weighted sum (standard alpha interpolation). Signature matches the composer's
+ * expectation: (colorA: v4f P3-linear, colorB: v4f P3-linear, t: f32) → v4f P3-linear.
+ */
+export declare const mixColorsLinear: import('typegpu').TgpuFn<(colorA: d.Vec4f, colorB: d.Vec4f, t: d.F32) => d.Vec4f>;
+export declare const mixColorsOklch: import('typegpu').TgpuFn<(colorA: d.Vec4f, colorB: d.Vec4f, t: d.F32) => d.Vec4f>;
+export declare const mixColorsOklab: import('typegpu').TgpuFn<(colorA: d.Vec4f, colorB: d.Vec4f, t: d.F32) => d.Vec4f>;
+export declare const mixColorsHsl: import('typegpu').TgpuFn<(colorA: d.Vec4f, colorB: d.Vec4f, t: d.F32) => d.Vec4f>;
+export declare const mixColorsHsv: import('typegpu').TgpuFn<(colorA: d.Vec4f, colorB: d.Vec4f, t: d.F32) => d.Vec4f>;
+export declare const mixColorsLch: import('typegpu').TgpuFn<(colorA: d.Vec4f, colorB: d.Vec4f, t: d.F32) => d.Vec4f>;
+/** mixColors variants keyed by colorSpaceMode (0 linear · 1 OKLCh · 2 OKLAB · 3 HSL · 4 HSV · 5 LCH). */
+export declare const mixColorsVariants: {
+    readonly 0: import('typegpu').TgpuFn<(colorA: d.Vec4f, colorB: d.Vec4f, t: d.F32) => d.Vec4f>;
+    readonly 1: import('typegpu').TgpuFn<(colorA: d.Vec4f, colorB: d.Vec4f, t: d.F32) => d.Vec4f>;
+    readonly 2: import('typegpu').TgpuFn<(colorA: d.Vec4f, colorB: d.Vec4f, t: d.F32) => d.Vec4f>;
+    readonly 3: import('typegpu').TgpuFn<(colorA: d.Vec4f, colorB: d.Vec4f, t: d.F32) => d.Vec4f>;
+    readonly 4: import('typegpu').TgpuFn<(colorA: d.Vec4f, colorB: d.Vec4f, t: d.F32) => d.Vec4f>;
+    readonly 5: import('typegpu').TgpuFn<(colorA: d.Vec4f, colorB: d.Vec4f, t: d.F32) => d.Vec4f>;
+};
+/**
+ * Mix two P3-linear colors in the given space. `colorSpaceMode` is a compile-time JS number
+ * (part of the pipeline hash), so this is a CPU/builder-level dispatcher — it selects the
+ * matching pre-transpiled variant. Do NOT call this inside a `'use gpu'` body; reference
+ * `mixColorsVariants[mode]` (a `tgpu.fn`) there instead.
+ */
+export declare const mixColors: (colorA: d.v4f, colorB: d.v4f, t: number, colorSpaceMode: number) => d.v4f;
+/** Forward half of a color-space blend: P3-linear → working space for `colorSpaceMode`. */
+export declare const convertP3ToMixSpace: (p3: d.v3f, colorSpaceMode: number) => d.v3f;
+/** Back half of a color-space blend: working space → P3-linear. Pair with convertP3ToMixSpace. */
+export declare const convertMixSpaceToP3: (mixed: d.v3f, colorSpaceMode: number) => d.v3f;
+/** Working-space step packed with its accumulated alpha, for chaining preconverted mixes. */
+export declare const MixStep: d.WgslStruct<{
+    conv: d.Vec3f;
+    alpha: d.F32;
+}>;
+/**
+ * One alpha-weighted mix step performed IN the working space, for chaining (identical math to
+ * the mix inside mixColors, minus the back-conversion). Feed one step's conv/alpha into the
+ * next; call `convertMixSpaceToP3` once on the final conv.
+ */
+export declare const mixPreconvertedInSpace: import('typegpu').TgpuFn<(convA: d.Vec3f, alphaA: d.F32, convB: d.Vec3f, alphaB: d.F32, t: d.F32) => d.WgslStruct<{
+    conv: d.Vec3f;
+    alpha: d.F32;
+}>>;
+/**
+ * Six pre-transpiled variants of the preconverted-endpoint mix + back-conversion.
+ * convA/convB are endpoints already in the working space (see convertP3ToMixSpace); alphas are
+ * read per pixel; result is P3-linear. Mode 0 endpoints are raw P3 — no back-conversion.
+ */
+export declare const mixPreconvertedLinear: import('typegpu').TgpuFn<(convA: d.Vec3f, convB: d.Vec3f, alphaA: d.F32, alphaB: d.F32, t: d.F32) => d.Vec4f>;
+export declare const mixPreconvertedOklch: import('typegpu').TgpuFn<(convA: d.Vec3f, convB: d.Vec3f, alphaA: d.F32, alphaB: d.F32, t: d.F32) => d.Vec4f>;
+export declare const mixPreconvertedOklab: import('typegpu').TgpuFn<(convA: d.Vec3f, convB: d.Vec3f, alphaA: d.F32, alphaB: d.F32, t: d.F32) => d.Vec4f>;
+export declare const mixPreconvertedHsl: import('typegpu').TgpuFn<(convA: d.Vec3f, convB: d.Vec3f, alphaA: d.F32, alphaB: d.F32, t: d.F32) => d.Vec4f>;
+export declare const mixPreconvertedHsv: import('typegpu').TgpuFn<(convA: d.Vec3f, convB: d.Vec3f, alphaA: d.F32, alphaB: d.F32, t: d.F32) => d.Vec4f>;
+export declare const mixPreconvertedLch: import('typegpu').TgpuFn<(convA: d.Vec3f, convB: d.Vec3f, alphaA: d.F32, alphaB: d.F32, t: d.F32) => d.Vec4f>;
+export declare const mixPreconvertedVariants: {
+    readonly 0: import('typegpu').TgpuFn<(convA: d.Vec3f, convB: d.Vec3f, alphaA: d.F32, alphaB: d.F32, t: d.F32) => d.Vec4f>;
+    readonly 1: import('typegpu').TgpuFn<(convA: d.Vec3f, convB: d.Vec3f, alphaA: d.F32, alphaB: d.F32, t: d.F32) => d.Vec4f>;
+    readonly 2: import('typegpu').TgpuFn<(convA: d.Vec3f, convB: d.Vec3f, alphaA: d.F32, alphaB: d.F32, t: d.F32) => d.Vec4f>;
+    readonly 3: import('typegpu').TgpuFn<(convA: d.Vec3f, convB: d.Vec3f, alphaA: d.F32, alphaB: d.F32, t: d.F32) => d.Vec4f>;
+    readonly 4: import('typegpu').TgpuFn<(convA: d.Vec3f, convB: d.Vec3f, alphaA: d.F32, alphaB: d.F32, t: d.F32) => d.Vec4f>;
+    readonly 5: import('typegpu').TgpuFn<(convA: d.Vec3f, convB: d.Vec3f, alphaA: d.F32, alphaB: d.F32, t: d.F32) => d.Vec4f>;
+};
+/**
+ * Mix two preconverted endpoints (see convertP3ToMixSpace) in `colorSpaceMode` and convert the
+ * result to P3-linear. CPU/builder-level dispatcher (mode is compile-time), same as mixColors.
+ */
+export declare const mixPreconvertedColors: (convA: d.v3f, convB: d.v3f, alphaA: number, alphaB: number, t: number, colorSpaceMode: number) => d.v4f;
+/**
+ * CPU mirror of the per-space forward conversion used inside mixColors. Input: P3-linear RGB.
+ * Output: the triplet in the mix space for `colorSpaceMode` (1 OKLCh · 2 OKLAB · 3 HSL · 4 HSV
+ * · 5 LCH). Mode 0 needs no conversion — keep using mixColors directly for linear RGB.
+ */
+export declare const convertP3ToMixSpaceCPU: (r: number, g: number, b: number, colorSpaceMode: number) => [number, number, number];
+//# sourceMappingURL=colorMixing.d.ts.map

package/dist/core/gpu/kit/colorMixing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"colorMixing.d.ts","sourceRoot":"","sources":["../../../src/gpu/kit/colorMixing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,EAAC,CAAC,EAAY,MAAM,SAAS,CAAA;AAepC,qCAAqC;AACrC,eAAO,MAAM,QAAQ,oDAMnB,CAAA;AAEF,qDAAqD;AACrD,eAAO,MAAM,QAAQ,sDAMnB,CAAA;AAIF,0FAA0F;AAC1F,eAAO,MAAM,UAAU,qDAoBrB,CAAA;AAEF,2BAA2B;AAC3B,eAAO,MAAM,UAAU,qDAmBrB,CAAA;AAEF,mCAAmC;AACnC,eAAO,MAAM,YAAY,qDAQvB,CAAA;AAEF,qBAAqB;AACrB,eAAO,MAAM,YAAY,qDAMvB,CAAA;AAIF;;;GAGG;AACH,eAAO,MAAM,iBAAiB,0EAyB5B,CAAA;AAIF,iDAAiD;AACjD,eAAO,MAAM,QAAQ,qDAyBnB,CAAA;AAEF,yBAAyB;AACzB,eAAO,MAAM,QAAQ,qDAYnB,CAAA;AAIF,0CAA0C;AAC1C,eAAO,MAAM,QAAQ,qDAsBnB,CAAA;AAEF,yBAAyB;AACzB,eAAO,MAAM,QAAQ,qDAYnB,CAAA;AAIF,mCAAmC;AACnC,eAAO,MAAM,QAAQ,qDAyBnB,CAAA;AAEF,6BAA6B;AAC7B,eAAO,MAAM,QAAQ,qDAyBnB,CAAA;AAEF,mCAAmC;AACnC,eAAO,MAAM,QAAQ,qDAQnB,CAAA;AAEF,qBAAqB;AACrB,eAAO,MAAM,QAAQ,qDAMnB,CAAA;AAUF;;;;;GAKG;AACH,eAAO,MAAM,eAAe,mFAQ1B,CAAA;AAEF,eAAO,MAAM,cAAc,mFAWzB,CAAA;AAEF,eAAO,MAAM,cAAc,mFAWzB,CAAA;AAEF,eAAO,MAAM,YAAY,mFAWvB,CAAA;AAEF,eAAO,MAAM,YAAY,mFAWvB,CAAA;AAEF,eAAO,MAAM,YAAY,mFAWvB,CAAA;AAEF,yGAAyG;AACzG,eAAO,MAAM,iBAAiB;;;;;;;CAOpB,CAAA;AAEV;;;;;GAKG;AACH,eAAO,MAAM,SAAS,WAAY,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,GAAG,KAAK,MAAM,kBAAkB,MAAM,KAAG,CAAC,CAAC,GAG7F,CAAA;AAOD,2FAA2F;AAC3F,eAAO,MAAM,mBAAmB,OAAQ,CAAC,CAAC,GAAG,kBAAkB,MAAM,KAAG,CAAC,CAAC,GASzE,CAAA;AAED,kGAAkG;AAClG,eAAO,MAAM,mBAAmB,UAAW,CAAC,CAAC,GAAG,kBAAkB,MAAM,KAAG,CAAC,CAAC,GAS5E,CAAA;AAID,6FAA6F;AAC7F,eAAO,MAAM,OAAO;;;EAA0C,CAAA;AAE9D;;;;GAIG;AACH,eAAO,MAAM,sBAAsB;;;GASlC,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,+GAUjC,CAAA;AAED,eAAO,MAAM,oBAAoB,+GAUhC,CAAA;AAED,eAAO,MAAM,oBAAoB,+GAUhC,CAAA;AAED,eAAO,MAAM,kBAAkB,+GAU9B,CAAA;AAED,eAAO,MAAM,kBAAkB,+GAU9B,CAAA;AAED,eAAO,MAAM,kBAAkB,+GAU9B,CAAA;AAED,eAAO,MAAM,uBAAuB;;;;;;;CAO1B,CAAA;AAEV;;;GAGG;AACH,eAAO,MAAM,qBAAqB,UACvB,CAAC,CAAC,GAAG,SACL,CAAC,CAAC,GAAG,UACJ,MAAM,UACN,MAAM,KACX,MAAM,kBACO,MAAM,KACvB,CAAC,CAAC,GAGJ,CAAA;AA6DD;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,MAC5B,MAAM,KAAK,MAAM,KAAK,MAAM,kBAAkB,MAAM,KACxD,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAgBzB,CAAA"}