shaders 2.5.135 → 3.0.436

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

@@ -0,0 +1,120 @@
+import { d } from './index';
+import { Expr } from '../contract';
+import { PropConfig } from '../../types';
+
+export declare const MAX_COLOR_STOPS = 8;
+export interface ColorStop {
+    /** CSS color string (hex, rgb, named, etc.) */
+    color: string;
+    /** Position along the gradient axis, 0–1 */
+    position: number;
+}
+/**
+ * Sentinel marker used as the `stops` prop's `transform`. Never invoked to produce a node —
+ * the color-stops branches in the uniform store intercept the prop by this identity before
+ * the generic transform path runs (mirrors the old `updateTransformMap` identity pattern).
+ */
+export declare const colorStopsTransform: (value: unknown) => unknown;
+/**
+ * Stable sort stops by position (CPU). Keeps `{color, position}` pairs together — sorting
+ * positions independently of colors would scramble the gradient.
+ */
+export declare function sortStops(stops: ColorStop[]): ColorStop[];
+/**
+ * The effective sorted stop list for a gradient's props: explicit `stops` (sorted) when
+ * present and non-empty, otherwise the legacy two-color [colorA@0, colorB@1] pair. Shared by
+ * core and the editor so they always agree.
+ */
+export declare function resolveStops(props: {
+    stops?: ColorStop[] | null;
+    colorA?: string;
+    colorB?: string;
+}): ColorStop[];
+/** A stop color parser: CSS string → P3-linear rgba. Supplied by transformations.ts. */
+export type ToRGBA = (css: string) => [number, number, number, number];
+/** Packed stop arrays in the fixed-MAX uniform-array layout. */
+export interface PackedStops {
+    /** rgba per stop, flat: MAX_COLOR_STOPS * 4 floats. */
+    colors: number[];
+    /** position per stop: MAX_COLOR_STOPS floats. */
+    positions: number[];
+    /** number of active stops (the CPU unroll bound). */
+    stopCount: number;
+}
+/**
+ * Pack (already-resolvable) stops into fixed-MAX flat arrays and compute `stopCount`. Inactive
+ * (null/empty) → stopCount 0 (the shader takes its legacy two-color path). Sort/pack decoupled
+ * from the uniform arrays. `toRGBA` converts each CSS color.
+ */
+export declare function packStops(stops: ColorStop[] | null | undefined, toRGBA: ToRGBA): PackedStops;
+/**
+ * Refill the CPU-preconverted working-space array from packed stop colors, for `colorSpaceMode`
+ * (uses colorMixing's `convertP3ToMixSpaceCPU`). Returns MAX_COLOR_STOPS * 3 floats; only the
+ * first `stopCount` entries are meaningful.
+ */
+export declare function packConvertedStops(colors: number[], stopCount: number, colorSpaceMode: number): number[];
+/**
+ * Working-space color of stop `i`: either the CPU-preconverted color (non-linear modes — zero
+ * forward conversions on the GPU) or the raw P3 rgb (mode 0, where the mix space IS P3). The
+ * caller supplies both accessors; `mixColorStops` selects between them by mode, exactly as the
+ * original's `useConverted` branch did.
+ */
+export interface StopAccessors {
+    /** Working-space (or, mode 0, raw P3) color of stop `i`. */
+    convAt: (i: number) => d.v3f;
+    /** Alpha of stop `i` (scalar GPU expr — typed `number`, matching colorMixing's convention). */
+    alphaAt: (i: number) => number;
+    /** Position of stop `i` along the gradient axis. */
+    positionAt: (i: number) => number;
+}
+/**
+ * Build-time multi-stop color evaluation at scalar `t` (0–1). When there are >1 active stops,
+ * unrolls the sorted stops into a sequential per-segment mix chain (in the working color space)
+ * and returns the resulting P3-linear vec4; otherwise returns `null` so the caller runs its
+ * original two-color path (`mixColorStops(...) ?? mixColors(...)`).
+ *
+ * BUILDER (composer-consumed): `stopCount` and `colorSpaceMode` are CPU compile-time values, so
+ * this JS-unrolls and only ever calls tgpu.fns (consistent with colorMixing's builder-dispatchers
+ * — never raw infix/construction at builder level). The chain runs IN the working space: each
+ * stop is forward-converted once (via the `convAt` accessor), segments blend with the
+ * alpha-weighted step, and a single back-conversion closes the chain.
+ */
+export declare function mixColorStops(stopCount: number, colorSpaceMode: number, t: number, stops: StopAccessors): d.v4f | null;
+/**
+ * Working-space multi-stop accumulation at scalar `t` (runtime loop, bound by `stopCount`). See
+ * the section note. `converted` holds each stop's color ALREADY in the working space (mode 0 =
+ * raw P3); `colors[i].w` is the alpha; `positions` packs the 8 stop positions 4-per-vec4. Returns
+ * the accumulated working-space color + alpha (`MixStep`) — the builder does the closing
+ * back-conversion. Exported for CPU golden-value tests (DualFn).
+ */
+export declare const gradientStopsInSpace: import('typegpu').TgpuFn<(t: d.F32, colors: d.WgslArray<d.Vec4f>, positions: d.WgslArray<d.Vec4f>, converted: d.WgslArray<d.Vec3f>, stopCount: d.F32) => d.WgslStruct<{
+    conv: d.Vec3f;
+    alpha: d.F32;
+}>>;
+/** The four packed color-stop uniform accessors a runtime multi-stop gradient consumes. */
+export interface ColorStopRuntimeUniforms {
+    /** `d.arrayOf(vec4f, 8)` — rgba per stop (rgb = xyz, alpha = w). */
+    colorsArray: Expr;
+    /** `d.arrayOf(vec4f, 2)` — 8 positions packed 4-per-vec4. */
+    positionsArray: Expr;
+    /** `d.arrayOf(vec3f, 8)` — CPU-preconverted working-space rgb per stop (at the active mode). */
+    convertedColorsArray: Expr;
+    /** `d.f32` — the active stop count (the runtime loop bound). */
+    stopCount: Expr;
+}
+/**
+ * Composition-time multi-stop color for a gradient parameter `t` (0–1). Runs the working-space
+ * accumulation loop over the packed stop uniforms, then back-converts to P3-linear at the
+ * compile-time `colorSpaceMode`, returning `vec4(rgb, alpha)`. The caller gates this behind
+ * `stopCount > 1` and runs the literal two-color `mixColors` path otherwise. `t` may be
+ * pre-clamped by the caller; the loop clamps internally regardless.
+ */
+export declare function mixColorStopsRuntime(t: Expr, uniforms: ColorStopRuntimeUniforms, colorSpaceMode: number): Expr;
+/**
+ * The standard `stops` PropConfig shared by every multi-stop gradient. Default `null` → the
+ * shader runs its literal two-color (colorA/colorB) path, so legacy presets and npm consumers
+ * stay byte-identical. Recompiles only when the unrolled structure changes: presence toggling
+ * (null ↔ multi) or the active stop count changing; same-count edits update in place.
+ */
+export declare function colorStopsPropConfig(): PropConfig<ColorStop[] | null>;
+//# sourceMappingURL=colorStops.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"colorStops.d.ts","sourceRoot":"","sources":["../../../src/gpu/kit/colorStops.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,EAAO,CAAC,EAAM,MAAM,SAAS,CAAA;AAmBpC,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,aAAa,CAAA;AACrC,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,aAAa,CAAA;AAE3C,eAAO,MAAM,eAAe,IAAI,CAAA;AAEhC,MAAM,WAAW,SAAS;IACtB,+CAA+C;IAC/C,KAAK,EAAE,MAAM,CAAA;IACb,4CAA4C;IAC5C,QAAQ,EAAE,MAAM,CAAA;CACnB;AAED;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,UAAW,OAAO,KAAG,OAAgB,CAAA;AAErE;;;GAGG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,SAAS,EAAE,CAKzD;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE;IAAC,KAAK,CAAC,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAC,GAAG,SAAS,EAAE,CAQ/G;AAED,wFAAwF;AACxF,MAAM,MAAM,MAAM,GAAG,CAAC,GAAG,EAAE,MAAM,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAEtE,gEAAgE;AAChE,MAAM,WAAW,WAAW;IACxB,uDAAuD;IACvD,MAAM,EAAE,MAAM,EAAE,CAAA;IAChB,iDAAiD;IACjD,SAAS,EAAE,MAAM,EAAE,CAAA;IACnB,qDAAqD;IACrD,SAAS,EAAE,MAAM,CAAA;CACpB;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,IAAI,GAAG,SAAS,EAAE,MAAM,EAAE,MAAM,GAAG,WAAW,CAe5F;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,MAAM,EAAE,CASxG;AA2CD;;;;;GAKG;AACH,MAAM,WAAW,aAAa;IAC1B,4DAA4D;IAC5D,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,CAAC,CAAC,GAAG,CAAA;IAC5B,+FAA+F;IAC/F,OAAO,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAA;IAC9B,oDAAoD;IACpD,UAAU,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAA;CACpC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CACzB,SAAS,EAAE,MAAM,EACjB,cAAc,EAAE,MAAM,EACtB,CAAC,EAAE,MAAM,EACT,KAAK,EAAE,aAAa,GACrB,CAAC,CAAC,GAAG,GAAG,IAAI,CAgBd;AAeD;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB;;;GAuB/B,CAAA;AAkBF,2FAA2F;AAC3F,MAAM,WAAW,wBAAwB;IACrC,oEAAoE;IACpE,WAAW,EAAE,IAAI,CAAA;IACjB,6DAA6D;IAC7D,cAAc,EAAE,IAAI,CAAA;IACpB,gGAAgG;IAChG,oBAAoB,EAAE,IAAI,CAAA;IAC1B,gEAAgE;IAChE,SAAS,EAAE,IAAI,CAAA;CAClB;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,wBAAwB,EAAE,cAAc,EAAE,MAAM,GAAG,IAAI,CAU9G;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,IAAI,UAAU,CAAC,SAAS,EAAE,GAAG,IAAI,CAAC,CAcrE"}

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

@@ -0,0 +1,28 @@
+import { d } from './index';
+
+/**
+ * The `_sys` uniform block. Minimal by design — one field per engine-provided global. `time` is
+ * CPU-accumulated (see kit/time.ts); `viewportSize` is the device-pixel backing-buffer size,
+ * `logicalViewportSize` the CSS-pixel size (the two differ under DPR / resolution scaling).
+ * `pointer` is in UV space; `pointerActive` is 0/1 (float, matching the ±1/0/1 float encoding
+ * transforms already use for booleans).
+ */
+export declare const SystemUniforms: d.WgslStruct<{
+    time: d.F32;
+    viewportSize: d.Vec2f;
+    logicalViewportSize: d.Vec2f;
+    aspect: d.F32;
+    pointer: d.Vec2f;
+    pointerActive: d.F32;
+}>;
+/**
+ * `viewportCoordinate` — pixel-space coordinate from a UV and the viewport size
+ * (`uv * viewportSize`). GPU-callable and CPU-evaluable (dual fn), so it is unit-testable
+ * on the CPU.
+ */
+export declare const viewportCoordinate: import('typegpu').TgpuFn<(uv: d.Vec2f, viewportSize: d.Vec2f) => d.Vec2f>;
+/**
+ * Aspect ratio (width / height) from a viewport size.
+ */
+export declare const aspectOf: import('typegpu').TgpuFn<(viewportSize: d.Vec2f) => d.F32>;
+//# sourceMappingURL=coords.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"coords.d.ts","sourceRoot":"","sources":["../../../src/gpu/kit/coords.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAAO,CAAC,EAAM,MAAM,SAAS,CAAA;AAEpC;;;;;;GAMG;AACH,eAAO,MAAM,cAAc;;;;;;;EAOzB,CAAA;AAEF;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,2EAG7B,CAAA;AAEF;;GAEG;AACH,eAAO,MAAM,QAAQ,4DAGnB,CAAA"}

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

@@ -0,0 +1,11 @@
+/**
+ * CPU-side texel encoders for uploading raw data into GPU textures.
+ *
+ * `createDataTexture({format: 'r16float' | 'rgba16float', …})` takes half-float texel bytes
+ * (`Uint16Array`), not `Float32Array` — filtering samplers reject `r32float`/`rgba32float`
+ * (they need the optional `float32-filterable` feature), so any sampled data texture must be
+ * 16-bit. A shader that re-uploads a per-frame field (Shatter's shard data, and future sims)
+ * half-encodes each texel in `onBeforeRender` before `tex.write(...)`.
+ */
+export declare function toHalfFloat(val: number): number;
+//# sourceMappingURL=dataEncoding.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dataEncoding.d.ts","sourceRoot":"","sources":["../../../src/gpu/kit/dataEncoding.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAOH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAsB/C"}

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

@@ -0,0 +1,76 @@
+import { d } from './index';
+import { v2f, v4f } from 'typegpu/data';
+import { Expr } from '../contract';
+
+/** Stretch (mode 0): clamp UV into [0,1] (`clamp(uv, vec2(0), vec2(1))`). */
+export declare const edgeClampUV: import('typegpu').TgpuFn<(uv: d.Vec2f) => d.Vec2f>;
+/**
+ * Mirror (mode 2): reflect UV back into [0,1]. Per-component: `m = mod(abs(x), 2); m > 1 ?
+ * 2 - m : m`. The `m >= 1.0` reflection predicate is equivalent to `step(1, m)`.
+ */
+export declare const edgeMirrorUV: import('typegpu').TgpuFn<(uv: d.Vec2f) => d.Vec2f>;
+/** Wrap (mode 3): tile UV via `fract(uv)`. */
+export declare const edgeWrapUV: import('typegpu').TgpuFn<(uv: d.Vec2f) => d.Vec2f>;
+/**
+ * Transparent (mode 1) coverage: 1 where the looked-up UV is inside [0,1] on both axes,
+ * else 0 (`step(0,x)*step(x,1)*step(0,y)*step(y,1)`).
+ */
+export declare const edgeTransparentMask: import('typegpu').TgpuFn<(uv: d.Vec2f) => d.F32>;
+/**
+ * Applies edge handling as a UV transformation (no color sampling). Used during UV
+ * composition so each distortion in a chain applies its own edge handling before the next
+ * transforms those UVs further.
+ *
+ * - transparent (1): pass-through (coverage is dropped later, at the color stage).
+ * - mirror (2) / wrap (3) / stretch (0): the matching per-mode `tgpu.fn`.
+ */
+export declare const applyEdgeToUV: (uv: v2f, edgeMode: number) => v2f;
+/**
+ * Bakes edge handling into a UV-remap step for the analytic fast path. Returns the
+ * coordinate to look up one layer down plus an updated coverage mask:
+ * - transparent (1): leaves the UV alone and drops coverage where the looked-up coordinate
+ *   falls outside [0,1] (matches applyEdgeHandling's alpha cut).
+ * - stretch/mirror/wrap (0/2/3): transforms the UV via applyEdgeToUV, mask unchanged.
+ */
+export declare const composeEdgeRemap: (distortedUV: v2f, mask: number, edgeMode: number) => {
+    uv: v2f;
+    mask: number;
+};
+/**
+ * Applies edge handling to sampled colors based on UV bounds. Supports the four modes for
+ * distorted UVs that fall outside [0,1].
+ *
+ * @param distortedUV  the distorted UV (pre-clamp)
+ * @param sampledColor the color sampled with clamped UVs
+ * @param sample       re-sample callback (bind `kitTexture.sample`), or null for the
+ *                     non-RTT path — mirror/wrap then fall back to stretch, as before
+ * @param edgeMode     0=stretch, 1=transparent, 2=mirror, 3=wrap
+ */
+export declare const applyEdgeHandling: (distortedUV: v2f, sampledColor: v4f, sample: ((uv: v2f) => v4f) | null, edgeMode: number) => v4f;
+/**
+ * Expr-level `applyEdgeToUV`: transform a distorted-UV Expr per the compile-time edge mode.
+ * transparent (1) passes the UV through (coverage is dropped at the color/mask stage); mirror
+ * (2) / wrap (3) / stretch (0) emit the matching per-mode fn call.
+ */
+export declare const applyEdgeToUVExpr: (uv: Expr, edgeMode: number) => Expr;
+/**
+ * Expr-level `composeEdgeRemap` for the analytic UV-fold fast path. Returns the coordinate to
+ * look up one layer down plus an updated coverage mask:
+ * - transparent (1): UV unchanged; multiply the mask by the in-bounds coverage of the looked-up
+ *   coordinate (`edgeTransparentMask`).
+ * - stretch/mirror/wrap (0/2/3): transform the UV via `applyEdgeToUVExpr`, mask unchanged.
+ */
+export declare const composeEdgeRemapExpr: (distortedUV: Expr, mask: Expr, edgeMode: number) => {
+    uv: Expr;
+    mask: Expr;
+};
+/**
+ * Expr-level `applyEdgeHandling` for the RTT-filter path — edge handling on a SAMPLED color.
+ * Supply a `sample` callback (bind `kitTexture.sample`) that samples the composed content at a
+ * UV Expr.
+ * - transparent (1): sample straight, then fade alpha to 0 outside [0,1] (`edgeTransparentMask`).
+ * - mirror (2) / wrap (3): re-sample at the reflected / tiled UV.
+ * - stretch (0): sample straight (the linearClamp sampler clamps out-of-range UVs to the edge).
+ */
+export declare const applyEdgeHandlingExpr: (distortedUV: Expr, sample: (uv: Expr) => Expr, edgeMode: number) => Expr;
+//# sourceMappingURL=edges.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"edges.d.ts","sourceRoot":"","sources":["../../../src/gpu/kit/edges.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,EAAO,CAAC,EAAM,MAAM,SAAS,CAAA;AACpC,OAAO,KAAK,EAAC,GAAG,EAAE,GAAG,EAAC,MAAM,cAAc,CAAA;AAK1C,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,aAAa,CAAA;AAIrC,6EAA6E;AAC7E,eAAO,MAAM,WAAW,oDAGtB,CAAA;AAEF;;;GAGG;AACH,eAAO,MAAM,YAAY,oDAQvB,CAAA;AAEF,8CAA8C;AAC9C,eAAO,MAAM,UAAU,oDAGrB,CAAA;AAEF;;;GAGG;AACH,eAAO,MAAM,mBAAmB,kDAK9B,CAAA;AAUF;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa,OAAQ,GAAG,YAAY,MAAM,KAAG,GAWzD,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,gBACZ,GAAG,QACV,MAAM,YACF,MAAM,KACjB;IAAC,EAAE,EAAE,GAAG,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAKxB,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,iBAAiB,gBACb,GAAG,gBACF,GAAG,UACT,CAAC,CAAC,EAAE,EAAE,GAAG,KAAK,GAAG,CAAC,GAAG,IAAI,YACvB,MAAM,KACjB,GAcF,CAAA;AAgBD;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,OAAQ,IAAI,YAAY,MAAM,KAAG,IAW9D,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,gBAAiB,IAAI,QAAQ,IAAI,YAAY,MAAM,KAAG;IAAC,EAAE,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,IAAI,CAAA;CAM3G,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,gBAAiB,IAAI,UAAU,CAAC,EAAE,EAAE,IAAI,KAAK,IAAI,YAAY,MAAM,KAAG,IASvG,CAAA"}

package/dist/core/gpu/kit/effects/emboss.d.ts

@@ -0,0 +1,53 @@
+import { d } from '../index';
+import { Expr, GpuFragmentParams, KitTexture } from '../../contract';
+
+/** Uniform keys the emboss builder reads via `params.uniforms.<key>`. */
+export interface EmbossEffectUniforms {
+    center: unknown;
+    scale: unknown;
+    rotation: unknown;
+    depth: unknown;
+    lightAngle: unknown;
+    lightIntensity: unknown;
+    shadowIntensity: unknown;
+}
+export interface EmbossEffectOptions {
+    /** Treat the field as a 3D thickness map — the relief follows the actual surface height. */
+    volumetric?: boolean;
+    /** Cheap bilinear sampler for the neighbour + shadow-trace taps (compute path). Falls back to sdfSampler. */
+    gradSampler?: (uv: Expr) => Expr;
+}
+/**
+ * Height field from an SDF value. 2D: a binary plateau with a tight transition of half-width
+ * `transitionW` (edge-only lighting). Volumetric: −field used directly as a continuous height
+ * (saturating at 0.18 field units). Feeding the wider shadow transition as `transitionW` gives the
+ * cast-shadow trace its smooth falloff. `depth` is signed (raised/sunken). Pure — golden-testable.
+ */
+export declare const embossHeight: import('typegpu').TgpuFn<(s: d.F32, depth: d.F32, transitionW: d.F32, volumetric: d.F32) => d.F32>;
+/** A shadow-trace sample UV: `sdfUV + (cos,sin)(lightAngle) * spread * frac`, spread = |depth|*0.06. Pure. */
+export declare const embossTraceUV: import('typegpu').TgpuFn<(sdfUV: d.Vec2f, lightAngle: d.F32, depth: d.F32, frac: d.F32) => d.Vec2f>;
+/** Parallax UV displacement — scale the child around the shape centre inside the boundary. Pure. */
+export declare const embossWarpUV: import('typegpu').TgpuFn<(uv: d.Vec2f, center: d.Vec2f, sdfC: d.F32, depth: d.F32) => d.Vec2f>;
+/**
+ * Surface normal from the height gradient (central differences over the 4 cardinal SDF taps) +
+ * directional edge lighting. Returns `vec2(highlight, edgeShadow)` — both ≥ 0. Pure —
+ * CPU-golden-testable.
+ */
+export declare const embossEdgeLighting: import('typegpu').TgpuFn<(sdfR: d.F32, sdfL: d.F32, sdfU: d.F32, sdfD: d.F32, depth: d.F32, lightAngle: d.F32, lightIntensity: d.F32, volumetric: d.F32) => d.Vec2f>;
+/**
+ * The full emboss composite. `childColor` = STRAIGHT child sample at the warped UV; the 5 SDF taps
+ * (centre + R/L/U/D) drive edge lighting; the 2 trace taps (`h1raw`/`h2raw`) drive the cast shadow.
+ * Returns STRAIGHT rgba. Resolve-goldenable.
+ */
+export declare const embossComposite: import('typegpu').TgpuFn<(childColor: d.Vec4f, sdfC: d.F32, sdfR: d.F32, sdfL: d.F32, sdfU: d.F32, sdfD: d.F32, h1raw: d.F32, h2raw: d.F32, depth: d.F32, lightAngle: d.F32, lightIntensity: d.F32, shadowIntensity: d.F32, volumetric: d.F32) => d.Vec4f>;
+/**
+ * Apply the emboss / deboss relief effect over child content. Composition-time Expr builder — see
+ * the file header for deviations.
+ *
+ * @param params        the fragment builder params (reads `uniforms`/`ctx`)
+ * @param sdfSampler    `(uvExpr) → vec4 Expr`: `.r` = signed distance / −chord
+ * @param childTexture  the child RTT (from the shader's `convertToTexture(childNode)`)
+ * @param options       `volumetric` + an optional cheap `gradSampler` for the neighbour/trace taps
+ */
+export declare function applyEmbossEffect(params: GpuFragmentParams, sdfSampler: (uv: Expr) => Expr, childTexture: KitTexture, options?: EmbossEffectOptions): Expr;
+//# sourceMappingURL=emboss.d.ts.map

package/dist/core/gpu/kit/effects/emboss.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emboss.d.ts","sourceRoot":"","sources":["../../../../src/gpu/kit/effects/emboss.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,EAAO,CAAC,EAAM,MAAM,UAAU,CAAA;AAGrC,OAAO,KAAK,EAAC,IAAI,EAAE,iBAAiB,EAAE,UAAU,EAAC,MAAM,gBAAgB,CAAA;AASvE,yEAAyE;AACzE,MAAM,WAAW,oBAAoB;IACjC,MAAM,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;IAClE,UAAU,EAAE,OAAO,CAAC;IAAC,cAAc,EAAE,OAAO,CAAC;IAAC,eAAe,EAAE,OAAO,CAAA;CACzE;AAED,MAAM,WAAW,mBAAmB;IAChC,4FAA4F;IAC5F,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,6GAA6G;IAC7G,WAAW,CAAC,EAAE,CAAC,EAAE,EAAE,IAAI,KAAK,IAAI,CAAA;CACnC;AAMD;;;;;GAKG;AACH,eAAO,MAAM,YAAY,oGAKvB,CAAA;AAEF,8GAA8G;AAC9G,eAAO,MAAM,aAAa,qGAOxB,CAAA;AAEF,oGAAoG;AACpG,eAAO,MAAM,YAAY,gGAQvB,CAAA;AAEF;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,sKAyBzB,CAAA;AAEN;;;;GAIG;AACH,eAAO,MAAM,eAAe,4PAyBtB,CAAA;AAMN;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAC7B,MAAM,EAAE,iBAAiB,EACzB,UAAU,EAAE,CAAC,EAAE,EAAE,IAAI,KAAK,IAAI,EAC9B,YAAY,EAAE,UAAU,EACxB,OAAO,CAAC,EAAE,mBAAmB,GAC9B,IAAI,CAyBN"}

package/dist/core/gpu/kit/effects/glass.d.ts

@@ -0,0 +1,98 @@
+import { d } from '../index';
+import { Expr, GpuFragmentParams, KitTexture } from '../../contract';
+
+export declare const BLUR_DISK: [number, number][];
+/**
+ * Uniform keys the glass builder reads via `params.uniforms.<key>` (GPU accessor Exprs).
+ * `blur`/`aberration` are ALSO read via `params.propValues` for compile-time branching.
+ */
+export interface GlassEffectUniforms {
+    center: unknown;
+    scale: unknown;
+    rotation: unknown;
+    edgeSoftness: unknown;
+    refraction: unknown;
+    innerZoom: unknown;
+    aberration: unknown;
+    blur: unknown;
+    tintColor: unknown;
+    tintIntensity: unknown;
+    tintPreserveLuminosity: unknown;
+    lightAngle: unknown;
+    highlight: unknown;
+    highlightColor: unknown;
+    highlightSoftness: unknown;
+    fresnel: unknown;
+    fresnelColor: unknown;
+    fresnelSoftness: unknown;
+    cutout: unknown;
+    thickness: unknown;
+}
+export interface GlassEffectOptions {
+    /** 3D thickness field (−chord/2): fresnel + refraction from surface slope instead of rim distance. */
+    volumetric?: boolean;
+    /** Sampler carries forward differences in .g/.b of the centre tap — skip the 2 extra taps. */
+    bakedGradients?: boolean;
+}
+/**
+ * Aspect-correct + rotate + scale the screen UV into SDF sample space, shared by the
+ * glass/neon/emboss preamble: aspect-correct the X delta, flip `center.y` back (transformPosition
+ * stores `1 - y`), rotate the delta by `rotation` degrees (rigid; rotation=0 is identity), scale,
+ * and offset by 0.5 into the 0–1 field. Pure — CPU-golden-testable.
+ */
+export declare const sdfSpaceUV: import('typegpu').TgpuFn<(center: d.Vec2f, scale: d.F32, rotation: d.F32, uv: d.Vec2f, aspect: d.F32) => d.Vec2f>;
+/** `uv + vec2(ox, oy)` — builds a neighbour/trace sample UV from a base UV + scalar offsets. */
+export declare const offsetUV: import('typegpu').TgpuFn<(uv: d.Vec2f, ox: d.F32, oy: d.F32) => d.Vec2f>;
+/** Forward-difference gradient of the SDF (non-baked path): `((sdfX - sdf)/EPS, (sdfY - sdf)/EPS)`
+ *  with EPS = 0.01. Pure. */
+export declare const glassGradient: import('typegpu').TgpuFn<(sdfRaw: d.F32, sdfX: d.F32, sdfY: d.F32) => d.Vec2f>;
+/**
+ * Refraction strength from depth. 2D plates fade refraction with depth `(1-d)²`; 3D thickness
+ * fields ramp it in with `smoothstep(0,1,d)`. `sdf` is already `sdfRaw/scale`. Pure.
+ */
+export declare const glassRefrStrength: import('typegpu').TgpuFn<(sdf: d.F32, thickness: d.F32, volumetric: d.F32) => d.F32>;
+/** The refracted lens sample UV + the ±chromatic-aberration r/b UVs. Pure. */
+export declare const GlassLensUVs: d.WgslStruct<{
+    lensUV: d.Vec2f;
+    rUV: d.Vec2f;
+    bUV: d.Vec2f;
+}>;
+export declare const glassLensUVs: import('typegpu').TgpuFn<(uv: d.Vec2f, center: d.Vec2f, sdfRaw: d.F32, scale: d.F32, gradX: d.F32, gradY: d.F32, refraction: d.F32, innerZoom: d.F32, thickness: d.F32, aberration: d.F32, aspect: d.F32, volumetric: d.F32) => d.WgslStruct<{
+    lensUV: d.Vec2f;
+    rUV: d.Vec2f;
+    bUV: d.Vec2f;
+}>>;
+/** One Vogel-disk blur tap offset in UV space: `(1/viewport) * (ox,oy) * blur*2`. Pure. */
+export declare const glassBlurOffset: import('typegpu').TgpuFn<(viewportSize: d.Vec2f, blur: d.F32, ox: d.F32, oy: d.F32) => d.Vec2f>;
+/**
+ * Colour tint (mix-based, matches the Tint shader). Optional luminosity preservation rescales the
+ * tinted colour back to the source luminance. `preserveLum` is 0/1. Pure — CPU-golden-testable
+ * (the boolean choice is a `std.mix` with a 0/1 factor, not a vec `std.select`).
+ */
+export declare const glassTint: import('typegpu').TgpuFn<(rgb: d.Vec3f, tintColor: d.Vec3f, tintIntensity: d.F32, preserveLum: d.F32) => d.Vec3f>;
+/** Directional border highlight ring (rb2): a thin 1px ring modulated by `normal·light`. Pure. */
+export declare const glassBorderHighlight: import('typegpu').TgpuFn<(sdf: d.F32, edgeSoftness: d.F32, pxH: d.F32, gradX: d.F32, gradY: d.F32, lightAngle: d.F32, highlight: d.F32) => d.F32>;
+/** Phong specular glint on the SDF normal (view dir = +z). Pure — CPU-golden-testable. */
+export declare const glassSpecular: import('typegpu').TgpuFn<(gradX: d.F32, gradY: d.F32, lightAngle: d.F32, highlight: d.F32, highlightSoftness: d.F32, refrStrength: d.F32) => d.F32>;
+/** Fresnel rim glow. Volumetric: view-angle from the thickness-field slope; 2D: distance-to-rim.
+ *  `rb1` is the inside mask. Pure — CPU-golden-testable. */
+export declare const glassFresnelRim: import('typegpu').TgpuFn<(sdf: d.F32, gradX: d.F32, gradY: d.F32, fresnel: d.F32, fresnelSoftness: d.F32, rb1: d.F32, volumetric: d.F32) => d.F32>;
+/**
+ * The full glass composite. `baseColor` = STRAIGHT child sample at screen UV; `blurred` = STRAIGHT
+ * refracted lens sample. Builds the inside mask, border ring, tint, specular, and fresnel, blends
+ * lighting over the child by `transition`, and applies cutout alpha. Returns STRAIGHT rgba. Pure
+ * (texture-derived only via the vec4 args) — resolve-goldenable.
+ */
+export declare const glassComposite: import('typegpu').TgpuFn<(baseColor: d.Vec4f, blurred: d.Vec4f, sdfRaw: d.F32, scale: d.F32, gradX: d.F32, gradY: d.F32, viewportSize: d.Vec2f, edgeSoftness: d.F32, lightAngle: d.F32, highlight: d.F32, highlightColor: d.Vec3f, highlightSoftness: d.F32, fresnel: d.F32, fresnelColor: d.Vec3f, fresnelSoftness: d.F32, thickness: d.F32, tintColor: d.Vec3f, tintIntensity: d.F32, tintPreserveLuminosity: d.F32, cutout: d.F32, volumetric: d.F32) => d.Vec4f>;
+/**
+ * Apply the glass lens effect. Composition-time Expr builder — see the file header for the notes.
+ *
+ * @param params        the fragment builder params (reads `uniforms`/`propValues`/`ctx`)
+ * @param sdfSampler    `(uvExpr) → vec4 Expr`: `.r` = signed distance/−chord, `.g`/`.b` = baked
+ *                      gradients (when `options.bakedGradients`)
+ * @param childTexture  the child RTT (from the shader's `convertToTexture(childNode)`)
+ * @param blurredTexture optional pre-blurred buffer (compute path); undefined → in-shader Vogel blur
+ * @param options       `volumetric` / `bakedGradients` build-time flags
+ */
+export declare function applyGlassEffect(params: GpuFragmentParams, sdfSampler: (uv: Expr) => Expr, childTexture: KitTexture, blurredTexture?: KitTexture, options?: GlassEffectOptions): Expr;
+//# sourceMappingURL=glass.d.ts.map

package/dist/core/gpu/kit/effects/glass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glass.d.ts","sourceRoot":"","sources":["../../../../src/gpu/kit/effects/glass.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,OAAO,EAAO,CAAC,EAAM,MAAM,UAAU,CAAA;AAGrC,OAAO,KAAK,EAAC,IAAI,EAAE,iBAAiB,EAAE,UAAU,EAAC,MAAM,gBAAgB,CAAA;AAWvE,eAAO,MAAM,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAO,CAAA;AAO/C;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAChC,MAAM,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAC;IAAC,YAAY,EAAE,OAAO,CAAA;IACzE,UAAU,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;IAC3E,SAAS,EAAE,OAAO,CAAC;IAAC,aAAa,EAAE,OAAO,CAAC;IAAC,sBAAsB,EAAE,OAAO,CAAA;IAC3E,UAAU,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,OAAO,CAAC;IAAC,cAAc,EAAE,OAAO,CAAC;IAAC,iBAAiB,EAAE,OAAO,CAAA;IAC5F,OAAO,EAAE,OAAO,CAAC;IAAC,YAAY,EAAE,OAAO,CAAC;IAAC,eAAe,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,OAAO,CAAA;CACzG;AAED,MAAM,WAAW,kBAAkB;IAC/B,sGAAsG;IACtG,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,8FAA8F;IAC9F,cAAc,CAAC,EAAE,OAAO,CAAA;CAC3B;AAMD;;;;;GAKG;AACH,eAAO,MAAM,UAAU,mHAYrB,CAAA;AAEF,gGAAgG;AAChG,eAAO,MAAM,QAAQ,0EAGnB,CAAA;AAMF;6BAC6B;AAC7B,eAAO,MAAM,aAAa,gFAIxB,CAAA;AAEF;;;GAGG;AACH,eAAO,MAAM,iBAAiB,sFAO5B,CAAA;AAEF,8EAA8E;AAC9E,eAAO,MAAM,YAAY;;;;EAA0D,CAAA;AACnF,eAAO,MAAM,YAAY;;;;GAuBnB,CAAA;AAEN,2FAA2F;AAC3F,eAAO,MAAM,eAAe,iGAI1B,CAAA;AAEF;;;;GAIG;AACH,eAAO,MAAM,SAAS,mHASpB,CAAA;AAEF,kGAAkG;AAClG,eAAO,MAAM,oBAAoB,mJAW3B,CAAA;AAEN,0FAA0F;AAC1F,eAAO,MAAM,aAAa,qJAapB,CAAA;AAEN;4DAC4D;AAC5D,eAAO,MAAM,eAAe,oJAWtB,CAAA;AAEN;;;;;GAKG;AACH,eAAO,MAAM,cAAc,scAuBrB,CAAA;AAMN;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC5B,MAAM,EAAE,iBAAiB,EACzB,UAAU,EAAE,CAAC,EAAE,EAAE,IAAI,KAAK,IAAI,EAC9B,YAAY,EAAE,UAAU,EACxB,cAAc,CAAC,EAAE,UAAU,EAC3B,OAAO,CAAC,EAAE,kBAAkB,GAC7B,IAAI,CA8EN"}

package/dist/core/gpu/kit/effects/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Shared effect helpers: glass / neon / emboss / prism / raymarch3d / thinFilm — reused across the
+ * shape-effect shaders (Glass, Crystal, Neon, Emboss, LiquidMetal, Plastic, Holographic, Frost,
+ * ThinFilm, Form3D, Prism, …). Each is an Expr-level builder
+ * `apply<X>Effect(params, sdfSampler?, …) => Expr` (see the individual files for the exact
+ * signature) plus its pure-math `'use gpu'` fns. Consumed as
+ * `kit.effects.glass.applyGlassEffect(...)` etc.
+ */
+export * as glass from './glass';
+export * as neon from './neon';
+export * as emboss from './emboss';
+export * as prism from './prism';
+export * as raymarch3d from './raymarch3d';
+export * as thinFilm from './thinFilm';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/gpu/kit/effects/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/gpu/kit/effects/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,KAAK,MAAM,SAAS,CAAA;AAChC,OAAO,KAAK,IAAI,MAAM,QAAQ,CAAA;AAC9B,OAAO,KAAK,MAAM,MAAM,UAAU,CAAA;AAClC,OAAO,KAAK,KAAK,MAAM,SAAS,CAAA;AAChC,OAAO,KAAK,UAAU,MAAM,cAAc,CAAA;AAC1C,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAA"}

package/dist/core/gpu/kit/effects/neon.d.ts

@@ -0,0 +1,60 @@
+import { d } from '../index';
+import { Expr, GpuFragmentParams } from '../../contract';
+
+/** Uniform keys the neon builder reads via `params.uniforms.<key>`. */
+export interface NeonEffectUniforms {
+    center: unknown;
+    scale: unknown;
+    rotation: unknown;
+    color: unknown;
+    secondaryColor: unknown;
+    secondaryBlend: unknown;
+    glowColor: unknown;
+    tubeThickness: unknown;
+    intensity: unknown;
+    hotCoreIntensity: unknown;
+    glowIntensity: unknown;
+    glowRadius: unknown;
+    lightAngle: unknown;
+    specularIntensity: unknown;
+    specularSize: unknown;
+    cornerSmoothing: unknown;
+    flickerSpeed: unknown;
+    flickerAmount: unknown;
+    flowSpeed: unknown;
+    flowAmount: unknown;
+}
+export interface NeonEffectOptions {
+    /** Treat the field as a 3D thickness map — trace tubes along all edges via view-depth creases. */
+    volumetric?: boolean;
+    /** Cheap bilinear sampler for the neighbour taps (compute path). Falls back to sdfSampler. */
+    gradSampler?: (uv: Expr) => Expr;
+}
+/** Corner-smoothing / tube stencil radius. Volumetric: doubles as the tube radius. Pure. */
+export declare const neonSmoothEPS: import('typegpu').TgpuFn<(tubeThickness: d.F32, cornerSmoothing: d.F32, volumetric: d.F32) => d.F32>;
+/** Two-layer outer glow (tight inner + wide outer bloom), masked to the exterior. Returns
+ *  `glowMasked`. `sdf` is the corner-smoothed field value. Pure — CPU-golden-testable. */
+export declare const neonGlow: import('typegpu').TgpuFn<(sdf: d.F32, glowRadius: d.F32, glowIntensity: d.F32) => d.F32>;
+/** Sporadic on/off flicker from three irrational-ratio sines. Higher `flickerAmount` → dark more
+ *  often. Pure — CPU-golden-testable. */
+export declare const neonFlicker: import('typegpu').TgpuFn<(time: d.F32, flickerSpeed: d.F32, flickerAmount: d.F32) => d.F32>;
+/** Rotating brightness band (`flowMod`): angular position drives a sweeping sine. Pure. */
+export declare const neonFlow: import('typegpu').TgpuFn<(sdfUV: d.Vec2f, time: d.F32, flowSpeed: d.F32, flowAmount: d.F32) => d.F32>;
+/**
+ * The full neon tube + glow composite. Takes the 5 SDF taps (centre + R/L/U/D), the stencil
+ * radius, the field-space `sdfUV` (for the flow angle), `scale`/`viewportSize` (softPx), `time`,
+ * and the uniforms. Models the interior depth as a semicircular tube cross-section, shades it with
+ * Blinn-Phong + self-emission + hot core, adds the multi-layer glow, and merges tube over glow.
+ * Returns STRAIGHT rgba (always cutout). Resolve-goldenable.
+ */
+export declare const neonComposite: import('typegpu').TgpuFn<(sC: d.Vec4f, sR: d.Vec4f, sL: d.Vec4f, sU: d.Vec4f, sD: d.Vec4f, smoothEPS: d.F32, sdfUV: d.Vec2f, scale: d.F32, viewportSize: d.Vec2f, time: d.F32, cornerSmoothing: d.F32, tubeThickness: d.F32, color: d.Vec3f, secondaryColor: d.Vec3f, secondaryBlend: d.F32, glowColor: d.Vec3f, intensity: d.F32, hotCoreIntensity: d.F32, glowIntensity: d.F32, glowRadius: d.F32, lightAngle: d.F32, specularIntensity: d.F32, specularSize: d.F32, flickerSpeed: d.F32, flickerAmount: d.F32, flowSpeed: d.F32, flowAmount: d.F32, volumetric: d.F32) => d.Vec4f>;
+/**
+ * Apply the neon tube effect. Composition-time Expr builder — see the file header for the notes.
+ *
+ * @param params      the fragment builder params (reads `uniforms`/`ctx`)
+ * @param sdfSampler  `(uvExpr) → vec4 Expr`: `.r` = signed distance/−chord, `.a` = view depth
+ * @param time        accumulated animated-time Expr
+ * @param options     `volumetric` + an optional cheap `gradSampler` for the neighbour taps
+ */
+export declare function applyNeonEffect(params: GpuFragmentParams, sdfSampler: (uv: Expr) => Expr, time: Expr, options?: NeonEffectOptions): Expr;
+//# sourceMappingURL=neon.d.ts.map

package/dist/core/gpu/kit/effects/neon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"neon.d.ts","sourceRoot":"","sources":["../../../../src/gpu/kit/effects/neon.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,EAAO,CAAC,EAAM,MAAM,UAAU,CAAA;AAErC,OAAO,KAAK,EAAC,IAAI,EAAE,iBAAiB,EAAC,MAAM,gBAAgB,CAAA;AAa3D,uEAAuE;AACvE,MAAM,WAAW,kBAAkB;IAC/B,MAAM,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAC;IAAC,cAAc,EAAE,OAAO,CAAA;IAC3F,cAAc,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,OAAO,CAAC;IAAC,aAAa,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,OAAO,CAAA;IACvF,gBAAgB,EAAE,OAAO,CAAC;IAAC,aAAa,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,OAAO,CAAA;IAC3F,iBAAiB,EAAE,OAAO,CAAC;IAAC,YAAY,EAAE,OAAO,CAAC;IAAC,eAAe,EAAE,OAAO,CAAA;IAC3E,YAAY,EAAE,OAAO,CAAC;IAAC,aAAa,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,OAAO,CAAA;CACzF;AAED,MAAM,WAAW,iBAAiB;IAC9B,kGAAkG;IAClG,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,8FAA8F;IAC9F,WAAW,CAAC,EAAE,CAAC,EAAE,EAAE,IAAI,KAAK,IAAI,CAAA;CACnC;AAMD,4FAA4F;AAC5F,eAAO,MAAM,aAAa,sGAKxB,CAAA;AAEF;0FAC0F;AAC1F,eAAO,MAAM,QAAQ,0FASnB,CAAA;AAEF;yCACyC;AACzC,eAAO,MAAM,WAAW,6FAStB,CAAA;AAEF,2FAA2F;AAC3F,eAAO,MAAM,QAAQ,uGAQnB,CAAA;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,ujBAgGpB,CAAA;AAMN;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC3B,MAAM,EAAE,iBAAiB,EACzB,UAAU,EAAE,CAAC,EAAE,EAAE,IAAI,KAAK,IAAI,EAC9B,IAAI,EAAE,IAAI,EACV,OAAO,CAAC,EAAE,iBAAiB,GAC5B,IAAI,CAwBN"}

package/dist/core/gpu/kit/effects/prism.d.ts

@@ -0,0 +1,111 @@
+import { d } from '../index';
+import { Expr, GpuFragmentParams } from '../../contract';
+
+/**
+ * Config uniform keys the prism builder reads. `center`/`scale`/
+ * `rotation` + the beam/fan/body appearance props are read on the GPU via `params.uniforms.<key>`;
+ * `shape`/`beamAngle`/`beamOffset`/`beamLength`/`refraction`/`dispersion`/`bounces` are read on the
+ * CPU via `params.getCpuValue(<key>)` for the per-frame trace.
+ */
+export interface PrismEffectUniforms {
+    center: unknown;
+    scale: unknown;
+    rotation: unknown;
+    shape: unknown;
+    refraction: unknown;
+    dispersion: unknown;
+    bounces: unknown;
+    beamAngle: unknown;
+    beamOffset: unknown;
+    beamWidth: unknown;
+    beamLength: unknown;
+    beamIntensity: unknown;
+    beamColor: unknown;
+    internalGlow: unknown;
+    fanIntensity: unknown;
+    saturation: unknown;
+    separation: unknown;
+    fanFalloff: unknown;
+    bodyColor: unknown;
+    bodyOpacity: unknown;
+    rimIntensity: unknown;
+}
+/**
+ * The synthetic `extraFields` the trace writes and the fragment reads. The parent's shader
+ * definition declares `extraFields: prismTraceExtraFields`. The 12 traced scalars are packed:
+ *   uEntry  = (entryA.x, entryA.y, entryB.x, entryB.y)   uEntryActive = 0/1
+ *   uSeg0..3 = (a.x, a.y, b.x, b.y) per internal segment  uSegW = (w0, w1, w2, w3)
+ *   uExit   = (exitPos.x, exitPos.y, exitDir.x, exitDir.y)
+ *   uFan    = (thetaRed, thetaViolet, fanSpread, fanActive)
+ *   uShape  = (sides, radius, shapePhi, 0)
+ */
+export declare const prismTraceExtraFields: {
+    readonly uEntry: {
+        readonly schema: d.Vec4f;
+        readonly initial: readonly [0.5, 0.5, 0.5, 0.5];
+    };
+    readonly uEntryActive: {
+        readonly schema: d.F32;
+        readonly initial: 0;
+    };
+    readonly uSeg0: {
+        readonly schema: d.Vec4f;
+        readonly initial: readonly [0.5, 0.5, 0.5, 0.5];
+    };
+    readonly uSeg1: {
+        readonly schema: d.Vec4f;
+        readonly initial: readonly [0.5, 0.5, 0.5, 0.5];
+    };
+    readonly uSeg2: {
+        readonly schema: d.Vec4f;
+        readonly initial: readonly [0.5, 0.5, 0.5, 0.5];
+    };
+    readonly uSeg3: {
+        readonly schema: d.Vec4f;
+        readonly initial: readonly [0.5, 0.5, 0.5, 0.5];
+    };
+    readonly uSegW: {
+        readonly schema: d.Vec4f;
+        readonly initial: readonly [0, 0, 0, 0];
+    };
+    readonly uExit: {
+        readonly schema: d.Vec4f;
+        readonly initial: readonly [0.5, 0.5, 1, 0];
+    };
+    readonly uFan: {
+        readonly schema: d.Vec4f;
+        readonly initial: readonly [0, 0, 0, 0];
+    };
+    readonly uShape: {
+        readonly schema: d.Vec4f;
+        readonly initial: readonly [3, 0.3, 0, 0];
+    };
+};
+/** Distance from p to segment a→b plus the parametric t along it. Returns `vec2(dist, t)`. Pure. */
+export declare const prismSegDistT: import('typegpu').TgpuFn<(p: d.Vec2f, a: d.Vec2f, b: d.Vec2f) => d.Vec2f>;
+/** Gaussian cross-section glow: `exp((d/half)² · −2.5)`. Pure — CPU-golden-testable. */
+export declare const prismGauss: import('typegpu').TgpuFn<(dd: d.F32, half: d.F32) => d.F32>;
+/**
+ * Spectral colour: smooth wavelength→RGB (no magenta wraparound). `t = 0` → deep red (700nm),
+ * `t = 1` → violet (400nm). Gaussian bumps (squared via mul, never pow — NaN for a negative base on
+ * the GPU); the small red lobe in the violet band makes violet read as violet. Pure —
+ * CPU-golden-testable. (`std.mix(700, 400, t)` is an all-integer mix → the endpoints are `d.f32`-
+ * wrapped so it types f32, not i32.)
+ */
+export declare const prismSpectral: import('typegpu').TgpuFn<(t: d.F32) => d.Vec3f>;
+/**
+ * The full per-pixel prism shade: incoming beam glow + 4 internal-segment glows + spectral exit fan
+ * + glassy polygon body. `p` is the field-space position; all traced geometry arrives PACKED (see
+ * `prismTraceExtraFields`) and the appearance uniforms follow. Returns `vec4(accum, cover)` (emitted
+ * light + coverage). Resolve-goldenable (the sub-fns carry the goldens).
+ */
+export declare const prismShade: import('typegpu').TgpuFn<(p: d.Vec2f, uEntry: d.Vec4f, uEntryActive: d.F32, uSeg0: d.Vec4f, uSeg1: d.Vec4f, uSeg2: d.Vec4f, uSeg3: d.Vec4f, uSegW: d.Vec4f, uExit: d.Vec4f, uFan: d.Vec4f, uShape: d.Vec4f, beamWidth: d.F32, beamColor: d.Vec3f, beamIntensity: d.F32, internalGlow: d.F32, fanIntensity: d.F32, saturation: d.F32, separation: d.F32, fanFalloff: d.F32, bodyColor: d.Vec3f, bodyOpacity: d.F32, rimIntensity: d.F32) => d.Vec4f>;
+/**
+ * Apply the Prism spectral generator. Composition-time Expr builder — see the file header for the
+ * notes. A luminous transparent-interior generator (no child): RGB is emitted light, alpha is
+ * coverage; composite over a dark background with `screen` / `linearDodge`.
+ *
+ * REQUIRES the parent's shader definition to declare `extraFields: prismTraceExtraFields`.
+ */
+export declare function applyPrismEffect(params: GpuFragmentParams): Expr;
+//# sourceMappingURL=prism.d.ts.map

package/dist/core/gpu/kit/effects/prism.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prism.d.ts","sourceRoot":"","sources":["../../../../src/gpu/kit/effects/prism.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,EAAO,CAAC,EAAM,MAAM,UAAU,CAAA;AAErC,OAAO,KAAK,EAAC,IAAI,EAAE,iBAAiB,EAAC,MAAM,gBAAgB,CAAA;AAI3D;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB;IAChC,MAAM,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;IAClE,UAAU,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;IAC1D,SAAS,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,OAAO,CAAA;IAChF,aAAa,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,OAAO,CAAC;IAAC,YAAY,EAAE,OAAO,CAAA;IACjE,YAAY,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,OAAO,CAAA;IACpF,SAAS,EAAE,OAAO,CAAC;IAAC,WAAW,EAAE,OAAO,CAAC;IAAC,YAAY,EAAE,OAAO,CAAA;CAClE;AAMD;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAWxB,CAAA;AA+HV,oGAAoG;AACpG,eAAO,MAAM,aAAa,2EAOxB,CAAA;AAEF,wFAAwF;AACxF,eAAO,MAAM,UAAU,6DAIrB,CAAA;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,iDAWxB,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,UAAU,qbAyFjB,CAAA;AAMN;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,iBAAiB,GAAG,IAAI,CA8GhE"}