shaders 3.1.463 → 3.2.464

package/dist/core/std/effects/edgeGlow.d.ts

@@ -0,0 +1,64 @@
+import { d } from '../../gpu/kit/index';
+
+/** Double heartbeat: two staggered sine spikes (the paper's beat()). */
+export declare const heartbeatPulse: import('typegpu').TgpuFn<(animTime: d.F32) => d.F32>;
+/**
+ * The luminous band + smoke over a shape's distance field. Returns `vec2(border, angle01)`:
+ *   border  — the band mask around the silhouette (hard ring at softness 0, wide gradient at 1),
+ *             with the noisy smoke already added and the whole thing clamped to [0,1]
+ *   angle01 — polar angle of the fragment around the shape centre, in turns
+ * `beat` is the caller-computed heartbeatPulse(animTime), shared with orbitSpotsAccum.
+ */
+export declare const edgeGlowBand: import('typegpu').TgpuFn<(fieldRaw: d.F32, sdfUV: d.Vec2f, viewport: d.Vec2f, scale: d.F32, thickness: d.F32, softness: d.F32, smokeSize: d.F32, smokeAmt: d.F32, animTime: d.F32, pulse: d.F32, beat: d.F32) => d.Vec2f>;
+/**
+ * Sector accumulation for ONE color's orbiting spots. Up to 5 spots orbit the band with
+ * hash-decorrelated speeds, directions, phases and sizes; each spot is an angular window ×
+ * breathing mask × border × intensity. Returns `vec2(overSector, addSector)`: the
+ * Porter-Duff-accumulated coverage (blend path) and the raw additive sum (bloom path). Spots
+ * are runtime-gated by `spotsF`. `beat` is the caller-computed heartbeatPulse(animTime) — the
+ * caller evaluates it ONCE per pixel and shares it across every per-color unrolled call.
+ */
+export declare const orbitSpotsAccum: import('typegpu').TgpuFn<(angle01: d.F32, border: d.F32, animTime: d.F32, beat: d.F32, spotsF: d.F32, spotSize: d.F32, pulse: d.F32, intensity: d.F32, softness: d.F32, seed: d.F32, colorIdxF: d.F32) => d.Vec2f>;
+export declare const EdgeGlowAccum: d.WgslStruct<{
+    rgb: d.Vec3f;
+    w: d.F32;
+    ba: d.F32;
+    ac: d.Vec3f;
+    aa: d.F32;
+}>;
+export declare const edgeGlowAccumZero: import('typegpu').TgpuFn<() => d.WgslStruct<{
+    rgb: d.Vec3f;
+    w: d.F32;
+    ba: d.F32;
+    ac: d.Vec3f;
+    aa: d.F32;
+}>>;
+export declare function edgeGlowAccumColorFor(mode: number): import('typegpu').TgpuFn<(st: d.WgslStruct<{
+    rgb: d.Vec3f;
+    w: d.F32;
+    ba: d.F32;
+    ac: d.Vec3f;
+    aa: d.F32;
+}>, color: d.Vec4f, sectors: d.Vec2f) => d.WgslStruct<{
+    rgb: d.Vec3f;
+    w: d.F32;
+    ba: d.F32;
+    ac: d.Vec3f;
+    aa: d.F32;
+}>>;
+/** One color from the packed stops uniform (positions ignored — the stops are a color LIST).
+ *  Copied component-wise: TypeGPU forbids returning references to fn arguments. */
+export declare const colorAtIndex: import('typegpu').TgpuFn<(colors: d.WgslArray<d.Vec4f>, idx: d.F32) => d.Vec4f>;
+/**
+ * Final composite — the `bloom = 4·bloom` blend/add extrapolation, over a TRANSPARENT
+ * background. The blend path premultiplies the space-blended color by its coverage. Returns
+ * STRAIGHT rgba.
+ */
+export declare const edgeGlowCompose: import('typegpu').TgpuFn<(st: d.WgslStruct<{
+    rgb: d.Vec3f;
+    w: d.F32;
+    ba: d.F32;
+    ac: d.Vec3f;
+    aa: d.F32;
+}>, bloom: d.F32) => d.Vec4f>;
+//# sourceMappingURL=edgeGlow.d.ts.map

package/dist/core/std/effects/edgeGlow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edgeGlow.d.ts","sourceRoot":"","sources":["../../../src/std/effects/edgeGlow.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAO,CAAC,EAAqC,MAAM,qBAAqB,CAAA;AAS/E,wEAAwE;AACxE,eAAO,MAAM,cAAc,sDAMzB,CAAA;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,2NAmCvB,CAAA;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,oNAqC1B,CAAA;AAMF,eAAO,MAAM,aAAa;;;;;;EAAwE,CAAA;AAElG,eAAO,MAAM,iBAAiB;;;;;;GAG5B,CAAA;AAuBF,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM;;;;;;;;;;;;IAOjD;AAED;mFACmF;AACnF,eAAO,MAAM,YAAY,iFAIvB,CAAA;AAEF;;;;GAIG;AACH,eAAO,MAAM,eAAe;;;;;;6BAQ1B,CAAA"}

package/dist/core/std/effects/fracture.d.ts

@@ -0,0 +1,55 @@
+import { GpuComputeNode } from '../../gpu/contract';
+import { d } from '../../gpu/kit/index';
+
+interface VoronoiGraph {
+    layout: ReturnType<typeof makeVoronoiGraph>['layout'];
+    kernel: ReturnType<typeof makeVoronoiGraph>['kernel'];
+}
+declare function makeVoronoiGraph(count: number, size: number): {
+    layout: import('typegpu').TgpuBindGroupLayout<{
+        cellPos: {
+            storage: d.WgslArray<d.F32>;
+            access: "readonly";
+        };
+        voronoiTex: {
+            storageTexture: d.WgslStorageTexture2d<"rgba16float", string>;
+        };
+    }>;
+    kernel: import('typegpu').TgpuFn<(cx: d.U32, cy: d.U32) => d.Void>;
+};
+/** The per-(count, size) Voronoi nearest-2 graph (both baked as compile-time constants). */
+export declare function voronoiNearest2Graph(count: number, size: number): VoronoiGraph;
+export declare function cellLaneUVFor(laneWidth: number): import('typegpu').TgpuFn<(idx: d.F32, field: d.F32) => d.Vec2f>;
+export declare const CrackGeom: d.WgslStruct<{
+    crackIntensity: d.F32;
+    edgeNormal: d.Vec2f;
+    displacedUV: d.Vec2f;
+    disp: d.Vec2f;
+}>;
+export declare const crackGeom: import('typegpu').TgpuFn<(uv: d.Vec2f, nPosX: d.F32, nPosY: d.F32, sPosX: d.F32, sPosY: d.F32, dispX: d.F32, dispY: d.F32, crackWidth: d.F32) => d.WgslStruct<{
+    crackIntensity: d.F32;
+    edgeNormal: d.Vec2f;
+    displacedUV: d.Vec2f;
+    disp: d.Vec2f;
+}>>;
+/** Per-channel refracted sample UV (channel −1/0/+1 → chromatic split). */
+export declare const crackRefractUV: import('typegpu').TgpuFn<(displacedUV: d.Vec2f, edgeNormal: d.Vec2f, crackIntensity: d.F32, refractionStrength: d.F32, chromaticSplit: d.F32, channel: d.F32) => d.Vec2f>;
+/** Final composite: crack refraction blend + tilted-shard lighting (pre-unpremultiply). */
+export declare const crackShardCompose: import('typegpu').TgpuFn<(normalColor: d.Vec4f, rFinal: d.Vec4f, gFinal: d.Vec4f, bFinal: d.Vec4f, crackIntensity: d.F32, disp: d.Vec2f, shardLighting: d.F32) => d.Vec4f>;
+/**
+ * The Voronoi region field as a compute part: nearest + second-nearest cell ID per pixel,
+ * precomputed on the GPU and re-dispatched only when the seed prop changes (avoiding a
+ * many-megaop CPU stall). Cell positions live in a small storage buffer regenerated CPU-side by
+ * `sites(seed)` on seed change; between changes the field is static and the frame program
+ * dispatches nothing. Published under `output`.
+ */
+export declare function voronoiRegionField(opts: {
+    count: number;
+    size: number;
+    sites: (seed: number) => Float32Array;
+    seedProp: string;
+    seedDefault: number;
+    output: string;
+}): GpuComputeNode;
+export {};
+//# sourceMappingURL=fracture.d.ts.map

package/dist/core/std/effects/fracture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fracture.d.ts","sourceRoot":"","sources":["../../../src/std/effects/fracture.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAC,cAAc,EAAoB,MAAM,oBAAoB,CAAA;AAEzE,OAAO,EAAO,CAAC,EAAM,MAAM,qBAAqB,CAAA;AAIhD,UAAU,YAAY;IAClB,MAAM,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC,QAAQ,CAAC,CAAA;IACrD,MAAM,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC,QAAQ,CAAC,CAAA;CACxD;AAED,iBAAS,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;;;;;;;;;;;EAoCpD;AAID,4FAA4F;AAC5F,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,YAAY,CAQ9E;AAUD,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,mEAO9C;AAGD,eAAO,MAAM,SAAS;;;;;EAKpB,CAAA;AAEF,eAAO,MAAM,SAAS;;;;;GAqBpB,CAAA;AAEF,2EAA2E;AAC3E,eAAO,MAAM,cAAc,2KAS1B,CAAA;AAMD,2FAA2F;AAC3F,eAAO,MAAM,iBAAiB,4KAe7B,CAAA;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE;IACrC,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,YAAY,CAAA;IACrC,QAAQ,EAAE,MAAM,CAAA;IAChB,WAAW,EAAE,MAAM,CAAA;IACnB,MAAM,EAAE,MAAM,CAAA;CACjB,GAAG,cAAc,CA2CjB"}

package/dist/core/std/effects/instances.d.ts

@@ -0,0 +1,84 @@
+import { Expr, GpuFragmentParams } from '../../gpu/contract';
+import { PropRef } from '../values';
+
+export interface GridSlots {
+    columns: PropRef;
+    rows: PropRef;
+    gapX: PropRef;
+    gapY: PropRef;
+    stagger: PropRef;
+    /** Structural: alternate-mirror mode ('none' | flip-x | flip-y | both). */
+    flip: PropRef;
+}
+export interface RadialSlots {
+    count: PropRef;
+    radius: PropRef;
+    startAngle: PropRef;
+    sweep: PropRef;
+    faceCenter: PropRef;
+}
+export interface LineSlots {
+    count: PropRef;
+    direction: PropRef;
+    spacing: PropRef;
+}
+export type PlacementSpec = {
+    kind: 'grid';
+    slots: GridSlots;
+} | {
+    kind: 'radial';
+    slots: RadialSlots;
+} | {
+    kind: 'line';
+    slots: LineSlots;
+};
+export declare const grid: (slots: GridSlots) => PlacementSpec;
+export declare const radial: (slots: RadialSlots) => PlacementSpec;
+export declare const line: (slots: LineSlots) => PlacementSpec;
+/** Pick a placement member by a structural mode prop — only the active member emits. */
+export interface PlacementPick {
+    mode: PropRef;
+    members: {
+        grid: PlacementSpec;
+        radial: PlacementSpec;
+        linear: PlacementSpec;
+    };
+}
+export declare const byMode: (mode: PropRef, members: PlacementPick["members"]) => PlacementPick;
+export interface VariationSlots {
+    scale: PropRef;
+    rotation: PropRef;
+    opacity: PropRef;
+    jitter: {
+        position: PropRef;
+        rotation: PropRef;
+        scale: PropRef;
+        opacity: PropRef;
+    };
+    seed: PropRef;
+    /** Seamless layout animation phase (wraps at 1). */
+    phase: PropRef;
+}
+export interface RepeatInstancesRecipe {
+    /** Crop insets applied to the sampled source rect. */
+    source: {
+        crop: {
+            left: PropRef;
+            right: PropRef;
+            top: PropRef;
+            bottom: PropRef;
+        };
+    };
+    placement: PlacementPick | PlacementSpec;
+    variation: VariationSlots;
+    /** Per-instance hue rotation (radians/instance); active when the prop is non-zero. */
+    hueShift?: PropRef;
+    /** Structural stacking order ('forward' | 'backward'). */
+    order: PropRef;
+}
+/**
+ * Build the instance-repeat fragment: placement frame → per-instance variation
+ * (→ hue-shift stage) → premultiplied over-accumulation of the child sampled per instance.
+ */
+export declare function repeatInstances(recipe: RepeatInstancesRecipe): (params: GpuFragmentParams) => Expr;
+//# sourceMappingURL=instances.d.ts.map

package/dist/core/std/effects/instances.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instances.d.ts","sourceRoot":"","sources":["../../../src/std/effects/instances.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAC,IAAI,EAAoB,KAAK,iBAAiB,EAAC,MAAM,oBAAoB,CAAA;AAGjF,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,WAAW,CAAA;AAMtC,MAAM,WAAW,SAAS;IACtB,OAAO,EAAE,OAAO,CAAA;IAChB,IAAI,EAAE,OAAO,CAAA;IACb,IAAI,EAAE,OAAO,CAAA;IACb,IAAI,EAAE,OAAO,CAAA;IACb,OAAO,EAAE,OAAO,CAAA;IAChB,2EAA2E;IAC3E,IAAI,EAAE,OAAO,CAAA;CAChB;AACD,MAAM,WAAW,WAAW;IACxB,KAAK,EAAE,OAAO,CAAA;IACd,MAAM,EAAE,OAAO,CAAA;IACf,UAAU,EAAE,OAAO,CAAA;IACnB,KAAK,EAAE,OAAO,CAAA;IACd,UAAU,EAAE,OAAO,CAAA;CACtB;AACD,MAAM,WAAW,SAAS;IACtB,KAAK,EAAE,OAAO,CAAA;IACd,SAAS,EAAE,OAAO,CAAA;IAClB,OAAO,EAAE,OAAO,CAAA;CACnB;AAED,MAAM,MAAM,aAAa,GACnB;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,SAAS,CAAA;CAAC,GAChC;IAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,WAAW,CAAA;CAAC,GACpC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,SAAS,CAAA;CAAC,CAAA;AAEtC,eAAO,MAAM,IAAI,UAAW,SAAS,KAAG,aAAwC,CAAA;AAChF,eAAO,MAAM,MAAM,UAAW,WAAW,KAAG,aAA0C,CAAA;AACtF,eAAO,MAAM,IAAI,UAAW,SAAS,KAAG,aAAwC,CAAA;AAEhF,wFAAwF;AACxF,MAAM,WAAW,aAAa;IAC1B,IAAI,EAAE,OAAO,CAAA;IACb,OAAO,EAAE;QAAC,IAAI,EAAE,aAAa,CAAC;QAAC,MAAM,EAAE,aAAa,CAAC;QAAC,MAAM,EAAE,aAAa,CAAA;KAAC,CAAA;CAC/E;AACD,eAAO,MAAM,MAAM,SAAU,OAAO,WAAW,aAAa,CAAC,SAAS,CAAC,KAAG,aAAkC,CAAA;AAI5G,MAAM,WAAW,cAAc;IAC3B,KAAK,EAAE,OAAO,CAAA;IACd,QAAQ,EAAE,OAAO,CAAA;IACjB,OAAO,EAAE,OAAO,CAAA;IAChB,MAAM,EAAE;QAAC,QAAQ,EAAE,OAAO,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,OAAO,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAC,CAAA;IAChF,IAAI,EAAE,OAAO,CAAA;IACb,oDAAoD;IACpD,KAAK,EAAE,OAAO,CAAA;CACjB;AAED,MAAM,WAAW,qBAAqB;IAClC,sDAAsD;IACtD,MAAM,EAAE;QAAC,IAAI,EAAE;YAAC,IAAI,EAAE,OAAO,CAAC;YAAC,KAAK,EAAE,OAAO,CAAC;YAAC,GAAG,EAAE,OAAO,CAAC;YAAC,MAAM,EAAE,OAAO,CAAA;SAAC,CAAA;KAAC,CAAA;IAC9E,SAAS,EAAE,aAAa,GAAG,aAAa,CAAA;IACxC,SAAS,EAAE,cAAc,CAAA;IACzB,sFAAsF;IACtF,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,0DAA0D;IAC1D,KAAK,EAAE,OAAO,CAAA;CACjB;AAKD;;;GAGG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,qBAAqB,YACzC,iBAAiB,KAAG,IAAI,CA+F3C"}

package/dist/core/std/effects/lens.d.ts

@@ -0,0 +1,53 @@
+import { GpuFragmentParams, Expr } from '../../gpu/contract';
+import { d } from '../../gpu/kit/index';
+import { ArgSpec } from '../invoke';
+import { PropRef } from '../values';
+import { SampleStage } from './blurs';
+
+export declare const chromaticOffsetUV: import('typegpu').TgpuFn<(uv: d.Vec2f, angle: d.F32, strength: d.F32, aspect: d.F32, channelOffset: d.F32) => d.Vec2f>;
+/**
+ * Chromatic fan: sample the child at three per-channel offset UVs along `angle` (each channel's
+ * signed multiplier × `strength`) and recombine R/G/B — alpha from the green tap, so a centred
+ * green (offset 0) keeps the silhouette put. Not a uvRemap candidate: three DIFFERENT sample UVs
+ * can't fold into one coordinate.
+ */
+export declare function chromaticFan(opts: {
+    strength: ArgSpec;
+    angle: ArgSpec;
+    red: ArgSpec;
+    green: ArgSpec;
+    blue: ArgSpec;
+}): SampleStage;
+/** The prop roles the spectral-lens recipe binds. */
+export interface SpectralLensSlots {
+    center: PropRef;
+    spread: PropRef;
+    bias: PropRef;
+    angle: PropRef;
+    perspective: PropRef;
+    count: PropRef;
+    dispersion: PropRef;
+    dispersionShift: PropRef;
+    dispersionColor: PropRef;
+    focusCenter: PropRef;
+    focusEdges: PropRef;
+    swirl: PropRef;
+    noise: PropRef;
+    noiseFrequency: PropRef;
+    noiseOffset: PropRef;
+    lensBulge: PropRef;
+    lensCircle: PropRef;
+    grainMixer: PropRef;
+    grainOverlay: PropRef;
+}
+/**
+ * The spectral-lens recipe: split the child into shifting chromatic layers (a runtime-count
+ * gather fan) with barrel/pincushion lens warp, optional circular crop, swirl, noise scatter and
+ * film grain. Composed from the kit's lens statement parts — lensGeometry → spreadAxis →
+ * spectralFan → grainOverlay, all appending to one statement stream (they share locals via the
+ * fresh prefix). The fan loop is raw WGSL because per-iteration texture sampling can't fold
+ * into the Expr graph; the accumulated result is premultiplied → straight alpha on the way out
+ * like every RTT filter.
+ */
+export declare function spectralLens(slots: SpectralLensSlots): (params: GpuFragmentParams) => Expr;
+//# sourceMappingURL=lens.d.ts.map

package/dist/core/std/effects/lens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lens.d.ts","sourceRoot":"","sources":["../../../src/std/effects/lens.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAC,iBAAiB,EAAc,MAAM,oBAAoB,CAAA;AACtE,OAAO,EAAC,IAAI,EAAc,MAAM,oBAAoB,CAAA;AAEpD,OAAO,EAAO,CAAC,EAAa,MAAM,qBAAqB,CAAA;AAEvD,OAAO,EAAa,KAAK,OAAO,EAAC,MAAM,WAAW,CAAA;AAClD,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,WAAW,CAAA;AACtC,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,SAAS,CAAA;AAQxC,eAAO,MAAM,iBAAiB,wHAQxB,CAAA;AAEN;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE;IAC/B,QAAQ,EAAE,OAAO,CAAA;IACjB,KAAK,EAAE,OAAO,CAAA;IACd,GAAG,EAAE,OAAO,CAAA;IACZ,KAAK,EAAE,OAAO,CAAA;IACd,IAAI,EAAE,OAAO,CAAA;CAChB,GAAG,WAAW,CAYd;AAID,qDAAqD;AACrD,MAAM,WAAW,iBAAiB;IAC9B,MAAM,EAAE,OAAO,CAAA;IACf,MAAM,EAAE,OAAO,CAAA;IACf,IAAI,EAAE,OAAO,CAAA;IACb,KAAK,EAAE,OAAO,CAAA;IACd,WAAW,EAAE,OAAO,CAAA;IACpB,KAAK,EAAE,OAAO,CAAA;IACd,UAAU,EAAE,OAAO,CAAA;IACnB,eAAe,EAAE,OAAO,CAAA;IACxB,eAAe,EAAE,OAAO,CAAA;IACxB,WAAW,EAAE,OAAO,CAAA;IACpB,UAAU,EAAE,OAAO,CAAA;IACnB,KAAK,EAAE,OAAO,CAAA;IACd,KAAK,EAAE,OAAO,CAAA;IACd,cAAc,EAAE,OAAO,CAAA;IACvB,WAAW,EAAE,OAAO,CAAA;IACpB,SAAS,EAAE,OAAO,CAAA;IAClB,UAAU,EAAE,OAAO,CAAA;IACnB,UAAU,EAAE,OAAO,CAAA;IACnB,YAAY,EAAE,OAAO,CAAA;CACxB;AAED;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,iBAAiB,GAAG,CAAC,MAAM,EAAE,iBAAiB,KAAK,IAAI,CA2B1F"}

package/dist/core/std/effects/overlay.d.ts

@@ -0,0 +1,66 @@
+import { Expr as ExprT, GpuFragmentParams } from '../../gpu/contract';
+import { PropRef } from '../values';
+/**
+ * std/effects — the HUD-drawing vocabulary shared by the overlay-role shaders (ObjectTracker,
+ * KeyFrames): premultiplied "over" compositing, round-rect signed distance, the corner-bracket
+ * stroke mask, and the premultiplied→straight output convention. The part BODIES live in
+ * kit/overlayParts (statement-level string builders — see the rationale there); this module is
+ * the std-facing surface shader definitions import.
+ *
+ * Only multi-consumer vocabulary lives here (the pass-4 rule: single-consumer stages stay in
+ * their shader file as named parts).
+ */
+export { overPremul, roundRectSD, cornerBracketMask, straightFromPremul } from '../../gpu/kit/overlayParts';
+/** The prop roles the detection-overlay recipe binds. */
+export interface DetectionOverlaySlots {
+    detectionMode: PropRef;
+    threshold: PropRef;
+    layout: PropRef;
+    cellSize: PropRef;
+    maxDepth: PropRef;
+    boxStyle: PropRef;
+    lineWidth: PropRef;
+    cornerRadius: PropRef;
+    strokeColor: PropRef;
+    fillColor: PropRef;
+    labelColor: PropRef;
+    labelBackgroundColor: PropRef;
+    labelMode: PropRef;
+    labelPosition: PropRef;
+    labelInset: PropRef;
+    labelRadius: PropRef;
+    fontFamily: PropRef;
+    fontWeight: PropRef;
+    fontSize: PropRef;
+    letterSpacing: PropRef;
+}
+/**
+ * The detection-overlay recipe: each pixel walks a spatial partition of the canvas to its leaf
+ * cell, scans that leaf for content (coverage + a content-tight bbox), and — if the leaf holds
+ * an object — composites a bounding box + an optional glyph-pill label over the source. One
+ * raw-WGSL builder over the kit's detection parts: the walk is JS-unrolled over compile-time
+ * `maxDepth`, each cell scan a JS-unrolled N×N textureSampleLevel loop, bbox accumulation via
+ * `select`-folds (uniform control flow, AA stays valid). Compile-time branches (detectionMode /
+ * layout / maxDepth / boxStyle / labelMode / labelPosition) read propValues.
+ */
+export declare function detectionOverlay(slots: DetectionOverlaySlots): (params: GpuFragmentParams) => ExprT;
+/** The prop roles the motion-tracker HUD recipe binds. */
+export interface MotionTrackerHudSlots {
+    trackers: PropRef;
+    trail: PropRef;
+    markerSize: PropRef;
+    lineWidth: PropRef;
+    markerColor: PropRef;
+    keyframeColor: PropRef;
+    pathColor: PropRef;
+}
+/**
+ * The motion-tracker HUD fragment: ONE copy of the draw body in a runtime loop over the tracker
+ * count, reading the pursuit sim's state rows (`trackState` compute output). Per pixel each
+ * tracker costs 2 cache-resident loads (head + trail AABB) unless the pixel is inside its padded
+ * box, where the trail-ring stamps (keyframe diamond + path segment) and the bracket gizmo run.
+ * The AABB cull is an atomic raw-WGSL core: a runtime-count loop whose draw body sits behind a
+ * per-tracker early-out, which no Expr-graph fold can express inside emitted control flow.
+ */
+export declare function motionTrackerHud(slots: MotionTrackerHudSlots): (params: GpuFragmentParams) => ExprT;
+//# sourceMappingURL=overlay.d.ts.map

package/dist/core/std/effects/overlay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlay.d.ts","sourceRoot":"","sources":["../../../src/std/effects/overlay.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAC,UAAU,EAAE,WAAW,EAAE,iBAAiB,EAAE,kBAAkB,EAAC,MAAM,4BAA4B,CAAA;AAGzG,OAAO,KAAK,EAAC,IAAI,IAAI,KAAK,EAAE,iBAAiB,EAAc,MAAM,oBAAoB,CAAA;AAIrF,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,WAAW,CAAA;AAKtC,yDAAyD;AACzD,MAAM,WAAW,qBAAqB;IAClC,aAAa,EAAE,OAAO,CAAA;IACtB,SAAS,EAAE,OAAO,CAAA;IAClB,MAAM,EAAE,OAAO,CAAA;IACf,QAAQ,EAAE,OAAO,CAAA;IACjB,QAAQ,EAAE,OAAO,CAAA;IACjB,QAAQ,EAAE,OAAO,CAAA;IACjB,SAAS,EAAE,OAAO,CAAA;IAClB,YAAY,EAAE,OAAO,CAAA;IACrB,WAAW,EAAE,OAAO,CAAA;IACpB,SAAS,EAAE,OAAO,CAAA;IAClB,UAAU,EAAE,OAAO,CAAA;IACnB,oBAAoB,EAAE,OAAO,CAAA;IAC7B,SAAS,EAAE,OAAO,CAAA;IAClB,aAAa,EAAE,OAAO,CAAA;IACtB,UAAU,EAAE,OAAO,CAAA;IACnB,WAAW,EAAE,OAAO,CAAA;IACpB,UAAU,EAAE,OAAO,CAAA;IACnB,UAAU,EAAE,OAAO,CAAA;IACnB,QAAQ,EAAE,OAAO,CAAA;IACjB,aAAa,EAAE,OAAO,CAAA;CACzB;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,qBAAqB,GAAG,CAAC,MAAM,EAAE,iBAAiB,KAAK,KAAK,CAoFnG;AAOD,0DAA0D;AAC1D,MAAM,WAAW,qBAAqB;IAClC,QAAQ,EAAE,OAAO,CAAA;IACjB,KAAK,EAAE,OAAO,CAAA;IACd,UAAU,EAAE,OAAO,CAAA;IACnB,SAAS,EAAE,OAAO,CAAA;IAClB,WAAW,EAAE,OAAO,CAAA;IACpB,aAAa,EAAE,OAAO,CAAA;IACtB,SAAS,EAAE,OAAO,CAAA;CACrB;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,qBAAqB,GAAG,CAAC,MAAM,EAAE,iBAAiB,KAAK,KAAK,CAiEnG"}

package/dist/core/std/effects/pointerFields.d.ts

@@ -0,0 +1,50 @@
+import { GpuFragmentParams } from '../../gpu/contract';
+import { d } from '../../gpu/kit/index';
+import { GridSimConfig, GridRoot } from '../sim/grids';
+import { PropRef } from '../values';
+
+export declare const SPLAT_MIN_GRID = 8;
+export declare const SPLAT_MAX_GRID = 128;
+/** The effective (clamped, floored) splat grid resolution — the shader's recompile key. */
+export declare const clampSplatGridSize: (v: number) => number;
+/** Splat update kernel factory (grid size baked): per-cell dissipation + Gaussian cursor-velocity
+ *  splat + clamp. No neighbour reads → single buffer, no ping-pong. Every cell updated. */
+export declare function makeSplatUpdateKernel(gridSize: number): import('typegpu').TgpuFn<(cx: d.U32, cy: d.U32) => d.Void>;
+/** Splat output kernel factory (grid size baked): copy the per-cell displacement into RG. */
+export declare function makeSplatOutputKernel(gridSize: number): import('typegpu').TgpuFn<(cx: d.U32, cy: d.U32) => d.Void>;
+/**
+ * The pointer-splat field sim: a mouse-driven grid displacement field on a single vec4 state
+ * buffer (createStateBuffer; WebGPU zero-inits → flat), as the std grid pipeline:
+ * cursor-velocity smoothing → settle gate → params write → the in-place update pass (dissipate +
+ * splat + clamp, one fused kernel) → the output publish under `slots.output`. CHILD-INDEPENDENT
+ * (no bindInputs). The grid resolution is baked per-compose from `slots.gridSize` (kernel
+ * factories) — pair that prop with a `clampSplatGridSize` recompile rule.
+ */
+export declare function pointerSplatField(slots: {
+    gridSize: PropRef;
+    decay: PropRef;
+    intensity: PropRef;
+    radius: PropRef;
+    output: string;
+}): (params: GpuFragmentParams, root: GridRoot) => GridSimConfig;
+/** Spring-lattice step (4 structural + 4 shear springs + return-to-rest, semi-implicit Euler,
+ *  cursor impulse injection). 2D-dispatched with the interior border guard. */
+export declare const springLatticeKernel: import('typegpu').TgpuFn<(cx: d.U32, cy: d.U32) => d.Void>;
+/** Copy the displacement (xy) of the current buffer into the RG displacement texture. */
+export declare const springLatticeOutputKernel: import('typegpu').TgpuFn<(cx: d.U32, cy: d.U32) => d.Void>;
+/**
+ * The spring-lattice field sim: a spring-mass cloth over two ping-pong vec4 state buffers
+ * (createStateBuffer; WebGPU zero-inits → the cloth starts at rest), as the std grid pipeline:
+ * cursor-impulse tracking → settle gate → params write → 2 fixed substeps (A→B, B→A — A is
+ * always current, B is scratch, so the bind groups are fixed) → output publish from A under
+ * `slots.output`. CHILD-INDEPENDENT → no bindInputs. NB: no childNode guard — in the analytic
+ * uvRemap fold path the composer passes childNode=undefined (the child is folded, not sampled);
+ * the sim must still run there so `uvRemap` can read its displacement.
+ */
+export declare function springLatticeField(slots: {
+    stiffness: PropRef;
+    damping: PropRef;
+    radius: PropRef;
+    output: string;
+}): (params: GpuFragmentParams, root: GridRoot) => GridSimConfig;
+//# sourceMappingURL=pointerFields.d.ts.map

package/dist/core/std/effects/pointerFields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pointerFields.d.ts","sourceRoot":"","sources":["../../../src/std/effects/pointerFields.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,oBAAoB,CAAA;AAEzD,OAAO,EAAO,CAAC,EAAM,MAAM,qBAAqB,CAAA;AAChD,OAAO,EAAsB,KAAK,aAAa,EAAE,KAAK,QAAQ,EAAC,MAAM,cAAc,CAAA;AACnF,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,WAAW,CAAA;AAMtC,eAAO,MAAM,cAAc,IAAI,CAAA;AAC/B,eAAO,MAAM,cAAc,MAAM,CAAA;AAKjC,2FAA2F;AAC3F,eAAO,MAAM,kBAAkB,MAAO,MAAM,KAAG,MAA2E,CAAA;AAe1H;2FAC2F;AAC3F,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,8DAuBrD;AAED,6FAA6F;AAC7F,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,8DAOrD;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE;IACrC,QAAQ,EAAE,OAAO,CAAA;IACjB,KAAK,EAAE,OAAO,CAAA;IACd,SAAS,EAAE,OAAO,CAAA;IAClB,MAAM,EAAE,OAAO,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;CACjB,GAAG,CAAC,MAAM,EAAE,iBAAiB,EAAE,IAAI,EAAE,QAAQ,KAAK,aAAa,CAqE/D;AAwBD;+EAC+E;AAC/E,eAAO,MAAM,mBAAmB,4DAoDH,CAAA;AAE7B,yFAAyF;AACzF,eAAO,MAAM,yBAAyB,4DAKP,CAAA;AAE/B;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE;IACtC,SAAS,EAAE,OAAO,CAAA;IAClB,OAAO,EAAE,OAAO,CAAA;IAChB,MAAM,EAAE,OAAO,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;CACjB,GAAG,CAAC,MAAM,EAAE,iBAAiB,EAAE,IAAI,EAAE,QAAQ,KAAK,aAAa,CA+E/D"}

package/dist/core/std/effects/reveal.d.ts

@@ -0,0 +1,106 @@
+import { Expr } from '../../gpu/contract';
+import { FilterParams } from '../../gpu/scaffolds/pointwiseFilter';
+import { PointwiseEffect } from '../types';
+import { ArgSpec } from '../invoke';
+import { PropRef } from '../values';
+
+/**
+ * A coverage coordinate: a per-pixel scalar in [0,1] ordering when each pixel is wiped
+ * (0 = goes first, 1 = goes last). Produced by the {@link coverage} namespace; refined by the
+ * modifier methods, each of which returns a new coverage.
+ */
+export declare class Coverage {
+    readonly build: (params: FilterParams) => Expr;
+    constructor(build: (params: FilterParams) => Expr);
+    /**
+     * Fold the coordinate about its midpoint: 0 on the center line, 1 at both ends — one sweeping
+     * front becomes two fronts opening outward (barn doors).
+     */
+    folded(): Coverage;
+    /**
+     * Tile the coordinate into `count` repeats, each tile crossing the same front in lockstep
+     * (venetian blinds).
+     */
+    tiled(count: ArgSpec): Coverage;
+    /**
+     * Quantize the coordinate into `count` bands that vanish whole, one after another in
+     * coordinate order (ring pops over a radial coverage). Chain `.shuffled()` to randomize the
+     * band order instead.
+     */
+    bands(count: ArgSpec): BandedCoverage;
+}
+/** A banded coverage — bands vanish in coordinate order, or in stable random order via {@link BandedCoverage.shuffled}. */
+export declare class BandedCoverage extends Coverage {
+    constructor(base: Coverage, count: ArgSpec);
+    private readonly base;
+    private readonly count;
+    /**
+     * Give each band a stable random coverage (a hash of its index, no time dependence) so the
+     * bands vanish in a frozen shuffled order (random bars).
+     */
+    shuffled(): Coverage;
+}
+/**
+ * The cell-grid coverage family: the frame diced into square-ish cells `size` wide (as a fraction
+ * of frame width, height aspect-corrected). Not a coverage by itself — pick how the cells order
+ * their pixels: {@link diamond}, {@link checker}, or {@link shuffled}.
+ */
+export declare class CellCoverage {
+    private readonly size;
+    constructor(size: ArgSpec);
+    /** Each pixel's coverage is its diamond distance from the cell center — a lattice of growing diamonds. */
+    diamond(): Coverage;
+    /** Cells vanish in the staggered checkerboard order: even-parity cells sweep corner-to-corner first, odd-parity second. */
+    checker(): Coverage;
+    /** Each cell gets a stable random coverage (a hash of its index, no time dependence) — blocks dissolve in a frozen random order. */
+    shuffled(): Coverage;
+}
+/** The sweep direction of an angular coverage — a structural choice, baked into the compiled shader. */
+export type AngularDirection = 'cw' | 'ccw' | 'both';
+/** The coverage coordinate producers — one per family. All read the frame's own UV and aspect. */
+export declare const coverage: {
+    /**
+     * 0→1 along `angleDeg` (degrees, 0 = left to right), aspect corrected so a diagonal reads as
+     * a true angle and both extremes of the frame are reached exactly.
+     */
+    directional(angleDeg: ArgSpec): Coverage;
+    /**
+     * Distance from `center` (a position prop), normalized by the distance to the FARTHEST corner
+     * so coverage 1 is reached at every pixel however off-center the origin is.
+     */
+    radial(center: ArgSpec): Coverage;
+    /**
+     * Clock-sweep fraction around `center`, measured from `startDeg`. `direction` is STRUCTURAL —
+     * a compile-time string prop (bind with `p()`) or a literal `'cw' | 'ccw' | 'both'`, baked
+     * into the compiled shader as a mode literal ('both' opens two wedges meeting on the far side).
+     */
+    angular(center: ArgSpec, startDeg: ArgSpec, direction: PropRef | AngularDirection): Coverage;
+    /**
+     * The frame diced into square-ish cells `size` wide (as a fraction of frame width). Pick the
+     * per-cell ordering: `.diamond()`, `.checker()`, or `.shuffled()`.
+     */
+    cells(size: ArgSpec): CellCoverage;
+    /**
+     * An organic noise field (a stable 3-octave fbm, no time dependence) — the classic film
+     * dissolve. `scale` sets the blob frequency; `seed` shifts the pattern.
+     */
+    noise(scale: ArgSpec, seed: ArgSpec): Coverage;
+};
+/** The reveal noun's slots: what orders the pixels, and the shared wipe timing. */
+export interface RevealSlots {
+    /** The coverage coordinate — which pixels go first. */
+    coverage: Coverage;
+    /** How far the wipe has travelled (0 = fully visible, 1 = fully wiped away). */
+    progress: ArgSpec;
+    /** Softness of the wipe front (the progress window a pixel crosses). */
+    feather: ArgSpec;
+    /** Reverse the coverage ordering (a boolean prop; flips the coordinate, not the progress). */
+    invert: ArgSpec;
+}
+/**
+ * Wipe the child away along a coverage coordinate: pixels vanish in coverage order as `progress`
+ * grows, crossing a ±`feather` soft front remapped so both progress extremes clear completely.
+ * Scales the straight-alpha child's alpha with RGB preserved — pointwise, no render-to-texture.
+ */
+export declare function reveal(slots: RevealSlots): PointwiseEffect;
+//# sourceMappingURL=reveal.d.ts.map

package/dist/core/std/effects/reveal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reveal.d.ts","sourceRoot":"","sources":["../../../src/std/effects/reveal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,oBAAoB,CAAA;AAG5C,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,qCAAqC,CAAA;AACrE,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,UAAU,CAAA;AAC7C,OAAO,EAAa,KAAK,OAAO,EAAC,MAAM,WAAW,CAAA;AAClD,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,WAAW,CAAA;AAEtC;;;;GAIG;AACH,qBAAa,QAAQ;IACL,QAAQ,CAAC,KAAK,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI;gBAArC,KAAK,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI;IAE1D;;;OAGG;IACH,MAAM,IAAI,QAAQ;IAIlB;;;OAGG;IACH,KAAK,CAAC,KAAK,EAAE,OAAO,GAAG,QAAQ;IAK/B;;;;OAIG;IACH,KAAK,CAAC,KAAK,EAAE,OAAO,GAAG,cAAc;CAGxC;AAED,2HAA2H;AAC3H,qBAAa,cAAe,SAAQ,QAAQ;gBAC5B,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO;IAO1C,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAU;IAC/B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;IAE/B;;;OAGG;IACH,QAAQ,IAAI,QAAQ;CAIvB;AAED;;;;GAIG;AACH,qBAAa,YAAY;IACT,OAAO,CAAC,QAAQ,CAAC,IAAI;gBAAJ,IAAI,EAAE,OAAO;IAE1C,0GAA0G;IAC1G,OAAO,IAAI,QAAQ;IAKnB,2HAA2H;IAC3H,OAAO,IAAI,QAAQ;IAKnB,oIAAoI;IACpI,QAAQ,IAAI,QAAQ;CAIvB;AAED,wGAAwG;AACxG,MAAM,MAAM,gBAAgB,GAAG,IAAI,GAAG,KAAK,GAAG,MAAM,CAAA;AAIpD,kGAAkG;AAClG,eAAO,MAAM,QAAQ;IACjB;;;OAGG;0BACmB,OAAO,GAAG,QAAQ;IAKxC;;;OAGG;mBACY,OAAO,GAAG,QAAQ;IAKjC;;;;OAIG;oBACa,OAAO,YAAY,OAAO,aAAa,OAAO,GAAG,gBAAgB,GAAG,QAAQ;IAa5F;;;OAGG;gBACS,OAAO,GAAG,YAAY;IAIlC;;;OAGG;iBACU,OAAO,QAAQ,OAAO,GAAG,QAAQ;CAIjD,CAAA;AAED,mFAAmF;AACnF,MAAM,WAAW,WAAW;IACxB,uDAAuD;IACvD,QAAQ,EAAE,QAAQ,CAAA;IAClB,gFAAgF;IAChF,QAAQ,EAAE,OAAO,CAAA;IACjB,wEAAwE;IACxE,OAAO,EAAE,OAAO,CAAA;IAChB,8FAA8F;IAC9F,MAAM,EAAE,OAAO,CAAA;CAClB;AAED;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,WAAW,GAAG,eAAe,CAa1D"}