shaders 3.1.463 → 3.2.464

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":"AAgBA,OAAO,KAAK,EAAC,IAAI,EAAE,iBAAiB,EAAE,UAAU,EAAC,MAAM,aAAa,CAAA;AACpE,OAAO,EAAO,CAAC,EAAM,MAAM,SAAS,CAAA;AAepC,qGAAqG;AACrG,eAAO,MAAM,qBAAqB,KAAK,CAAA;AAEvC,2FAA2F;AAC3F,eAAO,MAAM,mBAAmB,UAAsD,CAAA;AAEtF;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,uHAW9B,CAAA;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB,uHAgB/B,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,uHAc5B,CAAA;AAED,2DAA2D;AAC3D,MAAM,MAAM,kBAAkB,GAAG,QAAQ,GAAG,OAAO,GAAG,MAAM,CAAA;AAE5D,MAAM,WAAW,oBAAoB;IACjC,iGAAiG;IACjG,KAAK,EAAE,IAAI,CAAA;IACX,iDAAiD;IACjD,MAAM,EAAE,IAAI,CAAA;IACZ,EAAE,EAAE,IAAI,CAAA;IACR,MAAM,EAAE,IAAI,CAAA;IACZ,YAAY,EAAE,IAAI,CAAA;CACrB;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC5B,IAAI,EAAE,kBAAkB,EACxB,IAAI,EAAE,oBAAoB,EAC1B,MAAM,EAAE,CAAC,KAAK,EAAE,IAAI,KAAK,IAAI,GAC9B,IAAI,CASN;AAMD;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,yFAOxB,CAAA;AAEF,MAAM,WAAW,iBAAiB;IAC9B,EAAE,EAAE,IAAI,CAAA;IACR,qCAAqC;IACrC,MAAM,EAAE,IAAI,CAAA;IACZ,YAAY,EAAE,IAAI,CAAA;IAClB,+FAA+F;IAC/F,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,CAAC,KAAK,EAAE,IAAI,KAAK,IAAI,CAAA;CAChC;AAED,sGAAsG;AACtG,wBAAgB,aAAa,CAAC,IAAI,EAAE,iBAAiB,GAAG,IAAI,CAG3D;AAaD,eAAO,MAAM,uBAAuB,UAAqC,CAAA;AAGzE;4EAC4E;AAC5E,eAAO,MAAM,YAAY,sGAQvB,CAAA;AAEF,iGAAiG;AACjG,eAAO,MAAM,eAAe,gHAG1B,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,wHAiB9B,CAAA;AAEF,MAAM,WAAW,kBAAkB;IAC/B,qEAAqE;IACrE,EAAE,EAAE,IAAI,CAAA;IACR,qDAAqD;IACrD,EAAE,EAAE,IAAI,CAAA;IACR,YAAY,EAAE,IAAI,CAAA;IAClB,6BAA6B;IAC7B,UAAU,EAAE,IAAI,CAAA;IAChB,4CAA4C;IAC5C,MAAM,EAAE,CAAC,KAAK,EAAE,IAAI,KAAK,IAAI,CAAA;IAC7B,gBAAgB,EAAE,iBAAiB,CAAC,kBAAkB,CAAC,CAAA;CAC1D;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,kBAAkB,GAAG,IAAI,CAqB7D;AAMD;YACY;AACZ,eAAO,MAAM,cAAc,iGAGzB,CAAA;AAEF;;oDAEoD;AACpD,eAAO,MAAM,gBAAgB,qIAYvB,CAAA;AAEN,MAAM,WAAW,iBAAiB;IAC9B,EAAE,EAAE,IAAI,CAAA;IACR,YAAY,EAAE,IAAI,CAAA;IAClB,oFAAoF;IACpF,MAAM,EAAE,IAAI,CAAA;IACZ,4CAA4C;IAC5C,MAAM,EAAE,CAAC,KAAK,EAAE,IAAI,KAAK,IAAI,CAAA;CAChC;AAED;6DAC6D;AAC7D,wBAAgB,aAAa,CAAC,IAAI,EAAE,iBAAiB,GAAG,IAAI,CAQ3D;AAMD;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,+GAyBrB,CAAA;AAEN,MAAM,WAAW,kBAAkB;IAC/B,EAAE,EAAE,IAAI,CAAA;IACR,MAAM,EAAE,IAAI,CAAA;IACZ,oEAAoE;IACpE,KAAK,EAAE,IAAI,CAAA;IACX,sDAAsD;IACtD,GAAG,EAAE,IAAI,CAAA;IACT,8DAA8D;IAC9D,SAAS,EAAE,IAAI,CAAA;IACf,sFAAsF;IACtF,cAAc,EAAE,CAAC,KAAK,EAAE,IAAI,KAAK,IAAI,CAAA;CACxC;AAED;2EAC2E;AAC3E,wBAAgB,cAAc,CAAC,IAAI,EAAE,kBAAkB,GAAG,IAAI,CAI7D;AAMD;;;;;GAKG;AACH,eAAO,MAAM,YAAY,2JAoCnB,CAAA;AAEN,MAAM,WAAW,gBAAgB;IAC7B,EAAE,EAAE,IAAI,CAAA;IACR,MAAM,EAAE,IAAI,CAAA;IACZ,SAAS,EAAE,IAAI,CAAA;IACf,SAAS,EAAE,IAAI,CAAA;IACf,QAAQ,EAAE,IAAI,CAAA;IACd,SAAS,EAAE,IAAI,CAAA;CAClB;AAED,4FAA4F;AAC5F,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,gBAAgB,GAAG,IAAI,CAEhE;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,gBAAgB,GAAG;IAAC,OAAO,EAAE,UAAU,CAAA;CAAC,GAAG,IAAI,CAGvF;AAED;kFACkF;AAClF,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,gBAAgB,GAAG,IAAI,CAE9D;AAMD;wDACwD;AACxD,eAAO,MAAM,WAAW,mFAItB,CAAA;AAEF;0BAC0B;AAC1B,eAAO,MAAM,eAAe,sGAG1B,CAAA;AAEF,wCAAwC;AACxC,eAAO,MAAM,WAAW,2FAGtB,CAAA;AAEF,qGAAqG;AACrG,eAAO,MAAM,aAAa,uHAMxB,CAAA;AAEF,wFAAwF;AACxF,eAAO,MAAM,aAAa,sFAQxB,CAAA;AAEF,8DAA8D;AAC9D,eAAO,MAAM,aAAa,oIAUxB,CAAA;AA8BF,qGAAqG;AACrG,eAAO,MAAM,SAAS,+CAGpB,CAAA;AAEF;;;;GAIG;AACH,eAAO,MAAM,SAAS,iGASpB,CAAA;AAEF,2EAA2E;AAC3E,eAAO,MAAM,QAAQ,0EAKnB,CAAA;AAEF,sFAAsF;AACtF,eAAO,MAAM,WAAW,0EAKtB,CAAA;AAEF;;;;GAIG;AACH,eAAO,MAAM,UAAU,0FAOrB,CAAA;AAEF;;;;GAIG;AACH,eAAO,MAAM,YAAY,oHAUnB,CAAA;AAEN;gEACgE;AAChE,eAAO,MAAM,SAAS,4FAIpB,CAAA;AAEF;mDACmD;AACnD,eAAO,MAAM,cAAc,uFAGzB,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,YAAY,uHAwBnB,CAAA;AAEN,6EAA6E;AAC7E,eAAO,MAAM,SAAS,sEAIpB,CAAA;AAcF;;;GAGG;AACH,eAAO,MAAM,UAAU,2FAUrB,CAAA;AAEF;;;;GAIG;AACH,eAAO,MAAM,UAAU,uLAQjB,CAAA;AAEN,oFAAoF;AACpF,eAAO,MAAM,UAAU,4GAOrB,CAAA;AAEF,sFAAsF;AACtF,eAAO,MAAM,WAAW,2KAYlB,CAAA;AAEN;;;;;GAKG;AACH,eAAO,MAAM,UAAU;IACnB,wDAAwD;;IAExD,2EAA2E;;IAE3E,uCAAuC;;;;IAIvC,yDAAyD;;IAEzD,kDAAkD;;IAElD,kFAAkF;;EAEpF,CAAA;AAEF,eAAO,MAAM,UAAU;IAhBnB,wDAAwD;;IAExD,2EAA2E;;IAE3E,uCAAuC;;;;IAIvC,yDAAyD;;IAEzD,kDAAkD;;IAElD,kFAAkF;;GA+ChF,CAAA;AAEN;wEACwE;AACxE,eAAO,MAAM,cAAc,4FAMzB,CAAA;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,6KAwBpB,CAAA;AAEN,6FAA6F;AAC7F,eAAO,MAAM,gBAAgB,0HAQvB,CAAA"}

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

@@ -0,0 +1,129 @@
+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 marble turbulence field: three hand-unrolled MaterialX octaves over a linearly-scaled
+ * plane position. The octaves stay hand-unrolled rather than adopting {@link fbmGated}: each
+ * uses a DIFFERENT seed multiplier and time rate (1.7/0.7, 3.1/1.3) — hand-tuned decorrelation
+ * the gated loop's uniform per-octave stride cannot reproduce. GPU-only via the hash.
+ */
+export declare const marbleTurbulence: import('typegpu').TgpuFn<(pos: d.Vec2f, seed: d.F32, animTime: d.F32) => d.F32>;
+/**
+ * The vein wave: a noise-warped sine over the plane's x coordinate — `turbulence` sets how far
+ * the turbulence field bends the stripes — squashed to [0,1].
+ */
+export declare const veinWave: import('typegpu').TgpuFn<(x: d.F32, turb: d.F32, turbulence: d.F32) => d.F32>;
+/** Slow cross-axis noise (~[0.2, 0.8]) varying how deep the deepest veins read. */
+export declare const veinDepth: import('typegpu').TgpuFn<(pos: d.Vec2f, seed: d.F32) => d.F32>;
+/**
+ * The two-band vein ladder: `vec2(t1, t2 · depthVar)` — the blend factors for a base → tone →
+ * depth colour ladder, with the deep band modulated by {@link veinDepth}.
+ */
+export declare const veinLadder: import('typegpu').TgpuFn<(marbleT: d.F32, depthVar: d.F32) => d.Vec2f>;
+/** Tone lift applied to Strands' final P3-linear rgb (`pow(rgb, vec3(0.85))`). GPU-only. */
+export declare const strandsTonePow: import('typegpu').TgpuFn<(rgb: d.Vec3f) => d.Vec3f>;
+/**
+ * The flowing ribbon field. A runtime loop over the ACTIVE strand 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
+ * tails (tone-pow, back-conversion) already live outside.
+ */
+export declare const strandsField: 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;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,iFAM3B,CAAA;AAEF;;;GAGG;AACH,eAAO,MAAM,QAAQ,+EAInB,CAAA;AAEF,mFAAmF;AACnF,eAAO,MAAM,SAAS,gEAGpB,CAAA;AAEF;;;GAGG;AACH,eAAO,MAAM,UAAU,wEAKrB,CAAA;AAIF,4FAA4F;AAC5F,eAAO,MAAM,cAAc,qDAGzB,CAAA;AAUF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,YAAY,2PAoFvB,CAAA;AAIF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,YAAY,0IAanB,CAAA"}

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

@@ -0,0 +1,117 @@
+import { GpuFragmentParams, KitTexture } from '../contract';
+
+/**
+ * Premultiplied Porter-Duff "over": composite one straight-alpha layer (`rgb`, `a`) on top of
+ * the premultiplied accumulator `dst`, clamping the layer alpha. One statement, brace-scoped so
+ * repeated composites in the same block don't collide on the temp.
+ */
+export declare function overPremul(dst: string, rgb: string, a: string): string;
+/**
+ * Signed distance to a (rounded) rectangle: emits the classic sdRoundRect `q`/`sd` pair for the
+ * centre-relative point `pp` against half-extent `half`. With `radius` omitted the radius terms
+ * are not emitted at all (a sharp box, not a zero-radius one).
+ */
+export declare function roundRectSD(names: {
+    q: string;
+    sd: string;
+}, opts: {
+    pp: string;
+    half: string;
+    radius?: string;
+}): string[];
+/**
+ * The corner-bracket mask: keeps a box stroke only near its four corners (the "tracker
+ * bracket" look). `blInit` is the bracket-length expression — the constant inside it is the
+ * consumer's look and stays at the call site. Multiplies `stroke` in place.
+ */
+export declare function cornerBracketMask(names: {
+    bl: string;
+    inCorner: string;
+}, opts: {
+    blInit: string;
+    px: string;
+    py: string;
+    hx: string;
+    hy: string;
+    stroke: string;
+}): string[];
+/**
+ * The overlay output convention: the draw accumulator is premultiplied; the fragment returns
+ * straight alpha. Returns the final expression string.
+ */
+export declare function straightFromPremul(dst: string): string;
+export declare const GLYPH_ATLAS_GLYPHS = "0123456789x%";
+export declare const GLYPH_ATLAS_SLOTS = 16;
+export declare const GLYPH_ATLAS_CELL_W = 64;
+export declare const GLYPH_ATLAS_CELL_H = 96;
+export declare const DETECTION_WALK_SCAN = 3;
+export declare const DETECTION_LEAF_SCAN = 4;
+/**
+ * A glyph-strip atlas: a fixed-size media texture rasterised on a CPU canvas, redrawn on
+ * font-prop change (prop-keyed invalidation + fallback-then-real-font re-raster). Returns the
+ * atlas texture the label part samples by digit slot.
+ */
+export declare function createGlyphStripAtlas(params: GpuFragmentParams, opts?: {
+    glyphs?: string;
+    label?: string;
+    familyProp?: string;
+    weightProp?: string;
+}): KitTexture;
+/** The shared frame every detection part writes against: prefix, emitters, statement sink. */
+export interface DetectionEmitFrame {
+    p: string;
+    U: (name: string) => string;
+    L: (n: number) => string;
+    s: string[];
+    /** The child RTT read (textureSampleLevel — samples sit in dynamic-value context). */
+    sampleChild: (uvWgsl: string) => string;
+    /** Resolved kit unpremultiplyAlpha fn name. */
+    UN: string;
+    /** Compile-time detection mode. */
+    modeStr: string;
+}
+/** Content-test bool for a bound sample var (compile-time on detectionMode). */
+export declare function contentPredicate(f: DetectionEmitFrame, sVar: string, uVar: string): string;
+/** JS-unrolled N×N cell scan over runtime origin/size vars; accumulates coverage (+ bbox). */
+export declare function cellScanStmts(f: DetectionEmitFrame, sfx: string, originX: string, originY: string, sizeV: string, N: number, wantBounds: boolean): void;
+/** Walk to the leaf cell (JS-unrolled over compile-time D; grid/quadtree/mosaic split rule). */
+export declare function partitionWalkStmts(f: DetectionEmitFrame, layoutStr: string, D: number): void;
+/** Content-tight bbox, expanded by half the sample pitch then inset within the cell → `detected`. */
+export declare function contentBBoxStmts(f: DetectionEmitFrame): void;
+/** Box fill + stroke (uniform width; box is fully inside its cell), corner-bracket style optional. */
+export declare function detectionBoxStmts(f: DetectionEmitFrame, cornerStyle: boolean): void;
+export declare const digitsOf: (L: (n: number) => string, v: string) => string;
+export declare const digitAt: (L: (n: number) => string, v: string, e: string) => string;
+/** The label: a rounded pill anchored to a box corner + atlas digits ("W x H" or "NN %"). */
+export declare function glyphPillLabelStmts(f: DetectionEmitFrame, opts: {
+    labelStr: string;
+    labelPos: number;
+    atlasKey: string;
+}): void;
+/** The shared frame the HUD draw parts write against. */
+export interface HudEmitFrame {
+    p: string;
+    U: (name: string) => string;
+    L: (n: number) => string;
+    s: string[];
+}
+/** One draw stage spliced into the trail ring / tracker loop. */
+export type HudStage = (f: HudEmitFrame) => void;
+/** The keyframe diamond dropped at a ring entry (reads the ring frame's `dp`/`fade`). */
+export declare const diamondStamp: HudStage;
+/** The motion-path segment from the previous ring entry (the seam's stamp gap drops its segment). */
+export declare function pathSegmentStamp(every: number): HudStage;
+/**
+ * The trail-ring frame: a runtime ring walk with a rolling previous entry (ring-adjacent pairs
+ * are chronological neighbors), owning the per-entry `valid`/`fade`/`ep`/`dp` locals the spliced
+ * stages read.
+ */
+export declare function ringTrailStmts(f: HudEmitFrame, slots: {
+    len: number;
+    every: number;
+    load: (col: string) => string;
+    stages: HudStage[];
+}): void;
+/** The tracker gizmo: corner brackets + crosshair + center dot around the head position. */
+export declare const bracketGizmo: HudStage;
+//# sourceMappingURL=overlayParts.d.ts.map

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

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

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

@@ -0,0 +1,46 @@
+import { d } from './index';
+
+export declare const latticeFrameFlipY: import('typegpu').TgpuFn<(uv: d.Vec2f, viewport: d.Vec2f, cells: d.F32, rotationDeg: d.F32) => d.Vec2f>;
+export declare const latticeFrameCW: import('typegpu').TgpuFn<(uv: d.Vec2f, viewport: d.Vec2f, cells: d.F32, rotationDeg: d.F32) => d.Vec2f>;
+export declare const latticeFrame: import('typegpu').TgpuFn<(uv: d.Vec2f, viewport: d.Vec2f, cells: d.F32, rotationDeg: d.F32) => d.Vec2f>;
+export declare const cellVariation: import('typegpu').TgpuFn<(cellId: d.Vec2f, variation: d.F32) => d.F32>;
+export declare const strokeBandFloored: import('typegpu').TgpuFn<(field: d.F32, lineWidth: d.F32, pixel: d.F32, softness: d.F32) => d.F32>;
+export declare const strokeBandSymmetric: import('typegpu').TgpuFn<(field: d.F32, lineWidth: d.F32, aaWidth: d.F32) => d.F32>;
+export declare const checkerBlend: import('typegpu').TgpuFn<(uv: d.Vec2f, viewport: d.Vec2f, cells: d.F32, softness: d.F32) => d.F32>;
+export declare const stripeCoordP: import('typegpu').TgpuFn<(uv: d.Vec2f, viewport: d.Vec2f, angle: d.F32, density: d.F32, animTime: d.F32, offset: d.F32) => d.F32>;
+export declare const stripesMask: import('typegpu').TgpuFn<(uv: d.Vec2f, viewport: d.Vec2f, angle: d.F32, density: d.F32, animTime: d.F32, offset: d.F32, balance: d.F32, softness: d.F32) => d.F32>;
+export declare const chevronMask: import('typegpu').TgpuFn<(uv: d.Vec2f, viewport: d.Vec2f, count: d.F32, angle: d.F32, balance: d.F32, softness: d.F32, offset: d.F32, animTime: d.F32) => d.F32>;
+export declare const ripplesMask: import('typegpu').TgpuFn<(center: d.Vec2f, frequency: d.F32, softness: d.F32, thickness: d.F32, phase: d.F32, animTime: d.F32, uv: d.Vec2f, viewport: d.Vec2f) => d.F32>;
+export declare const fallingLinesField: import('typegpu').TgpuFn<(uv: d.Vec2f, vp: d.Vec2f, angle: d.F32, density: d.F32, speedVariance: d.F32, trailLength: d.F32, strokeWidth: d.F32, rounding: d.F32, balance: d.F32, animTime: d.F32) => d.Vec2f>;
+export declare const gridCellCenterUV: import('typegpu').TgpuFn<(uv: d.Vec2f, viewport: d.Vec2f, cells: d.F32, rotation: d.F32) => d.Vec2f>;
+export declare const gridField: import('typegpu').TgpuFn<(gridUV: d.Vec2f, thickness: d.F32, softness: d.F32, variation: d.F32) => d.Vec2f>;
+export declare const dotGridAlpha: import('typegpu').TgpuFn<(uv: d.Vec2f, viewport: d.Vec2f, density: d.F32, dotSize: d.F32, offset: d.F32, speedVariance: d.F32, twinkle: d.F32, animTime: d.F32, time: d.F32) => d.F32>;
+export declare const hexGridField: import('typegpu').TgpuFn<(scaledUV: d.Vec2f, thickness: d.F32, softness: d.F32, variation: d.F32) => d.Vec2f>;
+export declare const triangularGridField: import('typegpu').TgpuFn<(p: d.Vec2f, thickness: d.F32, softness: d.F32, variation: d.F32, speedVariance: d.F32, animTime: d.F32) => d.Vec2f>;
+export declare const brickField: import('typegpu').TgpuFn<(uv: d.Vec2f, viewport: d.Vec2f, cellsX: d.F32, cellsY: d.F32, mortar: d.F32, softness: d.F32, variation: d.F32, rotation: d.F32, offset: d.F32, speedVariance: d.F32, seed: d.F32, animTime: d.F32) => d.Vec2f>;
+export declare const truchetField: import('typegpu').TgpuFn<(scaledUV: d.Vec2f, thickness: d.F32, softness: d.F32, seed: d.F32) => d.F32>;
+export declare const weaveColor: import('typegpu').TgpuFn<(scaledUV: d.Vec2f, gap: d.F32, colorA: d.Vec4f, colorB: d.Vec4f) => d.Vec4f>;
+export declare const isoCubeField: import('typegpu').TgpuFn<(scaledUV: d.Vec2f, thickness: d.F32, softness: d.F32) => d.Vec3f>;
+export declare const halftoneClassic: import('typegpu').TgpuFn<(childColor: d.Vec4f, uv: d.Vec2f, aspect: d.F32, angleDeg: d.F32, frequency: d.F32) => d.Vec4f>;
+export declare const halftonePlateUV: import('typegpu').TgpuFn<(uv: d.Vec2f, misprintAngleDeg: d.F32, plateIndexDeg: d.F32, misprint: d.F32, aspect: d.F32) => d.Vec2f>;
+export declare const halftoneChannelK: import('typegpu').TgpuFn<(s: d.Vec4f) => d.F32>;
+export declare const halftoneChannelC: import('typegpu').TgpuFn<(s: d.Vec4f) => d.F32>;
+export declare const halftoneChannelM: import('typegpu').TgpuFn<(s: d.Vec4f) => d.F32>;
+export declare const halftoneChannelY: import('typegpu').TgpuFn<(s: d.Vec4f) => d.F32>;
+export declare const halftonePlateGrid: import('typegpu').TgpuFn<(uv: d.Vec2f, aspect: d.F32, angleDeg: d.F32, intensity: d.F32, frequency: d.F32) => d.F32>;
+export declare const halftoneTransmission: import('typegpu').TgpuFn<(inkColor: d.Vec4f, inkMask: d.F32) => d.Vec3f>;
+export declare const ditherCoord: import('typegpu').TgpuFn<(uv: d.Vec2f, gridRes: d.Vec2f, pixelSize: d.F32) => d.Vec2f>;
+export declare const ditherPixUV: import('typegpu').TgpuFn<(coord: d.Vec2f, pixelSize: d.F32, gridRes: d.Vec2f) => d.Vec2f>;
+export declare const ditherLuma: import('typegpu').TgpuFn<(c: d.Vec4f) => d.F32>;
+export declare const ditherBayerQuad: import('typegpu').TgpuFn<(a: d.F32, b: d.F32) => d.F32>;
+export declare const ditherPeriodic: import('typegpu').TgpuFn<(coord: d.Vec2f) => d.Vec4f>;
+export declare const ditherBlueNoise: import('typegpu').TgpuFn<(coord: d.Vec2f) => d.F32>;
+export declare const ditherWhiteNoise: import('typegpu').TgpuFn<(coord: d.Vec2f) => d.F32>;
+export declare const ditherOrderedResult: import('typegpu').TgpuFn<(ditherValue: d.F32, luminance: d.F32, threshold: d.F32, spread: d.F32) => d.F32>;
+export declare const ditherBlockOrigin: import('typegpu').TgpuFn<(coord: d.Vec2f) => d.Vec2f>;
+export declare const ditherLocalCellIndex: import('typegpu').TgpuFn<(coord: d.Vec2f, blockOrigin: d.Vec2f) => d.F32>;
+export declare const ditherCellUV: import('typegpu').TgpuFn<(blockOrigin: d.Vec2f, lx: d.F32, ly: d.F32, pixelSize: d.F32, gridRes: d.Vec2f) => d.Vec2f>;
+export declare const ditherFloydSteinberg: import('typegpu').TgpuFn<(lum: d.WgslArray<d.F32>, lic: d.F32, threshold: d.F32, spread: d.F32) => d.F32>;
+export declare const ditherComposeCustom: import('typegpu').TgpuFn<(colorA: d.Vec4f, colorB: d.Vec4f, ditherResult: d.F32) => d.Vec4f>;
+export declare const ditherComposeSource: import('typegpu').TgpuFn<(sourceColor: d.Vec4f, ditherResult: d.F32) => d.Vec4f>;
+//# sourceMappingURL=patternPaints.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"patternPaints.d.ts","sourceRoot":"","sources":["../../../src/gpu/kit/patternPaints.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,EAAO,CAAC,EAAM,MAAM,SAAS,CAAA;AAsBpC,eAAO,MAAM,iBAAiB,yGAQ5B,CAAA;AAGF,eAAO,MAAM,cAAc,yGAQzB,CAAA;AAGF,eAAO,MAAM,YAAY,yGAQvB,CAAA;AAMF,eAAO,MAAM,aAAa,wEAGxB,CAAA;AAIF,eAAO,MAAM,iBAAiB,oGAM5B,CAAA;AAIF,eAAO,MAAM,mBAAmB,qFAG9B,CAAA;AASF,eAAO,MAAM,YAAY,oGAIvB,CAAA;AAaF,eAAO,MAAM,YAAY,mIASnB,CAAA;AAON,eAAO,MAAM,WAAW,oKAKlB,CAAA;AAMN,eAAO,MAAM,WAAW,kKAoBtB,CAAA;AAWF,eAAO,MAAM,WAAW,0KAclB,CAAA;AAqBN,eAAO,MAAM,iBAAiB,+MA2DxB,CAAA;AAUN,eAAO,MAAM,gBAAgB,sGAG3B,CAAA;AAKF,eAAO,MAAM,SAAS,6GA8BpB,CAAA;AAWF,eAAO,MAAM,YAAY,wLA+BvB,CAAA;AAMF,eAAO,MAAM,YAAY,+GA0BvB,CAAA;AAOF,eAAO,MAAM,mBAAmB,+IAqC9B,CAAA;AAWF,eAAO,MAAM,UAAU,2OAsDrB,CAAA;AAkBF,eAAO,MAAM,YAAY,wGAsBvB,CAAA;AASF,eAAO,MAAM,UAAU,wGA+BrB,CAAA;AAWF,eAAO,MAAM,YAAY,6FAyCvB,CAAA;AASF,eAAO,MAAM,eAAe,2HActB,CAAA;AAKN,eAAO,MAAM,eAAe,mIAKtB,CAAA;AAGN,eAAO,MAAM,gBAAgB,iDAG3B,CAAA;AACF,eAAO,MAAM,gBAAgB,iDAK3B,CAAA;AACF,eAAO,MAAM,gBAAgB,iDAK3B,CAAA;AACF,eAAO,MAAM,gBAAgB,iDAK3B,CAAA;AAIF,eAAO,MAAM,iBAAiB,sHAaxB,CAAA;AAGN,eAAO,MAAM,oBAAoB,0EAG/B,CAAA;AAKF,eAAO,MAAM,WAAW,wFAGtB,CAAA;AACF,eAAO,MAAM,WAAW,2FAGtB,CAAA;AAGF,eAAO,MAAM,UAAU,iDAGrB,CAAA;AAGF,eAAO,MAAM,eAAe,yDAG1B,CAAA;AAMF,eAAO,MAAM,cAAc,uDAqCzB,CAAA;AAGF,eAAO,MAAM,eAAe,qDAI1B,CAAA;AACF,eAAO,MAAM,gBAAgB,qDAK3B,CAAA;AAIF,eAAO,MAAM,mBAAmB,4GAI9B,CAAA;AAGF,eAAO,MAAM,iBAAiB,uDAG5B,CAAA;AACF,eAAO,MAAM,oBAAoB,2EAG/B,CAAA;AAEF,eAAO,MAAM,YAAY,uHAGvB,CAAA;AAiBF,eAAO,MAAM,oBAAoB,2GAiD/B,CAAA;AAGF,eAAO,MAAM,mBAAmB,8FAK9B,CAAA;AACF,eAAO,MAAM,mBAAmB,kFAO9B,CAAA"}