shaders 3.1.463 → 3.2.465

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

@@ -0,0 +1,53 @@
+import { GpuComputeNode } from '../contract';
+
+import * as d from 'typegpu/data';
+export declare const TRACKER_MAX = 64;
+export declare const TRACKER_TRAIL_LEN = 12;
+export declare const TRACKER_TRAIL_EVERY = 8;
+export declare const TRACKER_AABB_COL: number;
+export declare const trackHash: import('typegpu').TgpuFn<(x: d.F32) => d.F32>;
+/** Per-detect-mode feature score of one child sample (premultiplied RTT texel). */
+export declare function featureScoreFn(mode: string): import('typegpu').TgpuFn<(c: d.Vec4f) => d.F32>;
+/**
+ * Feature-grid kernel: one thread per grid cell, scoring the child at 4 sub-cell taps. The sim
+ * kernel scans this grid so every unlocked tracker always has a concrete target.
+ */
+export declare function buildFeatureGridKernel(scoreFn: ReturnType<typeof featureScoreFn>): import('typegpu').TgpuFn<(gx: d.U32, gy: d.U32) => d.Void>;
+/**
+ * Per-tracker pursuit kernel. One thread per tracker.
+ *
+ * TRACKING is mean-shift: the 7×7 window computes the affinity-weighted CENTROID of the content
+ * around the tracker and steps toward it — the tracker converges smoothly onto a feature, sticks
+ * to it, and rides it as it moves (argmax hopping jittered along edges and off them).
+ *
+ * VARIANCE: each tracker owns a preferred brightness BAND (re-rolled per generation). Affinity is
+ * closeness of the feature's score to that preference, not raw magnitude — so the population
+ * spreads across mid-tones and edges instead of dog-piling the absolute brightest highlight.
+ * `threshold` is the floor below which content doesn't count as a feature at all.
+ *
+ * LIFESPAN: a tracker retires after its (jittered) lifespan and reacquires elsewhere via the
+ * feature grid — constant, visible turnover. When unlocked it targets the grid cell that best
+ * matches its band (distance-discounted), or roams when the frame is empty.
+ *
+ * ATOMIC (irreducible): this kernel is a serial per-tracker STATE MACHINE — seed → mean-shift
+ * pursuit → global reacquire → crowd-hop → retire — whose stages all read and mutate the same
+ * row-state registers in order, then commit them in one trail-ring write pass. There is no
+ * shared-intermediate seam to split on without duplicating the state loads/stores; the composed
+ * slot is the per-mode `scoreFn` part it shares with the feature-grid kernel.
+ */
+export declare function buildPursuitKernel(mode: string, scoreFn?: ReturnType<typeof featureScoreFn>): import('typegpu').TgpuFn<(ti: d.U32) => d.Void>;
+/**
+ * The whole compute half as one part: feature-grid scoring pass → tracker pursuit sim.
+ * Both consume the child RTT, which binds LATE (bindInputs — it only exists after boundary
+ * allocation). `mode` is the compile-time detect prop value; the scalar slots are per-frame
+ * CPU prop names.
+ */
+export declare function createTrackerPursuitSim(slots: {
+    mode: string;
+    trackers: string;
+    agility: string;
+    threshold: string;
+    variance: string;
+    lifespan: string;
+}): GpuComputeNode;
+//# sourceMappingURL=trackerSim.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"trackerSim.d.ts","sourceRoot":"","sources":["../../../src/gpu/kit/trackerSim.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,EAAoB,cAAc,EAAC,MAAM,aAAa,CAAA;AAIlE,OAAO,KAAK,CAAC,MAAM,cAAc,CAAA;AAIjC,eAAO,MAAM,WAAW,KAAK,CAAA;AAC7B,eAAO,MAAM,iBAAiB,KAAK,CAAA;AACnC,eAAO,MAAM,mBAAmB,IAAI,CAAA;AACpC,eAAO,MAAM,gBAAgB,QAAwB,CAAA;AAiCrD,eAAO,MAAM,SAAS,+CAGpB,CAAA;AAEF,mFAAmF;AACnF,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,mDAc1C;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,8DAwBhF;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,mDAkM3F;AAMD;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE;IAC3C,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;CACnB,GAAG,cAAc,CAmDjB"}

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

@@ -0,0 +1,257 @@
+import { d } from './index';
+import { Expr } from '../contract';
+
+/**
+ * Reflect a screen UV across the mirror line through `center` at `angle`.
+ *
+ * Returns `vec3(finalMirroredUV.xy, shouldMirror)`. `shouldMirror` is
+ * `step(0, signedDistance)`, a hard 0/1 pick used to select between the near side
+ * (original UV) and the reflected side.
+ */
+export declare const mirrorReflect: import('typegpu').TgpuFn<(center: d.Vec2f, angle: d.F32, uv: d.Vec2f, aspect: d.F32) => d.Vec3f>;
+/**
+ * Mirror the UV across the canvas axes. `flipX`/`flipY` arrive as ±1 f32 uniforms
+ * (transformBoolean maps false → −1, NOT 0 — so they must be COMPARED, never used as a
+ * mix factor). The flip maps [0,1] onto [0,1], so no edge handling is ever needed.
+ */
+export declare const flipUV: import('typegpu').TgpuFn<(uv: d.Vec2f, flipX: d.F32, flipY: d.F32) => d.Vec2f>;
+/**
+ * Invert the bent-sheet projection for one screen UV.
+ *
+ * The sheet is FLAT inside |s| ≤ f (the falloff threshold) and parabolic beyond it:
+ * z = b·u² with u = (|s| − f)/(1 − f) — falloff 0 curves the whole frame (u = |s|), higher
+ * keeps the middle untouched and concentrates the bend at the ends. A sheet point at
+ * (s, t, z) projects to screen (s·k, t·k) with k = D/(D − z), so we must INVERT: given the
+ * screen coordinate find the sheet coordinate. Inside the flat region that's the identity;
+ * beyond it a quadratic in u — b·m'·u² + D(1−f)·u + D(f − m') = 0 (m' = |s'| screen) →
+ * u = (√(D²(1−f)² + 4·b·m'·D·(m'−f)) − D(1−f))/(2·b·m') — picked so the root collapses to
+ * u = (m'−f)/(1−f) as b → 0 (guarded by the linear fallback there). Across the axis the
+ * inverse is direct: t = t'·(D − z)/D, which is what makes edges swell in BOTH dimensions.
+ * When the discriminant goes negative (bend-away, past the sheet's visible silhouette) there
+ * is no sheet under that pixel — the coordinate is pushed far out of [0,1] so the edge mode
+ * decides (transparent by default). All math in aspect-corrected space so the axis is a true
+ * direction on any canvas.
+ */
+export declare const bendRemap: import('typegpu').TgpuFn<(strength: d.F32, falloff: d.F32, angle: d.F32, uv: d.Vec2f, aspect: d.F32) => d.Vec2f>;
+/**
+ * The bulge/pinch UV displacement around `center`. Negative displacement (positive
+ * `strength`, then negated) scales the delta down → magnification; positive → pinch.
+ */
+export declare const bulgeUV: import('typegpu').TgpuFn<(center: d.Vec2f, strength: d.F32, radius: d.F32, falloff: d.F32, uv: d.Vec2f, aspect: d.F32) => d.Vec2f>;
+/** Rotate the delta-from-center by an angle proportional to its distance — the twist map. */
+export declare const twirlUV: import('typegpu').TgpuFn<(center: d.Vec2f, intensity: d.F32, uv: d.Vec2f, aspect: d.F32) => d.Vec2f>;
+/**
+ * Radial mirrored-segment fold. The angle is measured with `atan2` (range [-π, π]) and the
+ * rotation offset can push it negative, so the segment wrap MUST use FLOORED mod
+ * (`x - m*floor(x/m)`) — `std.mod` is TRUNCATED (%), which differs from a floored `mod`
+ * for negative operands and would tear the fold near angle 0.
+ */
+export declare const kaleidoscopeUV: import('typegpu').TgpuFn<(center: d.Vec2f, segments: d.F32, angle: d.F32, uv: d.Vec2f, aspect: d.F32) => d.Vec2f>;
+/**
+ * Directional stretch: decompose the delta-from-center into a component parallel to the
+ * stretch axis and a perpendicular one; the parallel component is compressed by a
+ * strength-scaled factor that ramps in past the center along the axis (falloff controls
+ * the ramp width). strength/falloff carry internal scale factors (×100, ×75).
+ */
+export declare const stretchUV: import('typegpu').TgpuFn<(center: d.Vec2f, strength: d.F32, angle: d.F32, falloff: d.F32, uv: d.Vec2f, aspect: d.F32) => d.Vec2f>;
+/**
+ * Compute the wave phase for a screen UV: aspect-correct the centered UV, take the rotated-Y
+ * projection by `angle`, scale into [0, 2π) cycles by `frequency`, and offset by the
+ * accumulated animation time `t`.
+ */
+export declare const wavePhase: import('typegpu').TgpuFn<(uv: d.Vec2f, aspect: d.F32, angle: d.F32, frequency: d.F32, t: d.F32) => d.F32>;
+/**
+ * Displace the base UV along the rotated axis by the wave value (×strength×0.5, X
+ * aspect-divided back to UV space).
+ */
+export declare const waveApply: import('typegpu').TgpuFn<(uv: d.Vec2f, aspect: d.F32, angle: d.F32, strength: d.F32, wave: d.F32) => d.Vec2f>;
+export declare const waveformSine: import('typegpu').TgpuFn<(phase: d.F32) => d.F32>;
+export declare const waveformTriangle: import('typegpu').TgpuFn<(phase: d.F32) => d.F32>;
+export declare const waveformSquare: import('typegpu').TgpuFn<(phase: d.F32) => d.F32>;
+export declare const waveformSawtooth: import('typegpu').TgpuFn<(phase: d.F32) => d.F32>;
+export declare const waveformBounce: import('typegpu').TgpuFn<(phase: d.F32) => d.F32>;
+export declare const waveDistortSine: import('typegpu').TgpuFn<(uv: d.Vec2f, aspect: d.F32, angle: d.F32, frequency: d.F32, strength: d.F32, t: d.F32) => d.Vec2f>;
+export declare const waveDistortTriangle: import('typegpu').TgpuFn<(uv: d.Vec2f, aspect: d.F32, angle: d.F32, frequency: d.F32, strength: d.F32, t: d.F32) => d.Vec2f>;
+export declare const waveDistortSquare: import('typegpu').TgpuFn<(uv: d.Vec2f, aspect: d.F32, angle: d.F32, frequency: d.F32, strength: d.F32, t: d.F32) => d.Vec2f>;
+export declare const waveDistortSawtooth: import('typegpu').TgpuFn<(uv: d.Vec2f, aspect: d.F32, angle: d.F32, frequency: d.F32, strength: d.F32, t: d.F32) => d.Vec2f>;
+export declare const waveDistortBounce: import('typegpu').TgpuFn<(uv: d.Vec2f, aspect: d.F32, angle: d.F32, frequency: d.F32, strength: d.F32, t: d.F32) => d.Vec2f>;
+/**
+ * Rectangular → polar mapping (pre-blend). The angle (`atan2`, [-π, π]) is normalised to
+ * [0, 1] and scaled by `wrap`; the radius is scaled by `radius`.
+ */
+export declare const polarCoordsUV: import('typegpu').TgpuFn<(center: d.Vec2f, wrap: d.F32, radius: d.F32, uv: d.Vec2f, aspect: d.F32) => d.Vec2f>;
+/**
+ * Polar → rectangular mapping (pre-blend): treats the base UV as polar (`u`=angle,
+ * `v`=radius) and converts to rectangular space. NOTE: unlike the other distortions,
+ * `center.x` is NOT aspect-corrected here (the rectangular X is aspect-divided and added
+ * to the raw center.x).
+ */
+export declare const rectCoordsUV: import('typegpu').TgpuFn<(center: d.Vec2f, scale: d.F32, uv: d.Vec2f, aspect: d.F32) => d.Vec2f>;
+export declare const cornerPinSafeDiv: import('typegpu').TgpuFn<(n: d.F32, dv: d.F32) => d.F32>;
+export declare const cornerSideOf: import('typegpu').TgpuFn<(p: d.Vec2f, a: d.Vec2f, b: d.Vec2f) => d.F32>;
+export declare const cornerInsideTri: import('typegpu').TgpuFn<(p: d.Vec2f, a: d.Vec2f, b: d.Vec2f, c: d.Vec2f) => d.F32>;
+export declare const cornerProjectToDiagonal: import('typegpu').TgpuFn<(p: d.Vec2f, a: d.Vec2f, b: d.Vec2f, refSide: d.F32) => d.Vec2f>;
+export declare const cornerConvexify: import('typegpu').TgpuFn<(p: d.Vec2f, a: d.Vec2f, b: d.Vec2f, o: d.Vec2f) => d.Vec2f>;
+/**
+ * Square→quad homography (Heckbert), inverted analytically.
+ *
+ * Maps `coord` to the source coordinate to sample, treating the four pinned corners as a
+ * projective quad (a true corner-pin homography). Returns vec3(su, sv, front) — front (0/1)
+ * gates coverage on the visible side of the quad (den·det ≥ 0). `amount` blends each corner
+ * toward its neutral rectangle position. Corners arrive as the transformed props
+ * (transformPosition stores `(x, 1-y)`), so `1 - c.y` recovers the authored y. Corner order
+ * = [topLeft, topRight, bottomRight, bottomLeft].
+ */
+export declare const cornerPinSample: import('typegpu').TgpuFn<(coord: d.Vec2f, amount: d.F32, c0: d.Vec2f, c1: d.Vec2f, c2: d.Vec2f, c3: d.Vec2f) => d.Vec3f>;
+/**
+ * Inverse perspective projection (ray–plane intersection): rotate the plane in 3D
+ * (pan/tilt), with `fov` controlling perspective intensity and `zoom` scaling the sampled
+ * area. No aspect correction (samples in raw UV space). `max(divisor, 0.001)` guards the
+ * projective divides.
+ */
+export declare const perspectiveUV: import('typegpu').TgpuFn<(center: d.Vec2f, pan: d.F32, tilt: d.F32, fov: d.F32, zoom: d.F32, offset: d.Vec2f, uv: d.Vec2f) => d.Vec2f>;
+/** Rotate a UV around the (transformed) center by `angle`, aspect-corrected. */
+export declare const csRotateUV: import('typegpu').TgpuFn<(uv: d.Vec2f, aspect: d.F32, center: d.Vec2f, angle: d.F32) => d.Vec2f>;
+/**
+ * Per-ring blended rotation: hash each ring's static + animated rotation (`legacySinHash11`,
+ * the shared sin-fract hash), blend adjacent rings along the SHORTEST angular path (wrap the
+ * difference to [-π, π] with a FLOORED mod so the blend never spirals through extra
+ * rotations), smoothstep across the ring boundary, then apply {@link csRotateUV}.
+ */
+export declare const concentricSpinUV: import('typegpu').TgpuFn<(center: d.Vec2f, intensity: d.F32, rings: d.F32, smoothness: d.F32, seed: d.F32, speedRandomness: d.F32, animTime: d.F32, uv: d.Vec2f, aspect: d.F32) => d.Vec2f>;
+/**
+ * Constant-speed flow through drifting 3D noise: three noise layers each drift through a 3D
+ * `mxNoiseFloat3` field at different rates; the noise value is used as a flow ANGLE (not a
+ * magnitude), so the combined + normalised flow has constant speed and displaces the base
+ * UV by `strength` (X aspect-divided back to UV space). `time` (flow drift) and
+ * `evolutionTime` (z-axis pattern reshape) are two independent animated clocks.
+ */
+export declare const flowFieldUV: import('typegpu').TgpuFn<(uv: d.Vec2f, aspect: d.F32, scale: d.F32, strength: d.F32, time: d.F32, evolutionTime: d.F32) => d.Vec2f>;
+/**
+ * Slide alternating strips out of the frame — the "shredder" transition. A directional
+ * coordinate dices the frame into `sliceCount` strips; each strip's lookup slides ALONG
+ * the strip (perpendicular to the dicing direction), alternating ±, by up to just over the
+ * frame's full extent — at progress 1 every lookup is out of bounds, and transparent edge
+ * handling clips the vacated space.
+ */
+export declare const sliceWipeUV: import('typegpu').TgpuFn<(uv: d.Vec2f, aspect: d.F32, angleDeg: d.F32, sliceCount: d.F32, progress: d.F32) => d.Vec2f>;
+/**
+ * Deterministic bar geometry: rotate the UV into bar-space, shift the perpendicular axis by
+ * `offset`, un-rotate, un-center back to UV space.
+ */
+export declare const barSampleUV: import('typegpu').TgpuFn<(uv: d.Vec2f, aspect: d.F32, angle: d.F32, offset: d.F32) => d.Vec2f>;
+/**
+ * Full per-bar displacement: which bar this pixel belongs to (hard-edged), its static +
+ * animated hash offset (`legacySinHash11`, the shared sin-fract hash), then the
+ * deterministic {@link barSampleUV}.
+ */
+export declare const barShiftUV: import('typegpu').TgpuFn<(count: d.F32, angle: d.F32, intensity: d.F32, seed: d.F32, animTime: d.F32, uv: d.Vec2f, aspect: d.F32) => d.Vec2f>;
+/** Snap a UV to the centre of its distortion-grid cell (aspect-corrected cell counts). */
+export declare const gridCellSnap: import('typegpu').TgpuFn<(uv: d.Vec2f, gridSize: d.F32, aspect: d.F32) => d.Vec2f>;
+/** Offset a UV by the clamped displacement (±0.1 clamp). */
+export declare const gridDistortOffsetUV: import('typegpu').TgpuFn<(uv: d.Vec2f, disp: d.Vec2f) => d.Vec2f>;
+/** The intensity-scaled, clamped displaced UV (±0.15 clamp) for a liquid displacement field. */
+export declare const liquifyOffsetUV: import('typegpu').TgpuFn<(uv: d.Vec2f, disp: d.Vec2f, intensity: d.F32) => d.Vec2f>;
+/** twoAxis — source RED drives horizontal, GREEN drives vertical (0.5 = neutral). */
+export declare const dmDisplaceRG: import('typegpu').TgpuFn<(uv: d.Vec2f, src: d.Vec4f, aspect: d.F32, amount: d.F32) => d.Vec2f>;
+/** directional — source LUMINANCE pushes along a fixed angle (0.5 = neutral). */
+export declare const dmDisplaceLuminance: import('typegpu').TgpuFn<(uv: d.Vec2f, src: d.Vec4f, aspect: d.F32, amount: d.F32, angleDeg: d.F32) => d.Vec2f>;
+export declare const FlutedGeom: d.WgslStruct<{
+    refractedUV: d.Vec2f;
+    chrOff: d.Vec2f;
+    slope: d.F32;
+}>;
+export declare const flutedGlassGeom: import('typegpu').TgpuFn<(uv: d.Vec2f, aspect: d.F32, t: d.F32, angleDeg: d.F32, frequency: d.F32, softness: d.F32, waveAmp: d.F32, waveFreq: d.F32, refraction: d.F32, aberration: d.F32, shapeParams: d.Vec3f) => d.WgslStruct<{
+    refractedUV: d.Vec2f;
+    chrOff: d.Vec2f;
+    slope: d.F32;
+}>>;
+/**
+ * Blinn-Phong specular with Schlick-Fresnel weighting over a 1D surface slope —
+ * N = (slope, sqrt(1-slope²)), light half-vector from `lightAngleDeg` (0 = head-on,
+ * 90 = grazing). `softness` spreads the peak (shininess = exp2(8 − softness·7)).
+ */
+export declare const blinnHighlight: import('typegpu').TgpuFn<(slope: d.F32, lightAngleDeg: d.F32, intensity: d.F32, softness: d.F32) => d.F32>;
+export declare const PagePeelGeom: d.WgslStruct<{
+    curlUV: d.Vec2f;
+    theta: d.F32;
+    distPastCrease: d.F32;
+    distIntoPeel: d.F32;
+    flatReach: d.F32;
+    peelReach: d.F32;
+    foldBlend: d.F32;
+    showCurl: d.F32;
+}>;
+export declare const pagePeelGeom: import('typegpu').TgpuFn<(uv: d.Vec2f, aspect: d.F32, cornerX: d.F32, cornerY: d.F32, oppX: d.F32, oppY: d.F32, amount: d.F32, radius: d.F32) => d.WgslStruct<{
+    curlUV: d.Vec2f;
+    theta: d.F32;
+    distPastCrease: d.F32;
+    distIntoPeel: d.F32;
+    flatReach: d.F32;
+    peelReach: d.F32;
+    foldBlend: d.F32;
+    showCurl: d.F32;
+}>>;
+/** Shade the crook of a curl near its crease, easing to full brightness at the lip. */
+export declare const curlShade: import('typegpu').TgpuFn<(theta: d.F32, shading: d.F32) => d.F32>;
+/**
+ * Soft specular sheen band up the curl: a Gaussian in normalized fold angle, centred toward
+ * the lip (0.65 of the quarter turn), with `softness` widening the band.
+ */
+export declare const curlSheen: import('typegpu').TgpuFn<(theta: d.F32, intensity: d.F32, softness: d.F32) => d.F32>;
+/**
+ * Contact-shadow strength over a lift `amount`: sharp+dark when the lip first lifts
+ * (smoothstep in over the first 4%), softening + fading to 0 by amount 1.
+ */
+export declare const liftShadowStrength: import('typegpu').TgpuFn<(amount: d.F32) => d.F32>;
+/**
+ * One-sided contact-shadow falloff: full at `dist` 0, easing to nothing by `reach`
+ * (`exponent` shapes the ease), zero on the negative side.
+ */
+export declare const shadowFalloff: import('typegpu').TgpuFn<(dist: d.F32, reach: d.F32, exponent: d.F32) => d.F32>;
+/** Shade multiplier on the flat page a lifted lip overhangs (1 = unshadowed). */
+export declare const overhangShade: import('typegpu').TgpuFn<(dist: d.F32, reach: d.F32, amount: d.F32, shadow: d.F32) => d.F32>;
+/** Shadow alpha cast onto the surface a peel reveals. */
+export declare const revealShadow: import('typegpu').TgpuFn<(dist: d.F32, reach: d.F32, amount: d.F32, shadow: d.F32) => d.F32>;
+/**
+ * Composite (back to front): revealed-surface cast shadow, flat page (shaded under the
+ * overhang), then the peeling lip (crook-shaded + sheened) on top. Result is premultiplied
+ * — the caller unpremultiplies.
+ */
+export declare const pagePeelCompose: import('typegpu').TgpuFn<(curlSample: d.Vec4f, flatSample: d.Vec4f, curlBright: d.F32, spec: d.F32, flatShade: d.F32, peelAlpha: d.F32, foldBlend: d.F32, showCurl: d.F32) => d.Vec4f>;
+/**
+ * Sphere-surface geometry: the bulged sample UV, the sphere boundary coverage, and the
+ * surface normal — the inputs the shading parts work from. The center double-flip recovers
+ * the authored y; z = sqrt(1 − r²) sphere surface; `depth` scales the bulge. Pure — no
+ * texture. `center` is the transformed (x, 1−y) prop value.
+ */
+export declare const SphereBulge: d.WgslStruct<{
+    uv: d.Vec2f;
+    coverage: d.F32;
+    normal: d.Vec3f;
+}>;
+export declare const sphereBulge: import('typegpu').TgpuFn<(uv: d.Vec2f, viewport: d.Vec2f, center: d.Vec2f, radius: d.F32, depth: d.F32) => d.WgslStruct<{
+    uv: d.Vec2f;
+    coverage: d.F32;
+    normal: d.Vec3f;
+}>>;
+/**
+ * Directional fresnel rim light over a surface normal: strongest at grazing edges
+ * (fresnel power hardening as `softness` drops), biased toward the light direction.
+ * `lightPos` is the transformed (x, 1−y) position prop.
+ */
+export declare const rimLight: import('typegpu').TgpuFn<(normal: d.Vec3f, lightPos: d.Vec2f, intensity: d.F32, softness: d.F32) => d.F32>;
+/** Add a tinted rim to a straight-alpha sample and gate its alpha by a coverage mask. Pure. */
+export declare const rimComposite: import('typegpu').TgpuFn<(straight: d.Vec4f, lightColor: d.Vec3f, rim: d.F32, coverage: d.F32) => d.Vec4f>;
+/**
+ * Chromatic three-tap split: sample at `uv ± offset` for red/blue and at `uv` for green,
+ * recombining per channel (alpha from the centre tap).
+ */
+export declare function rgbSplitTaps(sample: (uv: Expr) => Expr, uv: Expr, offset: Expr): Expr;
+/**
+ * Compile-time edge-mode sampler that CLIPS on the transparent mode: out-of-bounds zeroes
+ * the WHOLE premultiplied vec4 (coverage), so edge-clamped RGB can't leak through a
+ * multi-tap recombination. The other modes enforce the UV contract (stretch = clamp).
+ */
+export declare function edgeClipSample(sample: (uv: Expr) => Expr, uv: Expr, edgeMode: number): Expr;
+//# sourceMappingURL=warpMaps.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"warpMaps.d.ts","sourceRoot":"","sources":["../../../src/gpu/kit/warpMaps.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,EAAO,CAAC,EAAM,MAAM,SAAS,CAAA;AAMpC,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,aAAa,CAAA;AAIrC;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,kGAqBpB,CAAA;AAIN;;;;GAIG;AACH,eAAO,MAAM,MAAM,gFAKjB,CAAA;AAcF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,SAAS,kHA0ChB,CAAA;AAIN;;;GAGG;AACH,eAAO,MAAM,OAAO,oIAiCd,CAAA;AAIN,6FAA6F;AAC7F,eAAO,MAAM,OAAO,sGAalB,CAAA;AAIF;;;;;GAKG;AACH,eAAO,MAAM,cAAc,mHAyBrB,CAAA;AAIN;;;;;GAKG;AACH,eAAO,MAAM,SAAS,mIA4BhB,CAAA;AAIN;;;;GAIG;AACH,eAAO,MAAM,SAAS,2GAUhB,CAAA;AAEN;;;GAGG;AACH,eAAO,MAAM,SAAS,+GAUhB,CAAA;AAIN,eAAO,MAAM,YAAY,mDAGvB,CAAA;AAEF,eAAO,MAAM,gBAAgB,mDAI3B,CAAA;AAEF,eAAO,MAAM,cAAc,mDAIzB,CAAA;AAEF,eAAO,MAAM,gBAAgB,mDAI3B,CAAA;AAEF,eAAO,MAAM,cAAc,mDAGzB,CAAA;AAKF,eAAO,MAAM,eAAe,8HAKtB,CAAA;AAEN,eAAO,MAAM,mBAAmB,8HAK1B,CAAA;AAEN,eAAO,MAAM,iBAAiB,8HAKxB,CAAA;AAEN,eAAO,MAAM,mBAAmB,8HAK1B,CAAA;AAEN,eAAO,MAAM,iBAAiB,8HAKxB,CAAA;AAIN;;;GAGG;AACH,eAAO,MAAM,aAAa,gHAcpB,CAAA;AAEN;;;;;GAKG;AACH,eAAO,MAAM,YAAY,kGASnB,CAAA;AAQN,eAAO,MAAM,gBAAgB,0DAG3B,CAAA;AAGF,eAAO,MAAM,YAAY,yEAOvB,CAAA;AAGF,eAAO,MAAM,eAAe,qFAQ1B,CAAA;AAGF,eAAO,MAAM,uBAAuB,2FAQlC,CAAA;AAIF,eAAO,MAAM,eAAe,uFAK1B,CAAA;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe,0HAwDtB,CAAA;AAIN;;;;;GAKG;AACH,eAAO,MAAM,aAAa,wIA+BpB,CAAA;AAIN,gFAAgF;AAChF,eAAO,MAAM,UAAU,kGAWjB,CAAA;AAEN;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,6LAmCvB,CAAA;AAIN;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,qIA2ClB,CAAA;AAIN;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,wHAoBlB,CAAA;AAIN;;;GAGG;AACH,eAAO,MAAM,WAAW,gGAkBlB,CAAA;AAEN;;;;GAIG;AACH,eAAO,MAAM,UAAU,+IAsBjB,CAAA;AAIN,0FAA0F;AAC1F,eAAO,MAAM,YAAY,oFAQvB,CAAA;AAEF,4DAA4D;AAC5D,eAAO,MAAM,mBAAmB,mEAK9B,CAAA;AAEF,gGAAgG;AAChG,eAAO,MAAM,eAAe,qFAM1B,CAAA;AAWF,qFAAqF;AACrF,eAAO,MAAM,YAAY,gGAMvB,CAAA;AAEF,iFAAiF;AACjF,eAAO,MAAM,mBAAmB,iHAS9B,CAAA;AAQF,eAAO,MAAM,UAAU;;;;EAIrB,CAAA;AAIF,eAAO,MAAM,eAAe;;;;GA8B1B,CAAA;AAEF;;;;GAIG;AACH,eAAO,MAAM,cAAc,4GAarB,CAAA;AASN,eAAO,MAAM,YAAY;;;;;;;;;EASvB,CAAA;AAEF,eAAO,MAAM,YAAY;;;;;;;;;GA2CnB,CAAA;AAEN,uFAAuF;AACvF,eAAO,MAAM,SAAS,mEAIpB,CAAA;AAEF;;;GAGG;AACH,eAAO,MAAM,SAAS,sFAMpB,CAAA;AAEF;;;GAGG;AACH,eAAO,MAAM,kBAAkB,oDAG7B,CAAA;AAEF;;;GAGG;AACH,eAAO,MAAM,aAAa,iFAGxB,CAAA;AAEF,iFAAiF;AACjF,eAAO,MAAM,aAAa,8FAIxB,CAAA;AAEF,yDAAyD;AACzD,eAAO,MAAM,YAAY,8FAIvB,CAAA;AAEF;;;;GAIG;AACH,eAAO,MAAM,eAAe,wLAUtB,CAAA;AAIN;;;;;GAKG;AACH,eAAO,MAAM,WAAW;;;;EAItB,CAAA;AAEF,eAAO,MAAM,WAAW;;;;GAuBlB,CAAA;AAEN;;;;GAIG;AACH,eAAO,MAAM,QAAQ,4GAaf,CAAA;AAEN,+FAA+F;AAC/F,eAAO,MAAM,YAAY,4GAQnB,CAAA;AAIN;;;GAGG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,IAAI,KAAK,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,GAAG,IAAI,CAKrF;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,IAAI,KAAK,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAK3F"}

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

@@ -0,0 +1,70 @@
+import { d } from './index';
+import { GpuFragmentParams, KitTexture } from '../contract';
+import { ComputeStep } from '../compute';
+
+export interface WaveFieldKernels {
+    resolution: number;
+    propagateLayout: ReturnType<typeof buildPropagateLayout>;
+    gradientLayout: ReturnType<typeof buildGradientLayout>;
+    /** Callable inside a `'use gpu'` wrapper; resolvable via `tgpu.resolve` in tests. */
+    propagateKernel: (cx: number, cy: number) => void;
+    gradientKernel: (cx: number, cy: number) => void;
+}
+declare function buildPropagateLayout(cellCount: number): import('typegpu').TgpuBindGroupLayout<{
+    readBuf: {
+        storage: d.WgslArray<d.F32>;
+        access: "readonly";
+    };
+    writeBuf: {
+        storage: d.WgslArray<d.F32>;
+        access: "mutable";
+    };
+    params: {
+        uniform: d.WgslStruct<{
+            cursorX: d.F32;
+            cursorY: d.F32;
+            cursorSpeed: d.F32;
+            dt: d.F32;
+            damping: d.F32;
+            radius: d.F32;
+            aspect: d.F32;
+        }>;
+    };
+}>;
+declare function buildGradientLayout(cellCount: number): import('typegpu').TgpuBindGroupLayout<{
+    srcBuf: {
+        storage: d.WgslArray<d.F32>;
+        access: "readonly";
+    };
+    dispTex: {
+        storageTexture: d.WgslStorageTexture2d<"rgba16float", string>;
+    };
+}>;
+/** Layouts + kernels for one grid resolution. Memoized; $name carries the resolution key. */
+export declare function buildWaveFieldKernels(resolution: number): WaveFieldKernels;
+export interface WaveFieldConfig {
+    resolution: number;
+    /** Prop name read per frame as the damping value (std `op.wave({damping})`). */
+    dampingProp: string;
+    /** Prop name read per frame as the brush radius (std `op.splat({radius})`). */
+    radiusProp: string;
+    /** UI radius → field-space radius scale. */
+    radiusScale: number;
+    /** Pointer-speed clamp (std `pointerSpeed({max})`). */
+    speedMax: number;
+}
+export interface WaveFieldSim {
+    /** The RG displacement-gradient texture (a registered compute texture). */
+    displacement: KitTexture;
+    getComputeNodes: (frameParams: unknown) => ComputeStep[] | null;
+}
+/**
+ * The per-instance wave-field runtime: two ping-pong height-field state buffers
+ * (createStateBuffer; WebGPU zero-inits → the field starts flat), two dispatches/frame —
+ * propagation (+ cursor injection) then the gradient pass writing the RG displacement texture.
+ * Child-independent (a pure wave field), so there is no bindInputs. Returns null when the
+ * composition has no GPU root (GPU-free resolve/tests fall back to zero displacement).
+ */
+export declare function createWaveFieldSim(params: GpuFragmentParams, config: WaveFieldConfig): WaveFieldSim | null;
+export {};
+//# sourceMappingURL=waves.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"waves.d.ts","sourceRoot":"","sources":["../../../src/gpu/kit/waves.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,EAAO,CAAC,EAAM,MAAM,SAAS,CAAA;AACpC,OAAO,KAAK,EAAC,iBAAiB,EAAE,UAAU,EAAC,MAAM,aAAa,CAAA;AAC9D,OAAO,EAA8D,KAAK,WAAW,EAAC,MAAM,YAAY,CAAA;AAgBxG,MAAM,WAAW,gBAAgB;IAC7B,UAAU,EAAE,MAAM,CAAA;IAClB,eAAe,EAAE,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAA;IACxD,cAAc,EAAE,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAA;IACtD,qFAAqF;IACrF,eAAe,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,KAAK,IAAI,CAAA;IACjD,cAAc,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,KAAK,IAAI,CAAA;CACnD;AAED,iBAAS,oBAAoB,CAAC,SAAS,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;GAQ9C;AAED,iBAAS,mBAAmB,CAAC,SAAS,EAAE,MAAM;;;;;;;;GAK7C;AAID,6FAA6F;AAC7F,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,MAAM,GAAG,gBAAgB,CA8D1E;AAED,MAAM,WAAW,eAAe;IAC5B,UAAU,EAAE,MAAM,CAAA;IAClB,gFAAgF;IAChF,WAAW,EAAE,MAAM,CAAA;IACnB,+EAA+E;IAC/E,UAAU,EAAE,MAAM,CAAA;IAClB,4CAA4C;IAC5C,WAAW,EAAE,MAAM,CAAA;IACnB,uDAAuD;IACvD,QAAQ,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,WAAW,YAAY;IACzB,2EAA2E;IAC3E,YAAY,EAAE,UAAU,CAAA;IACxB,eAAe,EAAE,CAAC,WAAW,EAAE,OAAO,KAAK,WAAW,EAAE,GAAG,IAAI,CAAA;CAClE;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,iBAAiB,EAAE,MAAM,EAAE,eAAe,GAAG,YAAY,GAAG,IAAI,CAyE1G"}

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

@@ -30,7 +30,9 @@ export { defineSdfShapeShader, type SdfShapeShaderSpec, type SdfShapeBounds } fr
 export { definePointwiseFilter, isFilterIdentity, type PointwiseFilterConfig, type FilterBody, type FilterIdentity, type FilterParams, } from './scaffolds/pointwiseFilter';
 export { defineRttFilter, type RttFilterConfig, type RttFilterParams } from './scaffolds/rttFilter';
 export { createAgentSystem, readAgentFrame, makeCpuValueGetter, resolveDeviceTier, resolveRenderRes, clampAgentCount, energyCoverageAlpha, integrateSemiImplicitEuler, worldSplatWindow, texelSplatWindow, SplatWindow, SIZE_REF_RES, FIXED_POINT_GAINS, R2_ALPHA, R3_ALPHA, type AgentSystem, type AgentSystemConfig, type AgentPipelineSpec, type AgentThreads, type AgentFrame, type AgentFrameParams, type DeviceTier, } from './scaffolds/agentSystem';
-export { buildStableFluidsKernels, buildFluidOutputKernel, createStableFluidsPasses, neighbourIndex, type StableFluidsOptions, type StableFluidsKernels, type StableFluidsPasses, type FluidSolverLayout, type FluidOutputLayout, type FluidSolveParams, type FluidDyeParams, type FluidStorageTexture, type FluidBoundary, type FluidDyeMode, } from './scaffolds/fluids';
+export { buildStableFluidsKernels, buildFluidOutputKernel, createStableFluidsPasses, createFluidKernelPass, buildVelocityImpulseKernel, buildBrushSplatKernel, buildEmitterSplatKernel, buildNoiseFieldInitKernel, buildTrigTurbulenceKernel, buildNoiseRestoreKernel, makeShapeMaskSet, neighbourIndex, type StableFluidsOptions, type StableFluidsKernels, type StableFluidsPasses, type FluidSolverLayout, type FluidOutputLayout, type FluidSolveParams, type FluidDyeParams, type FluidStorageTexture, type FluidBoundary, type FluidDyeMode, } from './scaffolds/fluids';
+export { buildSpectralHeightField, makeWaveEquationKernel, makeHeightFieldMarchKernel, createHeightFieldParamsUniform, createWaveStateBuffers, createKernelPass, waveEquationLayout, heightFieldMarchLayout, WAVE_GRID, WAVE_HALFEXTENT, CURSOR_WAVE_BOUND, WAVE_DECAY, WAVE_SETTLE_MS, MARCH_FAR, HEIGHT_SLAB_PAD, HEIGHT_FIELD_STATE_FORMAT, type HeightFieldMarchOptions, type HeightFieldParamsInput, type HeightFieldParamsUniform, } from './scaffolds/heightField';
+export { createGridKernelPass, buildGrayScottStep, buildScatterSeedKernel, buildPairPublishKernel, buildOddEvenSortSet, makeAspectBrushWeight, buildFeedbackTrailStep, frameDiffMask, hueRotateTurns, buildMacroblockAdvectKernel, buildBlockQuantizeGraph, makeJpegBlockRgb, flowDirectionColor, type GridKernel, type GrayScottOptions, type ReactionDriveOptions, type OddEvenSortOptions, type FeedbackTrailOptions, type MacroblockAdvectOptions, type BlockQuantizeOptions, } from './scaffolds/gridKernels';
 export { gaussianBrushSq, gaussianBrushShiftedSq, gaussianBrushRaw, gaussianBrushShifted, gaussianBrushFnSq, gaussianBrushFn, gaussianBrushShiftedSqFn, gaussianBrushShiftedFn, type GaussianBrushOptions, } from './scaffolds/simShared';
 export { legacySinHash11 } from './scaffolds/shared';
 /**

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

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