shaders 2.5.135 → 3.0.437

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

@@ -0,0 +1,646 @@
+import { d } from './index';
+import { InferInput } from 'typegpu/data';
+import { TgpuRoot, TgpuTexture } from 'typegpu';
+import { KitComputePipeline } from '../compute';
+import { isMobileGpuViewport } from '../../utilities/device';
+import { Expr, GpuFragmentParams, KitTexture, GpuComputeStep } from '../contract';
+
+export { isMobileGpuViewport };
+export declare const SHAPE3D_TYPES: readonly ["sphere3D", "cube3D", "torus3D", "octahedron3D", "cylinder3D", "capsule3D", "cone3D", "pyramid3D", "prism3D", "ellipsoid3D", "diamond3D", "link3D", "gem3D", "helix3D", "metaballs3D", "dodecahedron3D", "hemisphere3D", "ribbon3D", "blob3D", "gyroscope3D"];
+export type Shape3DType = typeof SHAPE3D_TYPES[number];
+export declare function is3dShapeType(shapeType: string): shapeType is Shape3DType;
+export declare const SVG3D_TYPES: readonly ["svgExtrude3D"];
+export type Svg3DType = typeof SVG3D_TYPES[number];
+export declare function isSvg3dShapeType(shapeType: string): shapeType is Svg3DType;
+/** True when the shape type produces a volumetric (raymarched) field — analytic 3D or SVG 3D. */
+export declare function isVolumetricShapeType(shapeType: string): boolean;
+/** Defaults for the SVG 3D sub-props stored in the shape JSON (shared by sampler, bounds, and UI). */
+export declare const SVG3D_DEFAULTS: Record<string, number>;
+/**
+ * Per-frame context for resolving shape sub-props: time (auto-animate phase), pointer
+ * (mouse drivers) and a persistent per-key spring store (mouse smoothing/momentum).
+ */
+export interface ShapeSubPropFrame {
+    /** Wall-clock seconds since sampler creation (drives auto-animate phase). */
+    elapsed: number;
+    /** Seconds since the previous frame (drives mouse spring integration). */
+    deltaTime: number;
+    /** Normalised pointer position in [0,1]. */
+    pointerX: number;
+    pointerY: number;
+    /** Persistent spring state per sub-prop key (mouse smoothing/momentum). */
+    springs: Map<string, {
+        current: number;
+        velocity: number;
+    }>;
+}
+/**
+ * Resolve a shape sub-prop value that may be a number, an auto-animate config, or a
+ * mouse config. Auto base rate matches the renderer's prop drivers (0.2 cycles/sec →
+ * 5s full cycle at speed 1); mouse mapping (axis → spring → curve → output range)
+ * mirrors the renderer's resolveMouseMapForProp so behaviour matches top-level props.
+ */
+export declare function resolveShapeSubProp(value: any, fallback: number, frame: ShapeSubPropFrame, key: string): number;
+/** Static bound for a sub-prop value: the largest magnitude it can take (for bounding boxes). */
+export declare function shapeSubPropMax(value: any, fallback: number): number;
+export declare const SHAPE3D_DEFAULTS: Record<Shape3DType, Record<string, number>>;
+/**
+ * Conservative bounding radius (field UV units) for a 3D shape config — radius of
+ * the bounding sphere, which contains the silhouette under any rotation.
+ * Sub-prop values may be auto-animate configs; the max output bound is used.
+ */
+export declare function shape3dBoundingRadius(cfg: Record<string, any>): number;
+/** Fixed winding count for the helix (not user-exposed — `pitch` alone drives the
+ *  height). Kept as a constant so the SDF, bounds, and march agree. */
+export declare const HELIX_TURNS = 3;
+/** CPU-value rotation holder (a type alias — the consumer re-assembles it on TypeGPU uniforms;
+ *  see CONSUMER WIRES). */
+export interface RotUniforms {
+    cx: any;
+    sx: any;
+    cy: any;
+    sy: any;
+    cz: any;
+    sz: any;
+}
+/**
+ * How the march fills the surface-locked pattern coords (.g/.b):
+ *  - 'none'      → not computed (left 0). The cheapest; use when the consumer only
+ *                  reads .r (field/chord) and .a (depth). Skips ALL pattern work.
+ *  - 'raw'       → oblique projection of the raw shape-local hit position. Seamless,
+ *                  rotates with the solid, zero extra SDF evals.
+ *  - 'triplanar' → per-face axis pick from the local surface normal. Costs SIX extra
+ *                  sdf() evals per hit (a full normal probe). Only Crystal needs this.
+ *
+ * Defaulting to 'none' means a shader pays for pattern coords only by opting in —
+ * the 6-eval triplanar probe no longer runs for the effects that ignore .g/.b.
+ */
+export type SurfacePatternMode = 'none' | 'raw' | 'triplanar';
+/** CPU mirror of the GPU `rotateVec3` (same ZXY order) for plain JS scalars — used to project
+ *  an oriented bounding box onto the field axes for the aspect-fit domain. Returns
+ *  the rotated vector as {x, y, z}. */
+export declare function rotateVecCpu(vx: number, vy: number, vz: number, s: {
+    cx: number;
+    sx: number;
+    cy: number;
+    sy: number;
+    cz: number;
+    sz: number;
+}): {
+    x: number;
+    y: number;
+    z: number;
+};
+/** Sphere: `|p| - r`. */
+export declare const sdSphere: import('typegpu').TgpuFn<(p: d.Vec3f, r: d.F32) => d.F32>;
+/** Rounded box: half-extents (hx,hy,hz), corner rounding. */
+export declare const sdRoundBox: import('typegpu').TgpuFn<(p: d.Vec3f, hx: d.F32, hy: d.F32, hz: d.F32, rounding: d.F32) => d.F32>;
+/** Torus: ring radius `ringR` (in xz), tube radius `tubeR` (about y). */
+export declare const sdTorus: import('typegpu').TgpuFn<(p: d.Vec3f, ringR: d.F32, tubeR: d.F32) => d.F32>;
+/** Octahedron (iq, bound version): scaled L1 distance — Lipschitz-safe with the march's
+ *  min-step guard. */
+export declare const sdOctahedron: import('typegpu').TgpuFn<(p: d.Vec3f, s: d.F32) => d.F32>;
+/** Rounded cylinder: radius `r`, half-height `h`, corner rounding. */
+export declare const sdRoundCylinder: import('typegpu').TgpuFn<(p: d.Vec3f, r: d.F32, h: d.F32, rounding: d.F32) => d.F32>;
+/** Capsule: radius `r`, half-height `h` (about y). */
+export declare const sdCapsule: import('typegpu').TgpuFn<(p: d.Vec3f, r: d.F32, h: d.F32) => d.F32>;
+export declare const sdCappedCone: import('typegpu').TgpuFn<(p: d.Vec3f, r1: d.F32, r2: d.F32, h: d.F32) => d.F32>;
+export declare const sdPyramid: import('typegpu').TgpuFn<(p: d.Vec3f, b: d.F32, ht: d.F32) => d.F32>;
+export declare const sdHexPrism: import('typegpu').TgpuFn<(p: d.Vec3f, r: d.F32, he: d.F32) => d.F32>;
+export declare const sdEllipsoid: import('typegpu').TgpuFn<(p: d.Vec3f, rx: d.F32, ry: d.F32, rz: d.F32) => d.F32>;
+export declare const sdBicone: import('typegpu').TgpuFn<(p: d.Vec3f, r: d.F32, h: d.F32) => d.F32>;
+export declare const sdLink: import('typegpu').TgpuFn<(p: d.Vec3f, le: d.F32, r1: d.F32, r2: d.F32) => d.F32>;
+export declare const smin: import('typegpu').TgpuFn<(a: d.F32, b: d.F32, k: d.F32) => d.F32>;
+export declare const sdGem: import('typegpu').TgpuFn<(p: d.Vec3f, r: d.F32, h: d.F32, sides: d.F32) => d.F32>;
+export declare const sdHelix: import('typegpu').TgpuFn<(p: d.Vec3f, R: d.F32, tube: d.F32, pitch: d.F32, turns: d.F32) => d.F32>;
+export declare const sdMetaballs: import('typegpu').TgpuFn<(p: d.Vec3f, b0: d.Vec3f, b1: d.Vec3f, b2: d.Vec3f, b3: d.Vec3f, r: d.F32, k: d.F32) => d.F32>;
+export declare const sdDodecahedron: import('typegpu').TgpuFn<(p: d.Vec3f, r: d.F32) => d.F32>;
+export declare const sdCutSphere: import('typegpu').TgpuFn<(p: d.Vec3f, r: d.F32, h: d.F32) => d.F32>;
+export declare const sdRibbon: import('typegpu').TgpuFn<(p: d.Vec3f, w: d.F32, th: d.F32, len: d.F32, amp: d.F32, freq: d.F32, ph1: d.F32, ph2: d.F32, twRate: d.F32, twPh: d.F32, lip: d.F32) => d.F32>;
+export declare const sdWobbleBlob: import('typegpu').TgpuFn<(p: d.Vec3f, r: d.F32, amp: d.F32, freq: d.F32, ph1: d.F32, ph2: d.F32, lip: d.F32) => d.F32>;
+export declare const sdFlatBand: import('typegpu').TgpuFn<(radialDist: d.F32, axialDist: d.F32, R: d.F32, ht: d.F32, hw: d.F32, rnd: d.F32) => d.F32>;
+export declare const sdGyroscope: import('typegpu').TgpuFn<(p: d.Vec3f, radius: d.F32, width: d.F32, thick: d.F32, rnd: d.F32, core: d.F32, c1: d.F32, s1: d.F32, c2: d.F32, s2: d.F32, c3: d.F32, s3: d.F32) => d.F32>;
+/** CPU-precomputed sin/cos rotation, passed to the march as one struct argument (ZXY Euler). */
+export declare const RotStruct: d.WgslStruct<{
+    cx: d.F32;
+    sx: d.F32;
+    cy: d.F32;
+    sy: d.F32;
+    cz: d.F32;
+    sz: d.F32;
+}>;
+/** Rotate a vector by ZXY Euler angles using CPU-precomputed sin/cos uniforms (GPU). */
+export declare const rotateVec3: import('typegpu').TgpuFn<(v: d.Vec3f, rot: d.WgslStruct<{
+    cx: d.F32;
+    sx: d.F32;
+    cy: d.F32;
+    sy: d.F32;
+    cz: d.F32;
+    sz: d.F32;
+}>) => d.Vec3f>;
+/** A shape SDF baked with its size params — the piece the march consumes. */
+export type BakedSdf = (p: any) => any;
+/**
+ * Shared orthographic raymarch core: turns any Lipschitz-safe 3D SDF into a 2D field sampler.
+ * Returns a resolvable `tgpu.fn([d.vec2f, RotStruct, d.f32], d.vec4f)`:
+ *   .r = scalar field (silhouette distance outside, −chord/2 inside)
+ *   .g/.b = surface-locked pattern coords (per `patternMode`; 0 when 'none')
+ *   .a = view-space hit depth (tEnter) along the ray
+ *
+ * `fuv` = field UV, `rot` = the CPU-precomputed rotation struct, `rBound` = a bounding-sphere
+ * radius that always contains the solid (used to skip empty space analytically).
+ *
+ * The shape's size params are baked into `sdfFn` by the caller (a `tgpu.fn([d.vec3f], d.f32)`
+ * reading its size uniforms); `patternMode` is a build-time JS string that selects the emitted
+ * branch (only 'triplanar' emits the 6-eval normal probe; 'none' emits no pattern code).
+ */
+export declare function buildRaymarchedFieldFn(sdfFn: BakedSdf, patternMode?: SurfacePatternMode): import('typegpu').TgpuFn<(fuv: d.Vec2f, rot: d.WgslStruct<{
+    cx: d.F32;
+    sx: d.F32;
+    cy: d.F32;
+    sy: d.F32;
+    cz: d.F32;
+    sz: d.F32;
+}>, rBound: d.F32) => d.Vec4f>;
+/** Thin wrapper for `buildRaymarchedFieldFn` (the march fn is the value itself; rotation +
+ *  bounding radius are call arguments, not build-time closures). */
+export declare function buildRaymarchedField(sdfFn: BakedSdf, patternMode?: SurfacePatternMode): import('typegpu').TgpuFn<(fuv: d.Vec2f, rot: d.WgslStruct<{
+    cx: d.F32;
+    sx: d.F32;
+    cy: d.F32;
+    sy: d.F32;
+    cz: d.F32;
+    sz: d.F32;
+}>, rBound: d.F32) => d.Vec4f>;
+/** Field texture format. rgba32float is required (fp16 quantizes the depth channel → visible
+ *  banding in the reconstructed normals) and is NOT filterable in WebGPU, hence the manual
+ *  bilinear/Catmull-Rom in the samplers. */
+export declare const VOLUMETRIC_FIELD_FORMAT: "rgba32float";
+/** Field-texture resolution. The near-binary edge mask of Neon/Holographic/Crystal exposes the
+ *  texel lattice as jagged silhouettes once a field texel spans more than ~1 device pixel. 1536
+ *  is the middle ground (1.5× the linear resolution of 1024, 2.25× the march cost, 36 MB fp32 vs
+ *  16 MB) which — together with the aspect-fit domain — gets the strokes below device-pixel
+ *  frequency without the 4× hit of 2048. The march only re-runs on shape-state changes. */
+export declare const VOLUMETRIC_FIELD_RES = 1536;
+/** Mobile/tablet field-texture ALLOCATION (VRAM ceiling + activeRes cap). A coarse-pointer device
+ *  gets a smaller field than the 1536 desktop default: its GPU can't afford the desktop march
+ *  (cost scales with res²) and the texture is heavy (768² is 9 MB fp32 vs 1024²'s 16 MB vs 1536²'s
+ *  36 MB). Why 768 and not 1024: on mobile the active region is sized at HALF the device-pixel
+ *  footprint, so a typical phone shape already resolves to ≤640 — well under this cap. */
+export declare const VOLUMETRIC_FIELD_RES_MOBILE = 768;
+/**
+ * Pick the pre-march field resolution for this device, once, at shader-build time.
+ *
+ * The field texture is allocated when the sampler node is built and is NEVER reallocated
+ * afterwards (the renderer keeps resize free of texture reallocation), so we can't track the live
+ * canvas size. The one signal available synchronously is the device class, which is exactly what
+ * separates "needs the full desktop field" from "a phone that shouldn't pay for a 2K texture".
+ */
+export declare function resolveVolumetricFieldRes(): number;
+/**
+ * Pick the active march/sample resolution for a shape from its on-screen footprint.
+ *
+ * The field domain covers the shape's AABB (spanX × spanY in field-UV). The shader maps field-UV
+ * → screen with the `scale` uniform, so matching one field texel to one device pixel along the
+ * tighter axis means activeRes ≈ max(spanX,spanY) · scale · Hdev. We snap up to a bucket and clamp
+ * to the texture allocation. `prevRes` adds a shrink deadband so a shape hovering on a boundary
+ * doesn't re-march every frame.
+ */
+export declare function resolveActiveFieldRes(spanXv: number, spanYv: number, scale: number, canvasHeightDevicePx: number, maxRes: number, prevRes: number): number;
+/**
+ * March-pass uniform. Holds the rotation, bounding radius, aspect-fit domain (span/origin), active
+ * resolution, AND the shape's size superset (pA..pD + four metaball centres) so the caller's
+ * baked `sdfFn` reads its params from `layout.$.params.pA` etc. It is a superset; unused fields are
+ * never read by the shape's kernel. (The consumer's per-frame CPU setup writes this each time the
+ * shape state changes — see CONSUMER WIRES.)
+ */
+export declare const MarchParams: d.WgslStruct<{
+    rot: d.Decorated<d.WgslStruct<{
+        cx: d.F32;
+        sx: d.F32;
+        cy: d.F32;
+        sy: d.F32;
+        cz: d.F32;
+        sz: d.F32;
+    }>, [d.Align<16>, d.Size<32>]>;
+    rBound: d.F32;
+    spanX: d.F32;
+    spanY: d.F32;
+    originX: d.F32;
+    originY: d.F32;
+    activeRes: d.U32;
+    pA: d.F32;
+    pB: d.F32;
+    pC: d.F32;
+    pD: d.F32;
+    mb0: d.Vec3f;
+    mb1: d.Vec3f;
+    mb2: d.Vec3f;
+    mb3: d.Vec3f;
+}>;
+/**
+ * Build the GPU-free compute bind-group layout for the pre-march (kit/blur `build*Graph` pattern):
+ *   - `field`  → the write-only rgba32float storage texture the march fills.
+ *   - `params` → the `MarchParams` uniform.
+ *
+ * The caller threads the returned `layout` through both the baked `sdfFn` (which reads
+ * `layout.$.params.pA` …) and `buildVolumetricFieldKernel`, so everything shares one layout / one
+ * bind group. Returned separately from the kernel so the parent can bake `sdfFn` against
+ * `layout.$.params` before the march + kernel are built.
+ */
+export declare function makeVolumetricFieldLayout(): {
+    layout: import('typegpu').TgpuBindGroupLayout<{
+        field: {
+            storageTexture: d.WgslStorageTexture2d<"rgba32float", string>;
+        };
+        params: {
+            uniform: d.WgslStruct<{
+                rot: d.Decorated<d.WgslStruct<{
+                    cx: d.F32;
+                    sx: d.F32;
+                    cy: d.F32;
+                    sy: d.F32;
+                    cz: d.F32;
+                    sz: d.F32;
+                }>, [d.Align<16>, d.Size<32>]>;
+                rBound: d.F32;
+                spanX: d.F32;
+                spanY: d.F32;
+                originX: d.F32;
+                originY: d.F32;
+                activeRes: d.U32;
+                pA: d.F32;
+                pB: d.F32;
+                pC: d.F32;
+                pD: d.F32;
+                mb0: d.Vec3f;
+                mb1: d.Vec3f;
+                mb2: d.Vec3f;
+                mb3: d.Vec3f;
+            }>;
+        };
+    }>;
+    MarchParams: d.WgslStruct<{
+        rot: d.Decorated<d.WgslStruct<{
+            cx: d.F32;
+            sx: d.F32;
+            cy: d.F32;
+            sy: d.F32;
+            cz: d.F32;
+            sz: d.F32;
+        }>, [d.Align<16>, d.Size<32>]>;
+        rBound: d.F32;
+        spanX: d.F32;
+        spanY: d.F32;
+        originX: d.F32;
+        originY: d.F32;
+        activeRes: d.U32;
+        pA: d.F32;
+        pB: d.F32;
+        pC: d.F32;
+        pD: d.F32;
+        mb0: d.Vec3f;
+        mb1: d.Vec3f;
+        mb2: d.Vec3f;
+        mb3: d.Vec3f;
+    }>;
+};
+export type VolumetricFieldLayout = ReturnType<typeof makeVolumetricFieldLayout>['layout'];
+/**
+ * The compute kernel that pre-marches the field into the storage texture. Dispatched 2D over the
+ * ACTIVE block (see D3 rules: TGSL `/` is always float, so a 1D→2D index reconstruction is unsafe
+ * — the guarded pipeline gives clean `(cx, cy)` u32 + an auto bounds guard, and we
+ * `dispatchThreads(activeRes, activeRes)` each frame). Each active texel maps to its field-UV over
+ * the aspect-fit domain (span/origin) at the active density, marches, and writes the top-left
+ * `activeRes × activeRes` block of the maxRes texture.
+ */
+export declare function buildVolumetricFieldKernel(layout: VolumetricFieldLayout, marchFn: ReturnType<typeof buildRaymarchedFieldFn>): import('typegpu').TgpuFn<(cx: d.U32, cy: d.U32) => d.Void>;
+/**
+ * Fragment-side sampler uniform: the aspect-fit domain + active resolution + bounding radius. (The
+ * composer binds this + the field texture into the sampler layout — see CONSUMER WIRES.)
+ */
+export declare const SampleParams: d.WgslStruct<{
+    originX: d.F32;
+    originY: d.F32;
+    spanX: d.F32;
+    spanY: d.F32;
+    activeResF: d.F32;
+    rBound: d.F32;
+}>;
+/**
+ * Build the field samplers over a kit-owned bind-group layout (kit/blur pattern):
+ *   - `field`  → the rgba32float texture bound SAMPLED (`d.texture2d(d.f32)`).
+ *   - `params` → the `SampleParams` uniform (domain + active res + bounding radius).
+ *
+ * Returns two resolvable `tgpu.fn([d.vec2f], d.vec4f)` samplers:
+ *   - `fieldSample`     — bicubic Catmull-Rom on .r/.a + inner-2×2 neighbourhood clamp + bilinear
+ *                         .g/.b + far-field circle blend. Keeps the near-binary silhouette/normal
+ *                         edges crisp under magnification.
+ *   - `fieldSampleFast` — 4-tap bilinear (same domain map + far-field extension). Used by
+ *                         finite-difference gradient taps, which don't benefit from the bicubic.
+ *
+ * rgba32float is not filterable, so texels are read with an integer `std.textureLoad(field, coords,
+ * 0)` (3-arg SAMPLED read — level 0), NOT `.sample()`; there is no `/maxRes` normalization.
+ *
+ * CONSUMER WIRES: register the compute `fieldTexture` (from `createVolumetricFieldCompute`) as a
+ * `params.registerComputeTexture(...)` KitTexture the fragment samples, bind it + a `SampleParams`
+ * uniform to the returned `sampleLayout`, and drive the domain values each frame. The `texelSpan`
+ * an effect uses for a fast-sampler early-out is `max(spanX, spanY) / activeRes` (CPU-computable
+ * from the same values).
+ */
+export declare function buildFieldSampleGraph(): {
+    sampleLayout: import('typegpu').TgpuBindGroupLayout<{
+        field: {
+            texture: d.WgslTexture2d<d.F32>;
+            sampleType: string;
+        };
+        params: {
+            uniform: d.WgslStruct<{
+                originX: d.F32;
+                originY: d.F32;
+                spanX: d.F32;
+                spanY: d.F32;
+                activeResF: d.F32;
+                rBound: d.F32;
+            }>;
+        };
+    }>;
+    fieldSample: import('typegpu').TgpuFn<(uv: d.Vec2f) => d.Vec4f>;
+    fieldSampleFast: import('typegpu').TgpuFn<(uv: d.Vec2f) => d.Vec4f>;
+    SampleParams: d.WgslStruct<{
+        originX: d.F32;
+        originY: d.F32;
+        spanX: d.F32;
+        spanY: d.F32;
+        activeResF: d.F32;
+        rBound: d.F32;
+    }>;
+};
+/** Device-side volumetric field pre-march: allocates the field texture + march uniform, builds the
+ *  guarded compute pipeline, and exposes a per-frame `writeParams` + variable-count `dispatch`. */
+export interface VolumetricFieldCompute {
+    /** The guarded pipeline (already bound); dispatch it with `dispatch(activeRes)`. */
+    computeStep: KitComputePipeline;
+    /** rgba32float, storage + sampled. The consumer registers this as a compute KitTexture the
+     *  fragment samples (CONSUMER WIRES). */
+    fieldTexture: TgpuTexture;
+    /** Fixed texture allocation (device-class dependent). */
+    maxRes: number;
+    /** Current active linear resolution (≤ maxRes). */
+    readonly activeRes: number;
+    /** Write the whole march uniform (the parent's per-frame CPU setup drives this). */
+    writeParams(value: InferInput<typeof MarchParams>): void;
+    /** Dispatch a 2D `activeRes × activeRes` guarded grid, filling the top-left block. */
+    dispatch(activeRes: number): void;
+}
+/**
+ * Allocate + wire the compute pre-march. `layout` + `kernel` come from `makeVolumetricFieldLayout`
+ * / `buildVolumetricFieldKernel` (the caller bakes the shape `sdfFn` against `layout.$.params`
+ * first). The guarded pipeline is built WITHOUT a pre-bound size so each frame can
+ * `dispatch(activeRes)` a clean 2D grid.
+ *
+ * NOTE: this is the device-touching allocator (like kit/blur's `createGaussianBlurCompute`); it is
+ * NOT exercised under vitest (no GPU) — only tsc-checked. The march/kernel/sampler CORRECTNESS is
+ * verified on real GPU by the shape-effect shaders. CONSUMER WIRES: register `fieldTexture` as a
+ * compute KitTexture + bind the fragment sampler layout (see `buildFieldSampleGraph`), and drive
+ * `writeParams` / `dispatch` from the per-frame CPU setup (the createAnalytic3dSdfSetup equivalent).
+ */
+/** A MarchParams uniform handle (from `root.createUniform(MarchParams)`) the caller can share with
+ *  the compute — so the setup's per-frame `update` writes the SAME buffer the kernel reads. */
+export interface MarchParamsUniform {
+    readonly buffer: unknown;
+    write(value: InferInput<typeof MarchParams>): void;
+}
+/** Extra wiring for `createVolumetricFieldCompute`:
+ *  - `paramsUniform`  → reuse a caller-owned MarchParams uniform (the shape setup writes it each
+ *                       frame) instead of creating a fresh one. The kernel's bind group binds it.
+ *  - `sdfSourceTexture` → the 2D SDF DATA texture the SVG-extrusion `sdfFn` samples inside the march
+ *                       (`layout` MUST be a `makeVolumetricSvgFieldLayout()` layout with the
+ *                       `sdfSource` entry). Bound into the SAME compute bind group. */
+export interface VolumetricFieldComputeExtra {
+    paramsUniform?: MarchParamsUniform;
+    sdfSourceTexture?: unknown;
+}
+export declare function createVolumetricFieldCompute(root: TgpuRoot, layout: VolumetricFieldLayout, kernel: ReturnType<typeof buildVolumetricFieldKernel>, onCleanup: (cb: () => void) => void, extra?: VolumetricFieldComputeExtra): VolumetricFieldCompute;
+/**
+ * SVG-extrusion variant of the march bind-group layout: same `field` + `params` as
+ * `makeVolumetricFieldLayout`, PLUS a SAMPLED `sdfSource` entry — the 2D SDF DATA texture the
+ * extrusion `sdfFn` reads (via `textureLoad`) inside the march. Kept as a SEPARATE function (rather
+ * than an optional flag on `makeVolumetricFieldLayout`) so the analytic path's layout TYPE stays
+ * free of the optional entry — the SVG `sdfFn` reads `layout.$.sdfSource` off THIS layout's precise
+ * type, and `createVolumetricFieldCompute`'s `sdfSourceTexture` extra binds it into the same group.
+ */
+export declare function makeVolumetricSvgFieldLayout(): {
+    layout: import('typegpu').TgpuBindGroupLayout<{
+        field: {
+            storageTexture: d.WgslStorageTexture2d<"rgba32float", string>;
+        };
+        params: {
+            uniform: d.WgslStruct<{
+                rot: d.Decorated<d.WgslStruct<{
+                    cx: d.F32;
+                    sx: d.F32;
+                    cy: d.F32;
+                    sy: d.F32;
+                    cz: d.F32;
+                    sz: d.F32;
+                }>, [d.Align<16>, d.Size<32>]>;
+                rBound: d.F32;
+                spanX: d.F32;
+                spanY: d.F32;
+                originX: d.F32;
+                originY: d.F32;
+                activeRes: d.U32;
+                pA: d.F32;
+                pB: d.F32;
+                pC: d.F32;
+                pD: d.F32;
+                mb0: d.Vec3f;
+                mb1: d.Vec3f;
+                mb2: d.Vec3f;
+                mb3: d.Vec3f;
+            }>;
+        };
+        sdfSource: {
+            texture: d.WgslTexture2d<d.F32>;
+        };
+    }>;
+    MarchParams: d.WgslStruct<{
+        rot: d.Decorated<d.WgslStruct<{
+            cx: d.F32;
+            sx: d.F32;
+            cy: d.F32;
+            sy: d.F32;
+            cz: d.F32;
+            sz: d.F32;
+        }>, [d.Align<16>, d.Size<32>]>;
+        rBound: d.F32;
+        spanX: d.F32;
+        spanY: d.F32;
+        originX: d.F32;
+        originY: d.F32;
+        activeRes: d.U32;
+        pA: d.F32;
+        pB: d.F32;
+        pC: d.F32;
+        pD: d.F32;
+        mb0: d.Vec3f;
+        mb1: d.Vec3f;
+        mb2: d.Vec3f;
+        mb3: d.Vec3f;
+    }>;
+};
+export type VolumetricSvgFieldLayout = ReturnType<typeof makeVolumetricSvgFieldLayout>['layout'];
+/**
+ * FN-ARG field samplers — the CONSUMER-WIREABLE form of `buildFieldSampleGraph`. Same
+ * bicubic/bilinear math, but the field texture + the six SampleParams (origin/span/activeRes/rBound)
+ * arrive as FN ARGUMENTS instead of a captured kit-owned bind-group layout. This is the fn-arg
+ * path: the consuming shape-effect FRAGMENT passes the compute field texture's `.accessor()` (a
+ * group-1 `registerComputeTexture` binding) + its own SampleParams accessors (declared as
+ * `extraFields`, see `VOLUMETRIC_FIELD_EXTRA_FIELDS`). The captured-layout `buildFieldSampleGraph`
+ * cannot be used directly by a fragment because the pass manager only binds the four composer-pinned
+ * groups (uniforms/textures/samplers/external) — it has no mechanism to bind a shader-owned 5th
+ * bind group — so a fragment that referenced `sampleLayout.$.field` would resolve but never get
+ * bound. The fn-arg form routes everything through the standard groups.
+ *
+ * rgba32float is not filterable → texels are read with integer `std.textureLoad(field, coords, 0)`.
+ */
+export declare function buildFieldSampleGraphArgs(): {
+    fieldSampleArg: import('typegpu').TgpuFn<(uv: d.Vec2f, field: d.WgslTexture2d<d.F32>, originX: d.F32, originY: d.F32, spanX: d.F32, spanY: d.F32, activeResF: d.F32, rBound: d.F32) => d.Vec4f>;
+    fieldSampleFastArg: import('typegpu').TgpuFn<(uv: d.Vec2f, field: d.WgslTexture2d<d.F32>, originX: d.F32, originY: d.F32, spanX: d.F32, spanY: d.F32, activeResF: d.F32, rBound: d.F32) => d.Vec4f>;
+    texelSpanFn: import('typegpu').TgpuFn<(spanX: d.F32, spanY: d.F32, activeResF: d.F32) => d.F32>;
+};
+/**
+ * The six SampleParams a shape-effect shader must declare as `extraFields` so the field SAMPLER
+ * (fn-arg form) can read the compute-written aspect-fit domain in its FRAGMENT. `initial` values are
+ * inert (span 1 / full-res); `createVolumetricFieldComputeNode` writes the live values each frame
+ * via `params.setExtraField`. CONSUMER WIRES: spread these into the shader definition's
+ * `extraFields`, then pass `params.uniforms.<name>` into `buildVolumetricFieldSampler`.
+ */
+export declare const VOLUMETRIC_FIELD_EXTRA_FIELDS: Record<string, {
+    schema: typeof d.f32;
+    initial: number;
+}>;
+/** The six SampleParams accessor Exprs the consumer's fragment reads from `params.uniforms._vf*`. */
+export interface VolumetricFieldSampleParams {
+    originX: Expr;
+    originY: Expr;
+    spanX: Expr;
+    spanY: Expr;
+    activeResF: Expr;
+    rBound: Expr;
+}
+/** The three field-sampler Exprs a shape-effect fragment consumes. */
+export interface VolumetricFieldSamplers {
+    /** Bicubic sampler — crisp silhouette/normal edges. `(uv) => vec4(field, gPattern, bPattern, depth)`. */
+    volumetricFieldSampler: (uv: Expr) => Expr;
+    /** 4-tap bilinear sampler (finite-difference gradient taps). */
+    volumetricFieldSamplerFast: (uv: Expr) => Expr;
+    /** `max(spanX, spanY) / activeRes` — the fast-sampler early-out threshold. */
+    volumetricFieldTexelSpan: Expr;
+}
+/**
+ * Build the field samplers for a shape-effect FRAGMENT. `field` is the compute-written field
+ * KitTexture (`params.computeOutputs.volumetricFieldTexture` — a `registerComputeTexture` binding);
+ * `p` are the SampleParams accessor Exprs (`params.uniforms._vf*`). Returns the three sampler Exprs
+ * the effect samples. See `createVolumetricFieldComputeNode` for the compute side that fills them.
+ */
+export declare function buildVolumetricFieldSampler(field: KitTexture, p: VolumetricFieldSampleParams): VolumetricFieldSamplers;
+/** A per-frame shape-effect volumetric setup: a baked `sdfFn` (reads its layout's MarchParams) plus
+ *  the CPU resolver that writes the March uniform each frame from the shape config (auto-animate /
+ *  mouse sub-props). The parent (`createVolumetricFieldComputeNode`) threads `layout` + `sdfFn`
+ *  into the march/kernel/compute and drives `update` / `setActiveRes` / `getStateKey`. */
+export interface VolumetricFieldSetup {
+    /** The march bind-group layout the `sdfFn` reads its params off (analytic or SVG variant). */
+    layout: VolumetricFieldLayout;
+    /** The MarchParams uniform `update` writes each frame (shared with the compute bind group). */
+    marchParamsBuffer: MarchParamsUniform;
+    /** The shape SDF baked against `layout.$.params` — fed to `buildRaymarchedFieldFn`. */
+    sdfFn: BakedSdf;
+    /** SVG-3D only: the 2D SDF DATA texture bound into the compute kernel (`sdfSource`). */
+    sdfSourceTexture?: unknown;
+    /** Resolve the shape config + write the March uniform (advances the auto-animate clock). */
+    update: (frameParams?: ShapeFrameParams) => void;
+    /** Set the active linear resolution + re-write the uniform (no time advance). */
+    setActiveRes: (res: number) => void;
+    /** Dirty-key: the field re-marches only when this changes. */
+    getStateKey: () => string;
+    /** The aspect-fit domain footprint the parent feeds `resolveActiveFieldRes` / SampleParams. */
+    getFootprint: () => {
+        spanX: number;
+        spanY: number;
+        originX: number;
+        originY: number;
+        rBound: number;
+    };
+}
+/** The per-frame params a setup's `update` reads (deltaTime → auto clock, pointer → mouse drivers). */
+export interface ShapeFrameParams {
+    deltaTime?: number;
+    pointer?: {
+        x: number;
+        y: number;
+    };
+}
+/**
+ * Compile-time-selected analytic 3D SDF setup. Allocates the march layout + a MarchParams uniform,
+ * bakes `sdfFn` for `shapeType` (one primitive, compile-time
+ * branch, reading its size params off `layout.$.params`), and returns a per-frame `update` that
+ * resolves the shape JSON (incl. auto-animate / mouse sub-props) and writes the uniform.
+ */
+export declare function createAnalytic3dSdfSetup(root: TgpuRoot, shapeType: string, initialConfig: Record<string, unknown>, getShapeConfig: () => unknown): VolumetricFieldSetup;
+/**
+ * SVG-extrusion 3D SDF setup. Lifts the uploaded 2D SDF field into a solid by extrusion (slab +
+ * rounded bevel) and raymarches it. The `sdfFn` SAMPLES the 2D SDF DATA texture (bound as the
+ * layout's `sdfSource`) via a bilinear `textureLoad` INSIDE the march (rgba/r16 float texel reads,
+ * explicit level 0).
+ *
+ * The bounding radius uses the full-field fallback (`hwf = hhf = 0.5`) rather than a content-tight
+ * scan (`getSdfContentBounds`, which lives in `utilities/sdfBounds.ts`). Only march EFFICIENCY
+ * differs, never correctness.
+ */
+export declare function createSvg3dSdfSetup(params: GpuFragmentParams, shapeSdfUrl: string, getShapeConfig: () => unknown): VolumetricFieldSetup;
+/**
+ * The shared shape-effect compute entry. When the active shape is volumetric (analytic 3D or SVG
+ * extrude), pre-marches its field into a compute texture and
+ * exposes the samplers. Returns null for flat shapes and when no device is present (GPU-free resolve
+ * / WebGL) — the consumer then falls back to the inline analytic sampler.
+ *
+ * CONSUMER WIRES (the shape-effect shader that owns this — a later wave):
+ *   1. Declare `...VOLUMETRIC_FIELD_EXTRA_FIELDS` in the shader definition's `extraFields` (the six
+ *      SampleParams uniforms this node writes each frame via `setExtraField`).
+ *   2. `compute: (params) => { const vf = createVolumetricFieldComputeNode(params, () =>
+ *      params.getCpuValue('shape')); return vf && {outputs: vf.outputs, getComputeNodes:
+ *      vf.getComputeNodes} }`.
+ *   3. `fragment: (params) => { const fieldTex = params.computeOutputs?.volumetricFieldTexture; if
+ *      (!fieldTex) { …inline analytic fallback… } const s = buildVolumetricFieldSampler(fieldTex,
+ *      {originX: params.uniforms._vfOriginX, …}); …applyGlassEffect(s.volumetricFieldSampler, …)… }`.
+ *
+ * The one binding this can't close without a consuming fragment is the sampler↔fragment handoff
+ * (step 3): the samplers are built in the FRAGMENT (a separate builder invocation from `compute`),
+ * from the registered field texture (`outputs.volumetricFieldTexture`) + the fragment's own
+ * `extraFields` accessors. Everything on the compute side (setup, march, kernel, dispatch, dirty-key,
+ * SampleParams writes) is closed here.
+ */
+export declare function createVolumetricFieldComputeNode(params: GpuFragmentParams, getShapeConfig: () => unknown, patternMode?: SurfacePatternMode): {
+    outputs: {
+        volumetricFieldTexture: KitTexture;
+    };
+    getComputeNodes: (frameParams?: ShapeFrameParams) => GpuComputeStep[] | null;
+    /** The raw field TgpuTexture (rgba32float, storage+sampled) — for a consumer whose OWN compute
+     *  kernels sample the field (SmokeFill's mask kernel). Bind it as a SAMPLED entry declared
+     *  `sampleType: 'unfilterable-float'` (rgba32float is not filterable). */
+    fieldTexture: TgpuTexture;
+    /** The aspect-fit domain + active res describing the field texture's CURRENT contents — the
+     *  same values last published to the `_vf*` extraFields (initials before the first march).
+     *  Read AFTER `getComputeNodes` each frame for a compute-side consumer's uniform. */
+    getFieldDomain: () => {
+        originX: number;
+        originY: number;
+        spanX: number;
+        spanY: number;
+        activeRes: number;
+        rBound: number;
+    };
+} | null;
+//# sourceMappingURL=sdf3d.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sdf3d.d.ts","sourceRoot":"","sources":["../../../src/gpu/kit/sdf3d.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,OAAO,EAAO,CAAC,EAAM,MAAM,SAAS,CAAA;AACpC,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,cAAc,CAAA;AAC5C,OAAO,KAAK,EAAC,QAAQ,EAAE,WAAW,EAAC,MAAM,SAAS,CAAA;AAClD,OAAO,EAAuB,KAAK,kBAAkB,EAAC,MAAM,YAAY,CAAA;AACxE,OAAO,EAAC,mBAAmB,EAAC,MAAM,wBAAwB,CAAA;AAE1D,OAAO,KAAK,EAAC,IAAI,EAAE,iBAAiB,EAAE,UAAU,EAAE,cAAc,EAAC,MAAM,aAAa,CAAA;AAKpF,OAAO,EAAC,mBAAmB,EAAC,CAAA;AAS5B,eAAO,MAAM,aAAa,yQAKhB,CAAA;AACV,MAAM,MAAM,WAAW,GAAG,OAAO,aAAa,CAAC,MAAM,CAAC,CAAA;AAEtD,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,IAAI,WAAW,CAEzE;AAID,eAAO,MAAM,WAAW,2BAA4B,CAAA;AACpD,MAAM,MAAM,SAAS,GAAG,OAAO,WAAW,CAAC,MAAM,CAAC,CAAA;AAElD,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,IAAI,SAAS,CAE1E;AAED,iGAAiG;AACjG,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAEhE;AAED,sGAAsG;AACtG,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAEjD,CAAA;AA4CD;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IAC9B,6EAA6E;IAC7E,OAAO,EAAE,MAAM,CAAA;IACf,0EAA0E;IAC1E,SAAS,EAAE,MAAM,CAAA;IACjB,4CAA4C;IAC5C,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;IAChB,2EAA2E;IAC3E,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAC9D;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,iBAAiB,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CA0B/G;AAED,iGAAiG;AACjG,wBAAgB,eAAe,CAAC,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAQpE;AAKD,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAqBxE,CAAA;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,CA+BtE;AAED;uEACuE;AACvE,eAAO,MAAM,WAAW,IAAI,CAAA;AAE5B;2BAC2B;AAC3B,MAAM,WAAW,WAAW;IAAG,EAAE,EAAE,GAAG,CAAC;IAAC,EAAE,EAAE,GAAG,CAAC;IAAC,EAAE,EAAE,GAAG,CAAC;IAAC,EAAE,EAAE,GAAG,CAAC;IAAC,EAAE,EAAE,GAAG,CAAC;IAAC,EAAE,EAAE,GAAG,CAAA;CAAE;AAErF;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,kBAAkB,GAAG,MAAM,GAAG,KAAK,GAAG,WAAW,CAAA;AAE7D;;uCAEuC;AACvC,wBAAgB,YAAY,CACxB,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAClC,CAAC,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAC9E;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAQrC;AAOD,yBAAyB;AACzB,eAAO,MAAM,QAAQ,2DAGnB,CAAA;AAEF,6DAA6D;AAC7D,eAAO,MAAM,UAAU,mGAQrB,CAAA;AAEF,yEAAyE;AACzE,eAAO,MAAM,OAAO,6EAIlB,CAAA;AAEF;sBACsB;AACtB,eAAO,MAAM,YAAY,2DAGvB,CAAA;AAEF,sEAAsE;AACtE,eAAO,MAAM,eAAe,sFAO1B,CAAA;AAEF,sDAAsD;AACtD,eAAO,MAAM,SAAS,qEAIpB,CAAA;AAIF,eAAO,MAAM,YAAY,iFAoBvB,CAAA;AAKF,eAAO,MAAM,SAAS,sEAQpB,CAAA;AAGF,eAAO,MAAM,UAAU,sEAmBrB,CAAA;AAGF,eAAO,MAAM,WAAW,kFAKtB,CAAA;AAIF,eAAO,MAAM,QAAQ,qEAenB,CAAA;AAGF,eAAO,MAAM,MAAM,kFAKjB,CAAA;AAGF,eAAO,MAAM,IAAI,mEAIf,CAAA;AAKF,eAAO,MAAM,KAAK,mFAgBhB,CAAA;AAUF,eAAO,MAAM,OAAO,oGAWlB,CAAA;AAKF,eAAO,MAAM,WAAW,yHAOtB,CAAA;AAIF,eAAO,MAAM,cAAc,2DAOzB,CAAA;AAIF,eAAO,MAAM,WAAW,qEActB,CAAA;AASF,eAAO,MAAM,QAAQ,2KAoBnB,CAAA;AAKF,eAAO,MAAM,YAAY,wHAQvB,CAAA;AAKF,eAAO,MAAM,UAAU,sHASrB,CAAA;AAQF,eAAO,MAAM,WAAW,uLAoBtB,CAAA;AAgBF,gGAAgG;AAChG,eAAO,MAAM,SAAS;;;;;;;EAIpB,CAAA;AAEF,wFAAwF;AACxF,eAAO,MAAM,UAAU;;;;;;;eAYrB,CAAA;AAEF,6EAA6E;AAC7E,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,EAAE,GAAG,KAAK,GAAG,CAAA;AAEtC;;;;;;;;;;;;;GAaG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,QAAQ,EAAE,WAAW,GAAE,kBAA2B;;;;;;;+BAuI/F;AAED;oEACoE;AACpE,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,QAAQ,EAAE,WAAW,GAAE,kBAA2B;;;;;;;+BAE7F;AAID;;4CAE4C;AAC5C,eAAO,MAAM,uBAAuB,EAAG,aAAsB,CAAA;AAE7D;;;;2FAI2F;AAC3F,eAAO,MAAM,oBAAoB,OAAO,CAAA;AAExC;;;;0FAI0F;AAC1F,eAAO,MAAM,2BAA2B,MAAM,CAAA;AAE9C;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,IAAI,MAAM,CAElD;AAQD;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CACjC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,oBAAoB,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAC7G,MAAM,CAgBR;AAED;;;;;;GAMG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;EAatB,CAAA;AAEF;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMxC;AAED,MAAM,MAAM,qBAAqB,GAAG,UAAU,CAAC,OAAO,yBAAyB,CAAC,CAAC,QAAQ,CAAC,CAAA;AAE1F;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,qBAAqB,EAAE,OAAO,EAAE,UAAU,CAAC,OAAO,sBAAsB,CAAC,8DAa3H;AAED;;;GAGG;AACH,eAAO,MAAM,YAAY;;;;;;;EAKvB,CAAA;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2HpC;AAED;mGACmG;AACnG,MAAM,WAAW,sBAAsB;IACnC,oFAAoF;IACpF,WAAW,EAAE,kBAAkB,CAAA;IAC/B;6CACyC;IACzC,YAAY,EAAE,WAAW,CAAA;IACzB,yDAAyD;IACzD,MAAM,EAAE,MAAM,CAAA;IACd,mDAAmD;IACnD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,oFAAoF;IACpF,WAAW,CAAC,KAAK,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,GAAG,IAAI,CAAA;IACxD,sFAAsF;IACtF,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;CACpC;AAED;;;;;;;;;;;GAWG;AACH;+FAC+F;AAC/F,MAAM,WAAW,kBAAkB;IAC/B,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;IACxB,KAAK,CAAC,KAAK,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,GAAG,IAAI,CAAA;CACrD;AAED;;;;;uFAKuF;AACvF,MAAM,WAAW,2BAA2B;IACxC,aAAa,CAAC,EAAE,kBAAkB,CAAA;IAClC,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAC7B;AAED,wBAAgB,4BAA4B,CACxC,IAAI,EAAE,QAAQ,EACd,MAAM,EAAE,qBAAqB,EAC7B,MAAM,EAAE,UAAU,CAAC,OAAO,0BAA0B,CAAC,EACrD,SAAS,EAAE,CAAC,EAAE,EAAE,MAAM,IAAI,KAAK,IAAI,EACnC,KAAK,GAAE,2BAAgC,GACxC,sBAAsB,CA+BxB;AAUD;;;;;;;GAOG;AACH,wBAAgB,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAO3C;AAED,MAAM,MAAM,wBAAwB,GAAG,UAAU,CAAC,OAAO,4BAA4B,CAAC,CAAC,QAAQ,CAAC,CAAA;AAEhG;;;;;;;;;;;;;GAaG;AACH,wBAAgB,yBAAyB;;;;EAwHxC;AAED;;;;;;GAMG;AACH,eAAO,MAAM,6BAA6B,EAAE,MAAM,CAAC,MAAM,EAAE;IAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,CAOjG,CAAA;AAED,qGAAqG;AACrG,MAAM,WAAW,2BAA2B;IACxC,OAAO,EAAE,IAAI,CAAA;IACb,OAAO,EAAE,IAAI,CAAA;IACb,KAAK,EAAE,IAAI,CAAA;IACX,KAAK,EAAE,IAAI,CAAA;IACX,UAAU,EAAE,IAAI,CAAA;IAChB,MAAM,EAAE,IAAI,CAAA;CACf;AAED,sEAAsE;AACtE,MAAM,WAAW,uBAAuB;IACpC,yGAAyG;IACzG,sBAAsB,EAAE,CAAC,EAAE,EAAE,IAAI,KAAK,IAAI,CAAA;IAC1C,gEAAgE;IAChE,0BAA0B,EAAE,CAAC,EAAE,EAAE,IAAI,KAAK,IAAI,CAAA;IAC9C,8EAA8E;IAC9E,wBAAwB,EAAE,IAAI,CAAA;CACjC;AAED;;;;;GAKG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,UAAU,EAAE,CAAC,EAAE,2BAA2B,GAAG,uBAAuB,CAStH;AAID;;;0FAG0F;AAC1F,MAAM,WAAW,oBAAoB;IACjC,8FAA8F;IAC9F,MAAM,EAAE,qBAAqB,CAAA;IAC7B,+FAA+F;IAC/F,iBAAiB,EAAE,kBAAkB,CAAA;IACrC,uFAAuF;IACvF,KAAK,EAAE,QAAQ,CAAA;IACf,wFAAwF;IACxF,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B,4FAA4F;IAC5F,MAAM,EAAE,CAAC,WAAW,CAAC,EAAE,gBAAgB,KAAK,IAAI,CAAA;IAChD,iFAAiF;IACjF,YAAY,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAA;IACnC,8DAA8D;IAC9D,WAAW,EAAE,MAAM,MAAM,CAAA;IACzB,+FAA+F;IAC/F,YAAY,EAAE,MAAM;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,CAAA;CACvG;AAED,uGAAuG;AACvG,MAAM,WAAW,gBAAgB;IAC7B,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,OAAO,CAAC,EAAE;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAC,CAAA;CACnC;AAgBD;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACpC,IAAI,EAAE,QAAQ,EACd,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACtC,cAAc,EAAE,MAAM,OAAO,GAC9B,oBAAoB,CA+MtB;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAC/B,MAAM,EAAE,iBAAiB,EACzB,WAAW,EAAE,MAAM,EACnB,cAAc,EAAE,MAAM,OAAO,GAC9B,oBAAoB,CAkItB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,gCAAgC,CAC5C,MAAM,EAAE,iBAAiB,EACzB,cAAc,EAAE,MAAM,OAAO,EAC7B,WAAW,GAAE,kBAA2B,GACzC;IACC,OAAO,EAAE;QAAC,sBAAsB,EAAE,UAAU,CAAA;KAAC,CAAA;IAC7C,eAAe,EAAE,CAAC,WAAW,CAAC,EAAE,gBAAgB,KAAK,cAAc,EAAE,GAAG,IAAI,CAAA;IAC5E;;8EAE0E;IAC1E,YAAY,EAAE,WAAW,CAAA;IACzB;;yFAEqF;IACrF,cAAc,EAAE,MAAM;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,CAAA;CAC5H,GAAG,IAAI,CAqEP"}