shaders 3.1.463 → 3.2.465

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

@@ -0,0 +1,79 @@
+import { d } from './index';
+
+/**
+ * The standard shape-effect silhouette alpha: the D-7 inside mask (edge width `edgeSoftness·0.5`
+ * floored at 0.001, clamped to ≥ 1.5 device pixels) eased with smoothstep. This exact tail —
+ * `smoothstep(0, 1, insideMask(sdf, max(edgeSoftness·0.5, 0.001), pxH, 1.5))` — closes Chrome,
+ * LiquidMetal, Plastic, Water, Frost, Holographic, CarbonFiber and BrushedMetal. Pure.
+ */
+export declare const silhouetteAlpha: import('typegpu').TgpuFn<(sdf: d.F32, edgeSoftness: d.F32, pxH: d.F32) => d.F32>;
+/** A key-light frame: the light direction and its Blinn half-vector against the renderer's fixed
+ *  view direction (0,0,−1). */
+export declare const KeyLight: d.WgslStruct<{
+    L: d.Vec3f;
+    H: d.Vec3f;
+}>;
+/**
+ * Build the key-light frame from the light's direction components: `L = normalize(lx, ly, lz)`,
+ * `H = normalize(L + (0,0,−1))`. Every material picks its own `lz` (the fleet uses −0.6 … −0.9 —
+ * an eye-tuned elevation, not a shared constant) and its own lobe exponents at the call site.
+ * Pure.
+ */
+export declare const keyLight: import('typegpu').TgpuFn<(lx: d.F32, ly: d.F32, lz: d.F32) => d.WgslStruct<{
+    L: d.Vec3f;
+    H: d.Vec3f;
+}>>;
+/** Grazing-view factor for the fixed −z view: `1 − clamp(−n.z, 0, 1)` — the input every fresnel
+ *  pow() rides (Plastic, Crystal, Frost, Water, Goo). Pure. */
+export declare const grazingView: import('typegpu').TgpuFn<(n: d.Vec3f) => d.F32>;
+/**
+ * A sharpness-steered Blinn glint: `pow(ndh, mix(cfg.x, cfg.y, sharp)) · mix(cfg.z, cfg.w, sharp)`
+ * — exponent and gain both slide with the material's `sharpness`. LiquidMetal passes
+ * `(60, 900, 0.4, 1.4)`, Water `(40, 600, 0.3, 1.3)`; the shape is shared, the endpoints are each
+ * material's look. Pure.
+ */
+export declare const sharpGlint: import('typegpu').TgpuFn<(ndh: d.F32, sharp: d.F32, cfg: d.Vec4f) => d.F32>;
+/**
+ * Clamped analytic Perlin gradient — the shared tail of the metal reliefs: `perlin12d(q).yz`
+ * scaled by `gain` and clamped to ±4 (the slope bound that keeps chord-discontinuity spikes from
+ * reading as bright seams). Chrome's pressed-metal waviness passes gain 1, LiquidMetal's molten
+ * relief 0.62; the domain (`q`) each material warps its own way before the call. Pure.
+ */
+export declare const clampedPerlinGrad: import('typegpu').TgpuFn<(q: d.Vec2f, gain: d.F32) => d.Vec2f>;
+/**
+ * Tilt a geometric normal in-plane and renormalize: `normalize(n.x + dx, n.y + dy, n.z)` — how a
+ * relief field (waviness, molten folds, crumple, frost, weave crowns) bends the base normal.
+ * Callers fold their relief products into ONE dx/dy term each; a material whose tilt is a
+ * multi-term sum (Water, BrushedMetal) keeps its inline form — re-associating the sum through
+ * this single add would change float rounding. Pure.
+ */
+export declare const nudgeNormal: import('typegpu').TgpuFn<(n: d.Vec3f, dx: d.F32, dy: d.F32) => d.Vec3f>;
+/**
+ * The shared optical-thickness reading of the shape field: volumetric shapes use the chord
+ * (`clamp(−sdf·2, 0, 1.2)`), flat shapes a rim-depth proxy (`clamp(−sdf, 0, 0.5)·2`). The
+ * Frost/Water "solid body" cue; each material scales the result by its own density prop. Pure.
+ */
+export declare const opticalThickness: import('typegpu').TgpuFn<(sdf: d.F32, volumetric: d.F32) => d.F32>;
+/** Beer–Lambert transmission per channel: `exp(−thickness · absorb)`. Frost drives it with a
+ *  fixed ice absorption spectrum, Water derives absorption from the water colour. Pure. */
+export declare const beerLambert: import('typegpu').TgpuFn<(thickness: d.F32, absorb: d.Vec3f) => d.Vec3f>;
+/**
+ * The incommensurate-frequency domain-warp offset shared verbatim by LiquidMetal's molten folds
+ * and Water's wind-driven waves: two sin·cos products over `warpInput` (the pattern coords scaled
+ * by 0.6) drifting with `flowT`. The constants ARE the flow character — both materials read the
+ * same table. Pure.
+ */
+export declare const flowWarpOffset: import('typegpu').TgpuFn<(warpInput: d.Vec2f, flowT: d.F32) => d.Vec2f>;
+/**
+ * The shared 5-softbox studio: a floor→sky gradient plus five radial softbox banks — overhead key,
+ * upper-left, right, low fill / floor bounce, lower-left — rotated into the env frame. One sample
+ * for a reflection direction (rx, ry).
+ *
+ * BrushedMetal smears it along the brush grain (skyGain 0.38, animated `drift`); CarbonFiber's
+ * clearcoat takes one crisp tap (skyGain 0.3, keyRad 0.16, drift 0). The five bank positions,
+ * radius multipliers and brightnesses are byte-identical between the two — only the sky gain
+ * differs, so it is the one argument. (LiquidMetal's 3-bank studio and Chrome's rounded-rect
+ * softbox + flags are different arithmetic and stay in their files.) Pure.
+ */
+export declare const studio5Softbox: import('typegpu').TgpuFn<(rx: d.F32, ry: d.F32, envC: d.F32, envS: d.F32, keyRad: d.F32, drift: d.F32, envStr: d.F32, skyGain: d.F32) => d.F32>;
+//# sourceMappingURL=materialParts.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"materialParts.d.ts","sourceRoot":"","sources":["../../../src/gpu/kit/materialParts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,EAAO,CAAC,EAAM,MAAM,SAAS,CAAA;AAMpC;;;;;GAKG;AACH,eAAO,MAAM,eAAe,kFAI1B,CAAA;AAIF;+BAC+B;AAC/B,eAAO,MAAM,QAAQ;;;EAAqC,CAAA;AAE1D;;;;;GAKG;AACH,eAAO,MAAM,QAAQ;;;GAKnB,CAAA;AAEF;+DAC+D;AAC/D,eAAO,MAAM,WAAW,iDAGtB,CAAA;AAIF;;;;;GAKG;AACH,eAAO,MAAM,UAAU,6EAGrB,CAAA;AAIF;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,gEAQ5B,CAAA;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,yEAGtB,CAAA;AAIF;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,oEAK3B,CAAA;AAEF;2FAC2F;AAC3F,eAAO,MAAM,WAAW,0EAOtB,CAAA;AAIF;;;;;GAKG;AACH,eAAO,MAAM,cAAc,yEAKzB,CAAA;AAIF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,cAAc,iJAwBrB,CAAA"}

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

@@ -13,6 +13,13 @@ export declare const scaleScaleDown: import('typegpu').TgpuFn<(dims: d.Vec2f, vp
 export declare const scaleNone: import('typegpu').TgpuFn<(dims: d.Vec2f, vp: d.Vec2f) => d.Vec2f>;
 /** Centre the UV, divide by the fit scale, re-centre. No Y-flip (see the module note). */
 export declare const sampleUV: import('typegpu').TgpuFn<(uv: d.Vec2f, uvScale: d.Vec2f) => d.Vec2f>;
+/**
+ * Selfie-mode horizontal flip: mirror the sampling U when `mirror > 0`. Runtime (not compile-time) —
+ * `mirror` is an ordinary boolean uniform, so toggling it must not recompose. `1 - u` stays within
+ * [0,1] so the letterbox alpha-cut on the mirrored UV is unchanged (WebcamTexture's
+ * `uvPostProcess`, the one consumer of that hook).
+ */
+export declare const applyMirror: import('typegpu').TgpuFn<(uv: d.Vec2f, mirror: d.F32) => d.Vec2f>;
 /** Decode the sampled sRGB colour to linear, and cut alpha to 0 outside [0,1]² (letterbox). */
 export declare const alphaCutLinear: import('typegpu').TgpuFn<(color: d.Vec4f, uv: d.Vec2f) => d.Vec4f>;
 /**

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

@@ -1 +1 @@
-{"version":3,"file":"media.d.ts","sourceRoot":"","sources":["../../../src/gpu/kit/media.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,EAAO,CAAC,EAAM,MAAM,SAAS,CAAA;AAMpC,OAAO,KAAK,EAAC,IAAI,EAAE,UAAU,EAAC,MAAM,aAAa,CAAA;AAEjD,6EAA6E;AAC7E,eAAO,MAAM,UAAU,mEAMrB,CAAA;AAEF,mFAAmF;AACnF,eAAO,MAAM,YAAY,mEAMvB,CAAA;AAEF,2DAA2D;AAC3D,eAAO,MAAM,SAAS,yCAGpB,CAAA;AAEF,oFAAoF;AACpF,eAAO,MAAM,cAAc,mEAQzB,CAAA;AAEF,oGAAoG;AACpG,eAAO,MAAM,SAAS,mEAMpB,CAAA;AAEF,0FAA0F;AAC1F,eAAO,MAAM,QAAQ,sEAKnB,CAAA;AAEF,+FAA+F;AAC/F,eAAO,MAAM,cAAc,oEAMzB,CAAA;AAUF;;;GAGG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAA6D,CAAA;AAEjH,gGAAgG;AAChG,eAAO,MAAM,2BAA2B,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAA6D,CAAA;AAE5H,MAAM,WAAW,mBAAmB;IAChC,8CAA8C;IAC9C,OAAO,EAAE,UAAU,CAAA;IACnB,0DAA0D;IAC1D,EAAE,EAAE,IAAI,CAAA;IACR,wEAAwE;IACxE,QAAQ,EAAE,IAAI,CAAA;IACd;;;;OAIG;IACH,GAAG,EAAE,OAAO,CAAA;IACZ,gGAAgG;IAChG,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB;;;OAGG;IACH,aAAa,CAAC,EAAE,CAAC,EAAE,EAAE,IAAI,KAAK,IAAI,CAAA;IAClC;;;;OAIG;IACH,MAAM,EAAE,uBAAuB,CAAA;CAClC;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,mBAAmB,GAAG,IAAI,CAiB5D"}
+{"version":3,"file":"media.d.ts","sourceRoot":"","sources":["../../../src/gpu/kit/media.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,EAAO,CAAC,EAAM,MAAM,SAAS,CAAA;AAMpC,OAAO,KAAK,EAAC,IAAI,EAAE,UAAU,EAAC,MAAM,aAAa,CAAA;AAEjD,6EAA6E;AAC7E,eAAO,MAAM,UAAU,mEAMrB,CAAA;AAEF,mFAAmF;AACnF,eAAO,MAAM,YAAY,mEAMvB,CAAA;AAEF,2DAA2D;AAC3D,eAAO,MAAM,SAAS,yCAGpB,CAAA;AAEF,oFAAoF;AACpF,eAAO,MAAM,cAAc,mEAQzB,CAAA;AAEF,oGAAoG;AACpG,eAAO,MAAM,SAAS,mEAMpB,CAAA;AAEF,0FAA0F;AAC1F,eAAO,MAAM,QAAQ,sEAKnB,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,WAAW,mEAItB,CAAA;AAEF,+FAA+F;AAC/F,eAAO,MAAM,cAAc,oEAMzB,CAAA;AAUF;;;GAGG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAA6D,CAAA;AAEjH,gGAAgG;AAChG,eAAO,MAAM,2BAA2B,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAA6D,CAAA;AAE5H,MAAM,WAAW,mBAAmB;IAChC,8CAA8C;IAC9C,OAAO,EAAE,UAAU,CAAA;IACnB,0DAA0D;IAC1D,EAAE,EAAE,IAAI,CAAA;IACR,wEAAwE;IACxE,QAAQ,EAAE,IAAI,CAAA;IACd;;;;OAIG;IACH,GAAG,EAAE,OAAO,CAAA;IACZ,gGAAgG;IAChG,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB;;;OAGG;IACH,aAAa,CAAC,EAAE,CAAC,EAAE,EAAE,IAAI,KAAK,IAAI,CAAA;IAClC;;;;OAIG;IACH,MAAM,EAAE,uBAAuB,CAAA;CAClC;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,mBAAmB,GAAG,IAAI,CAiB5D"}

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

@@ -0,0 +1,296 @@
+import { Expr, GpuFragmentParams, KitTexture } from '../contract';
+import { d } from './index';
+
+/** Tap count of the motion-blur gather (one `textureSample` each — see `blur.unrolledTapGather`). */
+export declare const MOTION_BLUR_TAP_COUNT = 32;
+/** Normalized Gaussian tap weights, computed at JS time — no `exp()` per tap per pixel. */
+export declare const MOTION_BLUR_WEIGHTS: number[];
+/**
+ * Sample coordinate for one linear-blur tap. `tapT ∈ [-0.5, 0.5]` is the centered tap position
+ * ((i/31)-0.5). The blur vector is the (aspect-corrected) direction × intensity, normalised to the
+ * viewport and doubled. `angleDeg` is degrees (transformAngle is identity-degrees), so
+ * the body converts. All scalar infix (avoids vector `.div`).
+ */
+export declare const linearBlurTapCoord: import('typegpu').TgpuFn<(uv: d.Vec2f, angleDeg: d.F32, intensity: d.F32, viewport: d.Vec2f, tapT: d.F32) => d.Vec2f>;
+/**
+ * Sample coordinate for one orbit-blur tap: rotate the (aspect-corrected) offset from `center` by
+ * `(tapIndex − 15.5) × angleStep`, where `angleStep = intensity·0.005 / 31`. Centering the 32-tap
+ * sweep on the source pixel (taps at ±0.5·step, ±1.5·step, …) keeps the blurred image aligned with
+ * the sharp one — a one-sided sweep visibly counter-rotated content by half the blur angle
+ * (pre-2026-08 behavior; deliberately corrected). `center` is the ALREADY-transformed
+ * prop value (transformPosition stores `(x, 1 - y)`), so `1.0 - center.y` recovers the authored y.
+ *
+ * Each tap's rotation is computed DIRECTLY (`cos/sin((tapIndex − 15.5)·angleStep)`) rather than via
+ * a stateful recurrence — no accumulated f32 drift and no loop-carried state.
+ */
+export declare const angularBlurTapCoord: import('typegpu').TgpuFn<(center: d.Vec2f, intensity: d.F32, uv: d.Vec2f, aspect: d.F32, tapIndex: d.F32) => d.Vec2f>;
+/**
+ * Sample coordinate for one zoom-blur tap: scale the offset from `center` by
+ * `scale = 1 + radius·(tapIndex/31)` (radius = intensity·0.01), pulling near-center samples out and
+ * far samples in for the radial streak. `center` is the ALREADY-transformed prop value
+ * (transformPosition stores `(x, 1 - y)`), so `1.0 - center.y` recovers the authored y.
+ *
+ * The x offset is aspect-corrected (×aspect) then un-corrected (÷aspect) at the end; the two cancel
+ * algebraically but are kept in that exact op order so the f32 rounding matches. Pure.
+ */
+export declare const zoomBlurTapCoord: import('typegpu').TgpuFn<(center: d.Vec2f, intensity: d.F32, uv: d.Vec2f, aspect: d.F32, tapIndex: d.F32) => d.Vec2f>;
+/** The three tap trajectories a motion blur can follow. */
+export type MotionBlurPathKind = 'linear' | 'orbit' | 'zoom';
+export interface MotionBlurGatherArgs {
+    /** The path anchor: `linear` → the angle in degrees; `orbit`/`zoom` → the transformed center. */
+    focus: Expr;
+    /** Blur intensity (the shaders' 0–100 range). */
+    amount: Expr;
+    uv: Expr;
+    aspect: Expr;
+    viewportSize: Expr;
+}
+/**
+ * The 32-tap Gaussian motion-blur gather: `Σ sample(tapCoord(i)) · weight(i)`, left-folded in tap
+ * order (float addition is not associative — the fold order is part of the result). One
+ * `texture.sample()` per tap with no control flow, the only legal shape for textureSample in a
+ * fragment; the linearClamp sampler clamps out-of-range taps.
+ */
+export declare function motionBlurGather(kind: MotionBlurPathKind, args: MotionBlurGatherArgs, sample: (coord: Expr) => Expr): Expr;
+/**
+ * One decorrelated hash per pixel → a random offset in the [-1,1]² unit square, scaled to pixels by
+ * `intensity` and normalised by the viewport (so the grain size is DPR-stable). Returns the
+ * displaced sample coordinate. `viewport` is `_sys.viewportSize` (device pixels). The seed is
+ * ~thousands, where the old sin-fract hash streaks on iOS Metal (low-precision large-argument sin)
+ * — hence the integer bitcast hash. Vector ops fluent, scalar infix.
+ */
+export declare const diffuseBlurUV: import('typegpu').TgpuFn<(uv: d.Vec2f, intensity: d.F32, viewport: d.Vec2f) => d.Vec2f>;
+export interface ScatterGatherArgs {
+    uv: Expr;
+    /** Displacement radius in pixels. */
+    amount: Expr;
+    viewportSize: Expr;
+    /** Compile-time edge mode (transformEdges value); `stretch` relies on the clamping sampler. */
+    edgeMode: number;
+    sample: (coord: Expr) => Expr;
+}
+/** The scatter gather: sample the child once at the hash-displaced coordinate, with edge handling. */
+export declare function scatterGather(args: ScatterGatherArgs): Expr;
+export declare const DROP_SHADOW_TAP_WEIGHTS: number[];
+/** The shadow's screen UV: offset the sample by the compass-angle direction × distance (X divided by
+ *  aspect so the offset covers equal pixel distance in both axes). Pure. */
+export declare const dropShadowUV: import('typegpu').TgpuFn<(uv: d.Vec2f, viewport: d.Vec2f, angle: d.F32, distance: d.F32) => d.Vec2f>;
+/** `uv + (ox, oy) · blurRadius / viewport` — one separable-blur tap offset in UV space. Pure. */
+export declare const dropShadowTapUV: import('typegpu').TgpuFn<(uv: d.Vec2f, viewport: d.Vec2f, blurRadius: d.F32, ox: d.F32, oy: d.F32) => d.Vec2f>;
+/**
+ * The final drop-shadow composite in PREMULTIPLIED space (the child RTT is premultiplied) — the
+ * gather's caller unpremultiplies the return. `cutout` is a runtime 0/1 flag selected via
+ * `std.select`. Normal: original content OVER the shadow. Cutout: shadow only, with the original
+ * silhouette punched out. `shadowColor` is the vec4 rgba tint. Pure.
+ */
+export declare const dropShadowComposite: import('typegpu').TgpuFn<(originalColor: d.Vec4f, shadowColor: d.Vec4f, shadowAlpha: d.F32, cutout: d.F32) => d.Vec4f>;
+export interface SilhouetteBlurArgs {
+    /** Where the silhouette is read from (e.g. the shadow-offset UV). */
+    at: Expr;
+    /** The screen UV the vertical pass reads back at. */
+    uv: Expr;
+    viewportSize: Expr;
+    /** Blur radius in pixels. */
+    blurRadius: Expr;
+    /** Sample the child RTT (premultiplied). */
+    sample: (coord: Expr) => Expr;
+    convertToTexture: GpuFragmentParams['convertToTexture'];
+}
+/**
+ * Two-pass separable Gaussian blur of the child's ALPHA silhouette (the frozen 13-tap table),
+ * running INLINE in the fragment: horizontal pass at `at` → an intermediate RTT
+ * (`convertToTexture` of the pass's Expr) → vertical pass at `uv`. Returns the blurred coverage
+ * scalar.
+ */
+export declare function silhouetteBlur(args: SilhouetteBlurArgs): Expr;
+/** One neighbour sample UV: uv + (dirX, dirY) × one device pixel (pixelSize = 1 / viewportSize).
+ *  Pure. */
+export declare const sharpnessTapUV: import('typegpu').TgpuFn<(uv: d.Vec2f, viewport: d.Vec2f, dirX: d.F32, dirY: d.F32) => d.Vec2f>;
+/** Sharpening kernel: center × (1 + 4·amount) − neighbours × amount, clamped to [0,1]. Operates on
+ *  the premultiplied samples; alpha is taken from the centre tap (neighbour alpha is unused — RGB
+ *  only). The caller unpremultiplies the result. */
+export declare const sharpnessCompose: import('typegpu').TgpuFn<(center: d.Vec4f, top: d.Vec4f, bottom: d.Vec4f, left: d.Vec4f, right: d.Vec4f, amount: d.F32) => d.Vec4f>;
+export interface SharpenGatherArgs {
+    uv: Expr;
+    viewportSize: Expr;
+    /** Kernel strength; 0 collapses to identity (centerWeight 1, neighbourWeight 0). */
+    amount: Expr;
+    /** Sample the child RTT (premultiplied). */
+    sample: (coord: Expr) => Expr;
+}
+/** The sharpen gather: sample the centre + 4 orthogonal one-pixel neighbours and run the
+ *  unsharp-mask kernel over them, in premultiplied space. */
+export declare function sharpenGather(args: SharpenGatherArgs): Expr;
+/**
+ * Quantise the UV to a pixel grid + build the gap/roundness cell mask.
+ *
+ * Returns vec3(sampleUV.x, sampleUV.y, mask): the cell-center-ish sample coordinate (this samples
+ * the floored cell origin, not the center) packed with the rounded-rect cell coverage mask.
+ * `scale` counts pixels along the LONGEST side; the shorter side scales by aspect (clamped ≥ 1).
+ * Floor-quantise for the sample UV, fract-local coords for the SDF. Pure.
+ */
+export declare const pixelateSample: import('typegpu').TgpuFn<(uv: d.Vec2f, aspect: d.F32, scale: d.F32, gap: d.F32, roundness: d.F32) => d.Vec3f>;
+export interface PixelateGatherArgs {
+    uv: Expr;
+    aspect: Expr;
+    /** Pixel count along the longest edge (higher = smaller pixels). */
+    scale: Expr;
+    /** Space between cells as a fraction of cell size. */
+    gap: Expr;
+    /** Corner roundness of each cell (0 = square, 1 = circle). */
+    roundness: Expr;
+    /** Sample the child RTT and unpremultiply — the scaffold's straight-alpha sampler. */
+    sampleStraight: (coord: Expr) => Expr;
+}
+/** The pixelate gather: one straight-alpha sample at the quantised cell coordinate, with the
+ *  rounded-rect cell mask applied to the alpha. Returns STRAIGHT alpha. */
+export declare function pixelateGather(args: PixelateGatherArgs): Expr;
+/**
+ * The distorted sample coordinate for a screen UV. `tileCount` applies to the LONGEST side; the
+ * shorter side scales by aspect. The grid is rotated in aspect-corrected square space; the
+ * refraction offset pushes each fragment away from its tile centre (roundness fades that off
+ * radially). Vector ops fluent, scalar ops infix. Pure.
+ */
+export declare const glassTilesUV: import('typegpu').TgpuFn<(uv: d.Vec2f, aspect: d.F32, intensity: d.F32, baseTileCount: d.F32, rotationDegrees: d.F32, roundnessAmount: d.F32) => d.Vec2f>;
+export interface GlassTilesUVArgs {
+    uv: Expr;
+    aspect: Expr;
+    intensity: Expr;
+    tileCount: Expr;
+    rotation: Expr;
+    roundness: Expr;
+}
+/** The tile-distorted sample coordinate (shared by the fragment and the analytic remap). */
+export declare function glassTilesDistortUV(args: GlassTilesUVArgs): Expr;
+/**
+ * The glass-tiles fragment: sample the child RTT at the tile-distorted coordinate with the default
+ * clamp-to-edge sampler (no edge modes), then unpremultiply. Catmull-Rom reconstruction: each tile
+ * magnifies its slice of the content, so a single bilinear tap would facet any hard edge underneath.
+ * Returns STRAIGHT alpha.
+ */
+export declare function glassTilesFragment(args: GlassTilesUVArgs & {
+    texture: KitTexture;
+}): Expr;
+/** The analytic remap coordinate: the same tiled-refraction bend, clamped to [0,1] to match the
+ *  fragment path's clamp sampler (edgeClampUV clamps to `vec2(0)`..`vec2(1)`). */
+export declare function glassTilesRemapUV(args: GlassTilesUVArgs): Expr;
+/** One chromatic-aberration sample UV: shift X by ±(colorShift·0.002). `dir` is +1 (red) / -1
+ *  (blue); green samples the un-shifted uv directly. */
+export declare const crtSampleUV: import('typegpu').TgpuFn<(uv: d.Vec2f, colorShift: d.F32, dir: d.F32) => d.Vec2f>;
+/** Combine the three split-tap samples into one RGB: red from the +tap, green from the centre,
+ *  blue from the −tap. */
+export declare const rgbSplitCombine: import('typegpu').TgpuFn<(redSample: d.Vec4f, greenSample: d.Vec4f, blueSample: d.Vec4f) => d.Vec3f>;
+/** Brightness + contrast around 0.5. */
+export declare const adjustShade: import('typegpu').TgpuFn<(color: d.Vec3f, contrast: d.F32, brightness: d.F32) => d.Vec3f>;
+/** Sinusoidal scanlines: darken by a sin wave over `uvY × frequency` (period constant 3.14159·2). */
+export declare const scanlineShade: import('typegpu').TgpuFn<(color: d.Vec3f, uvY: d.F32, scanlineFrequency: d.F32, scanlineIntensity: d.F32) => d.Vec3f>;
+/** Subtle RGB phosphor pattern (per-channel sin masks with phase offsets 2.09/4.18). */
+export declare const phosphorShade: import('typegpu').TgpuFn<(color: d.Vec3f, uv: d.Vec2f, pixelSize: d.F32) => d.Vec3f>;
+/** Aspect-corrected circular vignette (X in height-units). */
+export declare const vignetteShade: import('typegpu').TgpuFn<(color: d.Vec3f, uv: d.Vec2f, aspect: d.F32, vignetteRadius: d.F32, vignetteIntensity: d.F32) => d.Vec3f>;
+/** Burst gate: slow scrolling noise, hard-edged — turns constant wobble into intermittent bursts. */
+export declare const burstGate: import('typegpu').TgpuFn<(t: d.F32) => d.F32>;
+/**
+ * Per-scanline fine noise: quantise UV.y into fields, hash each field. Luma/chroma get different
+ * time-seeded hashes (additive seed, non-degenerate at t≈0). The burst gate scales the jitter
+ * (`0.25 + burst·0.75`). Returns vec2(lumaRowOffset, chromaRowOffset).
+ */
+export declare const rowJitter: import('typegpu').TgpuFn<(uvY: d.F32, t: d.F32, scanlineNoise: d.F32, burst: d.F32) => d.Vec2f>;
+/** Tape waves (two-octave low-frequency wobble, always subtly present). */
+export declare const tapeWave: import('typegpu').TgpuFn<(uvY: d.F32, t: d.F32, wobble: d.F32) => d.F32>;
+/** Tape crease: narrow horizontal band scrolling vertically, gated intermittently. */
+export declare const creaseShift: import('typegpu').TgpuFn<(uvY: d.F32, t: d.F32, wobble: d.F32) => d.F32>;
+/**
+ * Head-switching noise: strong, localised to the top ~5% of the frame. A `smoothstep(0.06, 0, uvY)`
+ * band would have reversed edges (edge0 > edge1); written as `1 − smoothstep(0, 0.06, uvY)`
+ * (provably identical, satisfies WGSL's edge0<edge1). Returns vec2(switchX, switchY).
+ */
+export declare const headSwitch: import('typegpu').TgpuFn<(uvY: d.F32, t: d.F32, wobble: d.F32, burst: d.F32) => d.Vec2f>;
+/**
+ * All per-fragment tape geometry → the luma sample UV (.xy) + chroma base UV (.zw). t = time·speed.
+ * Composes the tape parts: one burst gate feeds both the row jitter and the head switch (a shared
+ * intermediate — computed once here), and the wave/crease/switch offsets fold into one global X.
+ */
+export declare const vhsSampleUVs: import('typegpu').TgpuFn<(uv: d.Vec2f, time: d.F32, speed: d.F32, wobble: d.F32, scanlineNoise: d.F32) => d.Vec4f>;
+/** AC beat: very subtle brightness pulse. mod(t, 2π) is safe with std.mod (truncated) because
+ *  t = time·speed ≥ 0 (speed ≥ 0.1), so floored ≡ truncated. */
+export declare const vhsAcBeat: import('typegpu').TgpuFn<(uv: d.Vec2f, time: d.F32, speed: d.F32, wobble: d.F32) => d.F32>;
+/** One chroma smear tap UV: chromaUV shifted left by i·smearScale (smearScale = smear·0.0075).
+ *  Pure. Sign of smear flips the trailing side. */
+export declare const vhsChromaTapUV: import('typegpu').TgpuFn<(chromaUV: d.Vec2f, smearScale: d.F32, i: d.F32) => d.Vec2f>;
+/**
+ * YIQ recombine: sharp luma Y from the luma tap + smeared I/Q from the 6-tap chroma blur. The i=0
+ * tap has weight (0/5)·(2/6)=0, so it contributes nothing and is omitted — c1..c5 carry weights
+ * i/15 (from `(i/(N-1))·(2/N)`, N=6), which sum to 1. Returns the recombined RGB (unclamped).
+ * Deterministic given the samples.
+ */
+export declare const yiqRecombine: import('typegpu').TgpuFn<(luma: d.Vec4f, c1: d.Vec4f, c2: d.Vec4f, c3: d.Vec4f, c4: d.Vec4f, c5: d.Vec4f) => d.Vec3f>;
+/** Pulse the RGB by the beat factor and clamp to [0,1], preserving alpha. */
+export declare const beatShade: import('typegpu').TgpuFn<(color: d.Vec4f, acBeat: d.F32) => d.Vec4f>;
+/**
+ * Temporal pulse — bursts of glitch followed by calm. A cubed slow hash gates the major bursts, a
+ * squared fast hash the minor flickers; both threshold against `1 − intensity`.
+ */
+export declare const burstPulse: import('typegpu').TgpuFn<(slowFrame: d.F32, fastFrame: d.F32, intensity: d.F32) => d.F32>;
+/**
+ * One horizontal jitter band scale: hash the band row against a frame counter, gate it by the
+ * glitch strength, and displace active bands. Returns vec3(displace, active, seed) — the seed is
+ * exposed so the caller can derive correlated values (vertical jitter) for the same band.
+ */
+export declare const bandJitter: import('typegpu').TgpuFn<(bandY: d.F32, frame: d.F32, seedScale: d.F32, frameScale: d.F32, gateFactor: d.F32, hashOffset: d.F32, amplitude: d.F32, glitchStrength: d.F32) => d.Vec3f>;
+/** Coarse block displacement on a 4-column grid. Returns vec2(displace, active). */
+export declare const blockShift: import('typegpu').TgpuFn<(colX: d.F32, bandY1: d.F32, slowFrame: d.F32, glitchStrength: d.F32) => d.Vec2f>;
+/** Mirror distortion — flip content horizontally/vertically in some active blocks. */
+export declare const mirrorFlips: import('typegpu').TgpuFn<(displacedUV: d.Vec2f, colX: d.F32, bandY1: d.F32, slowFrame: d.F32, bandActive1: d.F32, mirrorChance: d.F32, glitchStrength: d.F32) => d.Vec2f>;
+/**
+ * The shared glitch warp geometry: the burst pulse and band hashes feed the displacement, the
+ * mirror flips, the RGB-split spread, AND the fill/scanline gates together, so they are computed
+ * once here and exported as struct fields for the downstream parts. (Member reads re-emit the
+ * call; Metal CSEs the identical `glitchGeom(...)` across them.)
+ */
+export declare const GlitchGeom: d.WgslStruct<{
+    /** The displaced + mirror-flipped sample coordinate. */
+    mirroredUV: d.Vec2f;
+    /** `glitchStrength + |totalDisplaceX|·2` — scales the RGB-split offset. */
+    spread: d.F32;
+    /** The burst-gated glitch strength. */
+    strength: d.F32;
+    bandY1: d.F32;
+    slowFrame: d.F32;
+    /** bandActive1 — gates fills to active primary bands. */
+    bandGate: d.F32;
+    /** blockActive — gates fills to active blocks. */
+    blockGate: d.F32;
+    /** Any band active at any scale — confines the scanlines to distorted regions. */
+    distortion: d.F32;
+}>;
+export declare const glitchGeom: import('typegpu').TgpuFn<(uv: d.Vec2f, time: d.F32, intensity: d.F32, speed: d.F32, blockDensity: d.F32, mirrorChance: d.F32) => d.WgslStruct<{
+    /** The displaced + mirror-flipped sample coordinate. */
+    mirroredUV: d.Vec2f;
+    /** `glitchStrength + |totalDisplaceX|·2` — scales the RGB-split offset. */
+    spread: d.F32;
+    /** The burst-gated glitch strength. */
+    strength: d.F32;
+    bandY1: d.F32;
+    slowFrame: d.F32;
+    /** bandActive1 — gates fills to active primary bands. */
+    bandGate: d.F32;
+    /** blockActive — gates fills to active blocks. */
+    blockGate: d.F32;
+    /** Any band active at any scale — confines the scanlines to distorted regions. */
+    distortion: d.F32;
+}>>;
+/** The two RGB-split tap UVs around the mirrored coordinate, clamped to [0,1]:
+ *  vec4(redUV.xy, blueUV.xy). The offset is `rgbShift·0.003·spread`. */
+export declare const glitchSplitUVs: import('typegpu').TgpuFn<(mirroredUV: d.Vec2f, rgbShift: d.F32, spread: d.F32) => d.Vec4f>;
+/**
+ * Colour fills — SMPTE bars or a solid neon hue per block, mixed into the colour in active
+ * blocks. fillColor is a full-strength (unpremultiplied) neon colour — scaled by `color.w`
+ * before mixing into premultiplied-space content, so the bar respects a semi-transparent
+ * child's alpha instead of reading as fully opaque and then getting over-brightened by the
+ * trailing unpremultiplyAlpha.
+ */
+export declare const fillBarsShade: import('typegpu').TgpuFn<(color: d.Vec4f, uv: d.Vec2f, bandY1: d.F32, slowFrame: d.F32, colorBarMix: d.F32, strength: d.F32, bandGate: d.F32, blockGate: d.F32) => d.Vec4f>;
+/** Scanlines confined to actively distorted regions (pixel-space sin wave, ×0.3 ceiling). */
+export declare const distortScanShade: import('typegpu').TgpuFn<(color: d.Vec4f, uvY: d.F32, viewportY: d.F32, scanlines: d.F32, distortion: d.F32) => d.Vec4f>;
+//# sourceMappingURL=motionBlur.d.ts.map

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

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

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

@@ -0,0 +1,119 @@
+import { d } from './index';
+
+/** Aspect-corrected screen plane: `vec2(uv.x · aspect, uv.y)` (guarded divide). */
+export declare const aspectPlane: import('typegpu').TgpuFn<(uv: d.Vec2f, viewport: d.Vec2f) => d.Vec2f>;
+/**
+ * The RAW-divide exponential-scale framing (Scratches' historical domain): like
+ * `fields.aspectScaledDomain` but with an unguarded `viewport.x / viewport.y`, preserving the
+ * shader's exact arithmetic.
+ */
+export declare const rawAspectScaledDomain: import('typegpu').TgpuFn<(uv: d.Vec2f, viewport: d.Vec2f, scale: d.F32, seed: d.F32) => d.Vec2f>;
+/**
+ * The rotated fractal framing: aspect-correct, centre on the canvas midpoint, rotate by
+ * `angle` (degrees).
+ */
+export declare const rotatedCenteredDomain: import('typegpu').TgpuFn<(uv: d.Vec2f, viewport: d.Vec2f, angle: d.F32) => d.Vec2f>;
+/**
+ * Flow-speed magnitude of the divergence-free 2D curl field, √2-normalized
+ * (`length(curl22z(pos, z)) / 1.414`) so it reads as a [0,1]-ish swirling intensity. `z` is the
+ * evolution phase (a scaled time). Hash-based → GPU-only.
+ */
+export declare const curlMagnitude: import('typegpu').TgpuFn<(pos: d.Vec2f, z: d.F32) => d.F32>;
+/**
+ * The fBm accumulation stage: run the gated golden-angle octave sum over MaterialX simplex at
+ * base frequency 2, returning `vec2(accumulated, totalWeight)`. `detail` is the lacunarity and
+ * `contrast` the persistence; the seed offsets the two axes differently (`seed`, `seed · 0.7`)
+ * so re-rolling re-mixes rather than translating. GPU-only via the hash.
+ */
+export declare const fractalSum: import('typegpu').TgpuFn<(pos: d.Vec2f, detail: d.F32, contrast: d.F32, animTime: d.F32, seed: d.F32, octaveCount: d.F32) => d.Vec2f>;
+/**
+ * Normalize an fBm sum to the unit range: divide by the accumulated weight, remap the [-1,1]
+ * result to [0,1], clamp.
+ */
+export declare const fbmNormalize: import('typegpu').TgpuFn<(sum: d.Vec2f) => d.F32>;
+/** The shared legacy sin-fract cell hash, under WorleyNoise's historical name. */
+export declare const worleyHash: import('typegpu').TgpuFn<(p: d.Vec2f) => d.Vec2f>;
+/** One Worley octave: the nearest-2 cellular fold + the selectable mode reduction. */
+export declare const worleyEvalOctave: import('typegpu').TgpuFn<(oUV: d.Vec2f, animT: d.F32, seedOff: d.F32, jitter: d.F32, distNum: d.F32, modeNum: d.F32) => d.F32>;
+/**
+ * The Worley accumulation stage: the gated cellular octave sum over an aspect-plane position,
+ * returning `vec2(accumulated, totalWeight)`. `scale` is the base cell frequency; jitter, the
+ * distance metric, and the field reduction ride the per-octave `extra` bundle.
+ */
+export declare const worleyCells: import('typegpu').TgpuFn<(pos: d.Vec2f, scale: d.F32, seed: d.F32, jitter: d.F32, lacunarity: d.F32, persistence: d.F32, animTime: d.F32, octaves: d.F32, distNum: d.F32, modeNum: d.F32) => d.Vec2f>;
+/** Normalize a Worley sum: guarded weight divide, scaled by the per-mode normalization. */
+export declare const worleyNormalize: import('typegpu').TgpuFn<(sum: d.Vec2f, modeScale: d.F32) => d.F32>;
+/**
+ * Worley's tone tail: balance (shift) + contrast (scale about 0.5), remapped to [0,1] — the
+ * multiplicative, non-inverted tone variant (see `kit/tone.ts`; `contrast` is a gain here,
+ * 1 = identity). Pure float (CPU golden-testable).
+ */
+export declare const worleyTone: import('./tone').ToneRemapFn;
+/** Enum transform for the Worley `mode` prop (applied by the uniform bridge). */
+export declare const transformWorleyMode: (value: string) => number;
+/** Enum transform for the Worley `distance` prop (applied by the uniform bridge). */
+export declare const transformWorleyDistance: (value: string) => number;
+/** `mode` as its mapped number, robust to a raw string arriving untransformed. */
+export declare function worleyModeNum(raw: unknown): number;
+/** `distance` as its mapped number, robust to a raw string arriving untransformed. */
+export declare function worleyDistNum(raw: unknown): number;
+/**
+ * Per-mode normalization so default contrast=1 lands the result in roughly [0,1]. The distance
+ * metric also affects scale: Manhattan distances run larger than Euclidean, Chebyshev smaller.
+ */
+export declare function worleyModeScale(modeNum: number, distNum: number): number;
+/**
+ * The 3×3 nearest-two-features fold, returning `vec2(d1, d2)`. Plain Euclidean distance per tap
+ * (a ratio reduction needs real distances, not squared ones) and no jitter control — the cells
+ * are always fully random. The drifting cell points hash per-neighbour → GPU-only.
+ */
+export declare const voronoiCells: import('./cellular').Nearest2Fn;
+/**
+ * Fill gradient from the F1/F2 ratio, so cell size does not change the tonal range.
+ * `edgeIntensity` inverts into the ratio's exponent: high intensity = low power = the edge
+ * colour reaches further into each cell.
+ */
+export declare const cellFill: import('typegpu').TgpuFn<(dd: d.Vec2f, edgeIntensity: d.F32) => d.F32>;
+/**
+ * Boundary-line mask between cells, with `softness` compensated for the cell count so the line
+ * width reads constant as `scale` changes. 0 on a boundary, 1 inside a cell.
+ */
+export declare const cellBorders: import('typegpu').TgpuFn<(dd: d.Vec2f, softness: d.F32, scale: d.F32) => d.F32>;
+/** The gentle `pow(rgb, 0.85)` tone lift on a final P3-linear rgb. GPU-only. */
+export declare const toneLift: import('typegpu').TgpuFn<(rgb: d.Vec3f) => d.Vec3f>;
+/**
+ * The strands path frame — everything about the start→end path that is loop-invariant across
+ * strands: `vec4(progress, perpDist, pinch, edgeFade)`. Progress runs 0→1 start→end; perpDist is
+ * the signed distance from the path; pinch/edgeFade converge and fade the strands at the endpoints
+ * when pinning is on (`pinFlag` is the transformBoolean scalar: on = > 0). Start/end are
+ * aspect-corrected and Y-flipped here (transformPosition stores (x, 1-y) → `1 - .y` = authored).
+ */
+export declare const ribbonPathFrame: import('typegpu').TgpuFn<(uv: d.Vec2f, viewport: d.Vec2f, start: d.Vec2f, end: d.Vec2f, pinFlag: d.F32) => d.Vec4f>;
+/**
+ * The flowing ribbons field (the ribbons genre primitive). A runtime loop over the ACTIVE ribbon count accumulates each strand's
+ * WORKING-SPACE gradient color (via {@link gradientStopsInSpace} — a preconverted, alpha-weighted
+ * per-segment mix) weighted by coverage. Returns `vec4(workingColorRGB, alpha)`; the caller does
+ * the single back-conversion + tone-pow at the compile-time colorSpace mode. Scalars are packed
+ * into vec4 params (tgpu.fn 15-arg cap). Loop is hash-free but nested → GPU-only. `packed3`
+ * carries pinEdges (transformBoolean: on = > 0), the two animated clocks, and the runtime stop
+ * count.
+ *
+ * ATOMIC (deliberately): the per-strand gradient lookup and coverage weighting live inside a
+ * runtime-count reduce — splitting them would hoist a loop-carried dependency. The separable
+ * pieces already live outside: the loop-invariant path geometry in {@link ribbonPathFrame}, the
+ * tails (tone-pow, back-conversion) in the noun.
+ */
+export declare const ribbonsField: import('typegpu').TgpuFn<(uv: d.Vec2f, viewport: d.Vec2f, start: d.Vec2f, end: d.Vec2f, packed1: d.Vec4f, packed2: d.Vec4f, packed3: d.Vec4f, colors: d.WgslArray<d.Vec4f>, positions: d.WgslArray<d.Vec4f>, converted: d.WgslArray<d.Vec3f>) => d.Vec4f>;
+/**
+ * Paper surface (displaced sample UV + grain brightness). Packs the two per-pixel derivations
+ * Paper needs into one `vec3f` so the grain UV is computed once: `.xy` is the child sample UV
+ * shifted along the divergence-free curl flow (fiber-direction micro-roughness), `.z` is the
+ * fibrous-grain brightness. `curl22`/`paper12` are hash-based → GPU-only (the u32-hash rule); the
+ * math: grain freq `grainScale*6`, disp `curl22 * displacement * 0.0025`, brightness centred on
+ * paper12's ~0.7 mid.
+ *
+ * ATOMIC (deliberately): the shared grain UV feeds BOTH outputs — splitting into a displacement
+ * part and a brightness part would re-derive it.
+ */
+export declare const paperSurface: import('typegpu').TgpuFn<(uv: d.Vec2f, aspect: d.F32, grainScale: d.F32, seed: d.F32, displacement: d.F32, roughness: d.F32) => d.Vec3f>;
+//# sourceMappingURL=noisePaints.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"noisePaints.d.ts","sourceRoot":"","sources":["../../../src/gpu/kit/noisePaints.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAAO,CAAC,EAAM,MAAM,SAAS,CAAA;AAWpC,mFAAmF;AACnF,eAAO,MAAM,WAAW,uEAItB,CAAA;AAEF;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,kGAM5B,CAAA;AAEN;;;GAGG;AACH,eAAO,MAAM,qBAAqB,qFAY5B,CAAA;AAIN;;;;GAIG;AACH,eAAO,MAAM,aAAa,6DAGxB,CAAA;AAcF;;;;;GAKG;AACH,eAAO,MAAM,UAAU,uIAIjB,CAAA;AAEN;;;GAGG;AACH,eAAO,MAAM,YAAY,mDAGvB,CAAA;AAIF,kFAAkF;AAClF,eAAO,MAAM,UAAU,mDAAY,CAAA;AAYnC,sFAAsF;AACtF,eAAO,MAAM,gBAAgB,gIAKvB,CAAA;AAYN;;;;GAIG;AACH,eAAO,MAAM,WAAW,uMAQtB,CAAA;AAEF,2FAA2F;AAC3F,eAAO,MAAM,eAAe,qEAG1B,CAAA;AAEF;;;;GAIG;AACH,eAAO,MAAM,UAAU,8BAA6E,CAAA;AAEpG,iFAAiF;AACjF,eAAO,MAAM,mBAAmB,UAAW,MAAM,KAAG,MAAgC,CAAA;AAEpF,qFAAqF;AACrF,eAAO,MAAM,uBAAuB,UAAW,MAAM,KAAG,MAAkC,CAAA;AAE1F,kFAAkF;AAClF,wBAAgB,aAAa,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAElD;AAED,sFAAsF;AACtF,wBAAgB,aAAa,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAElD;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CASxE;AAID;;;;GAIG;AACH,eAAO,MAAM,YAAY,iCAA+E,CAAA;AAExG;;;;GAIG;AACH,eAAO,MAAM,QAAQ,wEAInB,CAAA;AAEF;;;GAGG;AACH,eAAO,MAAM,WAAW,iFAItB,CAAA;AAIF,gFAAgF;AAChF,eAAO,MAAM,QAAQ,qDAGnB,CAAA;AAUF;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,qHAsBtB,CAAA;AAEN;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,YAAY,2PAqEvB,CAAA;AAIF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,YAAY,0IAanB,CAAA"}