shaders 3.1.463 → 3.2.464

package/dist/core/std/paint/fields.d.ts

@@ -0,0 +1,179 @@
+import { Expr, GpuFragmentParams } from '../../gpu/contract';
+import { PropRef } from '../values';
+import { ArgSpec } from '../invoke';
+
+/** A generator paint — what a `role: 'generator'` definition's `paint:` field takes. */
+export type Paint = (params: GpuFragmentParams) => Expr;
+/** A scalar field over a coordinate. Metric fields take a vec2 UV; domain combinators may pass vec3. */
+export type Field = (params: GpuFragmentParams, coord: Expr) => Expr;
+/** A colour lookup at a field parameter t ∈ [0,1]. Build via {@link pair} or {@link stops}. */
+export type Palette = (t: Expr, params: GpuFragmentParams) => Expr;
+/**
+ * A scalar slot: a prop/scalar/number, optionally affine-mapped — `{base, add, mul}`
+ * resolves to `(base + add) * mul` (for props whose UI range needs remapping into the
+ * field's own units, e.g. a 0–100 balance slider to a ±0.3 bias).
+ */
+export type FieldScalar = ArgSpec | {
+    base: ArgSpec;
+    add?: number;
+    mul?: number;
+};
+/**
+ * Compile-time colour-space mode reader — robust to a raw string (a preset loaded before the
+ * prop transform ran) as well as the bridge-mapped number.
+ */
+export declare function colorSpaceModeOf(raw: unknown): number;
+/** Two endpoint colour props mixed in the structural `space`. */
+export declare function pair(a: PropRef, b: PropRef, space: PropRef): Palette;
+/**
+ * The standard stop ramp: when the `stops` prop packs >1 active stops (the fixed
+ * `colorsArray`/`positionsArray`/`convertedColorsArray`/`stopCount` uniforms from
+ * `colorStopsPropConfig`), the working-space accumulation loop runs; otherwise it falls
+ * back to the `colorA`/`colorB` pair. Both in the structural `space`.
+ */
+export declare function stops(space: PropRef): Palette;
+/**
+ * The generator paint: evaluate `field` at the composed UV and look its parameter up in
+ * `palette`. With an `edges` slot (a structural prop) the parameter is edge-handled first —
+ * stretch (clamp), transparent (alpha fades to 0 outside the [0,1] band), mirror, or wrap —
+ * and clamped for the colour lookup. Without one, the field's parameter feeds the palette
+ * raw (fields that bound themselves — rings, sweeps, tone — need no clamp).
+ */
+export declare function rampOver(field: Field, palette: Palette, opts?: {
+    edges?: PropRef;
+}): Paint;
+/** Metric-distance field producers — each maps the screen UV to a raw gradient parameter. */
+export declare const dist: {
+    /** Projection onto the `from`→`to` axis, rotated by `angle` (degrees) about the midpoint. */
+    linear(slots: {
+        from: PropRef;
+        to: PropRef;
+        angle: FieldScalar;
+    }): Field;
+    /** Elliptical radial distance from `center`, normalized by `radius`; `aspect` stretches, `skew` rotates the axis. */
+    radial(slots: {
+        center: PropRef;
+        radius: FieldScalar;
+        aspect: FieldScalar;
+        skew: FieldScalar;
+    }): Field;
+    /** Angular sweep around `center`, CCW from 3-o'clock, shifted by `rotation` (degrees). */
+    conic(slots: {
+        center: PropRef;
+        rotation: FieldScalar;
+    }): Field;
+    /** Diamond (L1 → L∞ via `roundness`) distance from `center`, tilted by `rotation`, normalized by `size`. */
+    diamond(slots: {
+        center: PropRef;
+        size: FieldScalar;
+        rotation: FieldScalar;
+        roundness: FieldScalar;
+    }): Field;
+    /**
+     * Animated spiral stripe coverage around `center` (0 = background, 1 = stroke), spun by
+     * the definition's `animatedTime` clock. Stays a fused kit body: its anti-aliasing reads
+     * `fwidth` of the spiral parameter, so the offset must be derived inside the same
+     * fragment-scope function the derivatives sample.
+     */
+    spiral(slots: {
+        center: PropRef;
+        scale: FieldScalar;
+        width: FieldScalar;
+        falloff: FieldScalar;
+        softness: FieldScalar;
+    }): Field;
+};
+/** Concentric repetition: `count` ≤ 1 clamps, above 1 tiles rings via fract (a runtime select). */
+export declare function rings(field: Field, count: FieldScalar): Field;
+/** Wrapped repetition: every cycle tiles via fract (angular sweeps, starbursts). */
+export declare function tiles(field: Field, count: FieldScalar): Field;
+/**
+ * Tone-shape a unit field: `glow` spreads via pow, `contrast` is multiplicative around
+ * mid-grey, `balance` is a percent-centred (0–100) shift, `invert` flips the result so a
+ * multi-stop ramp's stop0…stopN reads in the expected direction. Currently the glow-gamma
+ * inverted shape (the one the kit tone library implements for unit fields).
+ */
+export declare function tone(field: Field, opts: {
+    glow: FieldScalar;
+    contrast: FieldScalar;
+    balance: FieldScalar;
+    invert: true;
+}): Field;
+/** Soft threshold over a signed [-1,1] field: normalize to [0,1], add `bias`, smoothstep `low`→`high`. */
+export declare function threshold(field: Field, opts: {
+    low: number;
+    high: number;
+    bias?: FieldScalar;
+}): Field;
+/**
+ * Share one field evaluation between consumers: the first read binds a WGSL local, later
+ * reads reuse it (a threshold and a shimmer reading the same flow pattern must not
+ * re-derive it). Cached per composition.
+ */
+export declare function share(field: Field): Field;
+/** Noise bases usable as a {@link noiseField} — unit-range ([0,1]) samples over a vec3 coordinate. */
+declare const NOISE_BASES: {
+    /** MaterialX 3D noise, unit-biased. Hash-based (bit-cast) → GPU-only. */
+    readonly mx3: {
+        readonly fn: () => import('typegpu').TgpuFn<(pos: import('typegpu/data').Vec3f) => import('typegpu/data').F32>;
+        readonly hint: "unitNoise3";
+    };
+    /** 3D Perlin gradient noise, ~[0,1]. Hash-based (bit-cast) → GPU-only. */
+    readonly perlin: {
+        readonly fn: () => import('typegpu').TgpuFn<(p: import('typegpu/data').Vec3f) => import('typegpu/data').F32>;
+        readonly hint: "perlin13";
+    };
+    /** 3D value noise — soft blocky cells (Quilez permutation), [0,1]. Pure float. */
+    readonly value: {
+        readonly fn: () => import('typegpu').TgpuFn<(p: import('typegpu/data').Vec3f) => import('typegpu/data').F32>;
+        readonly hint: "value13";
+    };
+    /** RAW MaterialX 3D noise, signed [-1,1] — pair with a signed tone. GPU-only. */
+    readonly mx3signed: {
+        readonly fn: () => import('typegpu').TgpuFn<(p: import('typegpu/data').Vec3f) => import('typegpu/data').F32>;
+        readonly hint: "mxNoiseFloat3";
+    };
+};
+export type NoiseBasis = keyof typeof NOISE_BASES;
+/** Sample a noise basis at the incoming (vec3) coordinate. Compose under a domain producer. */
+export declare function noiseField(basis: NoiseBasis): Field;
+/**
+ * Domain-warp the inner field's coordinate (Inigo-Quilez two-level warp over the given
+ * noise basis): noise displaces the sampling position before feeding the field, which is
+ * what turns smooth noise into flowing plasma. `amount` (optionally pre-scaled by
+ * `amountScale`) sets the displacement; the warp evolves on the definition's
+ * `animatedTime` clock scaled by `timeScale`.
+ */
+export declare function warped(field: Field, opts: {
+    amount: FieldScalar;
+    amountScale?: number;
+    timeScale?: number;
+}): Field;
+/** Lift a vec3-coordinate field onto the screen: aspect-corrected z=0 slab, zoomed exponentially by `scale`. */
+export declare function scaledVolume(field: Field, opts: {
+    scale: FieldScalar;
+}): Field;
+/**
+ * The layered trig flow pattern: three nested sin/cos layers, each domain-warping the
+ * previous, combined into one signed [-1,1] field. Animated by the definition's
+ * `animatedTime` clock; reads the raw coordinate it is given (no aspect correction — the
+ * pattern is viewport-relative by design).
+ */
+export declare function flowField(slots: {
+    detail: FieldScalar;
+}): Field;
+/** A subtle brightness pulse from a pattern field: `sin(t·speed + pattern·span)·depth + 1`. */
+export declare function pulse(field: Field, opts: {
+    speed: number;
+    span: number;
+    depth: number;
+}): Field;
+/**
+ * The classic six-segment hue wheel: a cyclic hue coordinate (any real; wraps) → rgb.
+ * The rotating-rainbow palette (Prism's fan, ColorWheel-class effects).
+ */
+export declare function hueWheel(h: Expr): Expr;
+/** Scale a paint's whole colour (rgb AND alpha) by a gain field evaluated at the raw canvas UV. */
+export declare function shimmered(paint: Paint, gain: Field): Paint;
+export {};
+//# sourceMappingURL=fields.d.ts.map

package/dist/core/std/paint/fields.d.ts.map

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

package/dist/core/std/paint/figures.d.ts

@@ -0,0 +1,87 @@
+import { Expr, GpuFragmentParams } from '../../gpu/contract';
+import { PropRef } from '../values';
+import { ArgSpec } from '../invoke';
+
+/** A generator paint: the composition builder a `role: 'generator'` definition runs. */
+export type Paint = (params: GpuFragmentParams) => Expr;
+/** The {@link strokedSegment} noun's slots. */
+export interface StrokedSegmentSlots {
+    /** The segment endpoints (position props). */
+    from: PropRef;
+    to: PropRef;
+    /** Stroke thickness in canvas-height units. */
+    width: ArgSpec;
+    /** Line style as a runtime mode number (solid 0 / dashed 1 / dotted 2). */
+    style: ArgSpec;
+    /** Dash length (including caps) and the gap between dashes / spacing between dots. */
+    dashLength: ArgSpec;
+    gapLength: ArgSpec;
+    /** Cap shape per end as a runtime mode number (square 0 / rounded 1). */
+    capStart: ArgSpec;
+    capEnd: ArgSpec;
+    /** The stroke color prop. */
+    color: PropRef;
+}
+/**
+ * A straight stroked segment between two points: per-end square/rounded caps, and dash/dot
+ * patterns rescaled to land exactly on both endpoints. Antialiased with a ~1px device-space
+ * feather at any thickness; degenerate (coincident) endpoints render a single cap-shaped point.
+ */
+export declare function strokedSegment(slots: StrokedSegmentSlots): Paint;
+/** The {@link sineStroke} noun's slots. */
+export interface SineStrokeSlots {
+    /** The wave's center (a position prop) and rotation in degrees. */
+    position: PropRef;
+    angle: ArgSpec;
+    /** Cycle count across the frame and wave height. */
+    frequency: ArgSpec;
+    amplitude: ArgSpec;
+    /** Band thickness and edge softness of the stroke. */
+    thickness: ArgSpec;
+    softness: ArgSpec;
+    /** The stroke color prop. */
+    color: PropRef;
+}
+/**
+ * A traveling sine-wave stroke: a soft band of `thickness`/`softness` around an animated sine
+ * centered on `position` and rotated by `angle`. Reads the definition's per-node animated time
+ * (declare `animatedTime: {speed: ...}` on the definition).
+ */
+export declare function sineStroke(slots: SineStrokeSlots): Paint;
+/** The {@link blob} noun's slots. */
+export interface BlobSlots {
+    /** The blob's center (a position prop). */
+    center: PropRef;
+    /** Base radius, organic wobble amount, and edge softness. */
+    size: ArgSpec;
+    deformation: ArgSpec;
+    softness: ArgSpec;
+    /** Specular highlight: intensity, the raw light-direction props, and the highlight color. */
+    highlightIntensity: ArgSpec;
+    light: {
+        x: PropRef;
+        y: PropRef;
+        z: PropRef;
+    };
+    highlightColor: PropRef;
+    /** The gradient endpoint colors (overridden by a multi-stop `stops` prop when active). */
+    colors: {
+        a: PropRef;
+        b: PropRef;
+    };
+    /** The compile-time color-space prop the gradient mixes in. */
+    colorSpace: PropRef;
+    /** Seed prop added to the animated-time read for pattern variation. */
+    seed: PropRef;
+}
+/**
+ * An organic animated blob: a four-layer sine-noise radius field with a power-curve soft edge,
+ * a fake-3D specular highlight, and a fluid two-color (or multi-stop) gradient. Reads the
+ * definition's per-node animated time plus the seed offset.
+ *
+ * The light direction is normalized on the CPU each frame and written to the definition's
+ * `normLx`/`normLy`/`normLz` extraFields (declare them on the definition), which avoids a
+ * per-fragment normalize(). Uses the RAW canvas viewport for aspect (no resize-fit box).
+ */
+export declare function blob(slots: BlobSlots): Paint;
+//# sourceMappingURL=figures.d.ts.map

package/dist/core/std/paint/figures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"figures.d.ts","sourceRoot":"","sources":["../../../src/std/paint/figures.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,KAAK,EAAC,IAAI,EAAE,iBAAiB,EAAC,MAAM,oBAAoB,CAAA;AAG/D,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,WAAW,CAAA;AAGtC,OAAO,EAA2B,KAAK,OAAO,EAAC,MAAM,WAAW,CAAA;AAEhE,wFAAwF;AACxF,MAAM,MAAM,KAAK,GAAG,CAAC,MAAM,EAAE,iBAAiB,KAAK,IAAI,CAAA;AA2BvD,+CAA+C;AAC/C,MAAM,WAAW,mBAAmB;IAChC,8CAA8C;IAC9C,IAAI,EAAE,OAAO,CAAA;IACb,EAAE,EAAE,OAAO,CAAA;IACX,+CAA+C;IAC/C,KAAK,EAAE,OAAO,CAAA;IACd,2EAA2E;IAC3E,KAAK,EAAE,OAAO,CAAA;IACd,sFAAsF;IACtF,UAAU,EAAE,OAAO,CAAA;IACnB,SAAS,EAAE,OAAO,CAAA;IAClB,yEAAyE;IACzE,QAAQ,EAAE,OAAO,CAAA;IACjB,MAAM,EAAE,OAAO,CAAA;IACf,6BAA6B;IAC7B,KAAK,EAAE,OAAO,CAAA;CACjB;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,mBAAmB,GAAG,KAAK,CAiBhE;AAID,2CAA2C;AAC3C,MAAM,WAAW,eAAe;IAC5B,mEAAmE;IACnE,QAAQ,EAAE,OAAO,CAAA;IACjB,KAAK,EAAE,OAAO,CAAA;IACd,oDAAoD;IACpD,SAAS,EAAE,OAAO,CAAA;IAClB,SAAS,EAAE,OAAO,CAAA;IAClB,sDAAsD;IACtD,SAAS,EAAE,OAAO,CAAA;IAClB,QAAQ,EAAE,OAAO,CAAA;IACjB,6BAA6B;IAC7B,KAAK,EAAE,OAAO,CAAA;CACjB;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,eAAe,GAAG,KAAK,CAgBxD;AAID,qCAAqC;AACrC,MAAM,WAAW,SAAS;IACtB,2CAA2C;IAC3C,MAAM,EAAE,OAAO,CAAA;IACf,6DAA6D;IAC7D,IAAI,EAAE,OAAO,CAAA;IACb,WAAW,EAAE,OAAO,CAAA;IACpB,QAAQ,EAAE,OAAO,CAAA;IACjB,6FAA6F;IAC7F,kBAAkB,EAAE,OAAO,CAAA;IAC3B,KAAK,EAAE;QAAC,CAAC,EAAE,OAAO,CAAC;QAAC,CAAC,EAAE,OAAO,CAAC;QAAC,CAAC,EAAE,OAAO,CAAA;KAAC,CAAA;IAC3C,cAAc,EAAE,OAAO,CAAA;IACvB,0FAA0F;IAC1F,MAAM,EAAE;QAAC,CAAC,EAAE,OAAO,CAAC;QAAC,CAAC,EAAE,OAAO,CAAA;KAAC,CAAA;IAChC,+DAA+D;IAC/D,UAAU,EAAE,OAAO,CAAA;IACnB,uEAAuE;IACvE,IAAI,EAAE,OAAO,CAAA;CAChB;AAED;;;;;;;;GAQG;AACH,wBAAgB,IAAI,CAAC,KAAK,EAAE,SAAS,GAAG,KAAK,CAgE5C"}

package/dist/core/std/paint/gradients.d.ts

@@ -0,0 +1,89 @@
+import { Expr, GpuFragmentParams } from '../../gpu/contract';
+import { d } from '../../gpu/kit/index';
+import { PropRef } from '../values';
+import { ArgSpec } from '../invoke';
+
+/** A generator paint: the composition builder a `role: 'generator'` definition runs. */
+export type Paint = (params: GpuFragmentParams) => Expr;
+/**
+ * Fill with a single colour. The bound prop is already a P3-linear rgba uniform, so the
+ * paint is a direct read; alpha passes through, so a half-transparent fill composites
+ * correctly.
+ */
+export declare function solidColor(color: PropRef): Paint;
+/**
+ * A directional gradient that cycles through colours over time (the definition's
+ * `animatedTime` clock). `mode` (structural) selects the procedural rainbow spectrum or a
+ * custom three-colour loop `a`→`b`→`c`→`a`, each transition mixed in the structural
+ * `space` (rainbow generates colours, so `space` does not apply there). `direction`
+ * (degrees) spins the gradient in place about the canvas centre; `scale` sets how many
+ * cycles span the viewport.
+ */
+export declare function colorWheel(slots: {
+    mode: PropRef;
+    direction: ArgSpec;
+    scale: ArgSpec;
+    palette: {
+        a: PropRef;
+        b: PropRef;
+        c: PropRef;
+    };
+    space: PropRef;
+}): Paint;
+/**
+ * Five individually placed colour points blended by inverse-distance proximity. The kit
+ * body returns the four incremental running-weighted-average factors; the paint folds the
+ * five colours through them, each mix in the structural `space`. `smoothness` inverts into
+ * the distance power (higher = blobs spread further). Exactly five points.
+ */
+export declare function pointCloudGradient(slots: {
+    points: {
+        color: PropRef;
+        position: PropRef;
+    }[];
+    smoothness: ArgSpec;
+    space: PropRef;
+}): Paint;
+/**
+ * The `extraFields` the {@link beam} paint drives: for a non-linear colour space the
+ * forward P3→working-space conversion of the two endpoint colours is pixel-invariant, so
+ * it is computed ONCE per frame on the CPU (dirty-keyed) into these vec3 fields and read
+ * on the GPU by `mixPreconvertedVariants[mode]`. Declare on the definition alongside the
+ * paint.
+ */
+export declare const beamPreconvertedFields: {
+    convA: {
+        schema: d.Vec3f;
+        initial: number[];
+    };
+    convB: {
+        schema: d.Vec3f;
+        initial: number[];
+    };
+};
+/**
+ * A beam of light from `from` to `to`: the pixel projects onto the segment, thickness and
+ * softness taper between the `start`/`end` values along it, and the cross-section shades
+ * `colors.inside` → `colors.outside` with a glow alpha. The structural `space` selects the
+ * mix: linear mixes per pixel; a non-linear space preconverts both endpoints on the CPU
+ * each frame into {@link beamPreconvertedFields} and pays only the weighted mix +
+ * back-conversion per pixel. Alpha is the endpoint average scaled by the glow.
+ */
+export declare function beam(slots: {
+    from: PropRef;
+    to: PropRef;
+    thickness: {
+        start: ArgSpec;
+        end: ArgSpec;
+    };
+    softness: {
+        start: ArgSpec;
+        end: ArgSpec;
+    };
+    colors: {
+        inside: PropRef;
+        outside: PropRef;
+    };
+    space: PropRef;
+}): Paint;
+//# sourceMappingURL=gradients.d.ts.map

package/dist/core/std/paint/gradients.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gradients.d.ts","sourceRoot":"","sources":["../../../src/std/paint/gradients.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,KAAK,EAAC,IAAI,EAAE,iBAAiB,EAAC,MAAM,oBAAoB,CAAA;AAG/D,OAAO,EAAC,CAAC,EAA8B,MAAM,qBAAqB,CAAA;AAClE,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,WAAW,CAAA;AAGtC,OAAO,EAA2B,KAAK,OAAO,EAAC,MAAM,WAAW,CAAA;AAEhE,wFAAwF;AACxF,MAAM,MAAM,KAAK,GAAG,CAAC,MAAM,EAAE,iBAAiB,KAAK,IAAI,CAAA;AA0BvD;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,CAEhD;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE;IAC9B,IAAI,EAAE,OAAO,CAAA;IACb,SAAS,EAAE,OAAO,CAAA;IAClB,KAAK,EAAE,OAAO,CAAA;IACd,OAAO,EAAE;QAAC,CAAC,EAAE,OAAO,CAAC;QAAC,CAAC,EAAE,OAAO,CAAC;QAAC,CAAC,EAAE,OAAO,CAAA;KAAC,CAAA;IAC7C,KAAK,EAAE,OAAO,CAAA;CACjB,GAAG,KAAK,CAyBR;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE;IACtC,MAAM,EAAE;QAAC,KAAK,EAAE,OAAO,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAA;KAAC,EAAE,CAAA;IAC7C,UAAU,EAAE,OAAO,CAAA;IACnB,KAAK,EAAE,OAAO,CAAA;CACjB,GAAG,KAAK,CAkBR;AAED;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;CAGlC,CAAA;AAED;;;;;;;GAOG;AACH,wBAAgB,IAAI,CAAC,KAAK,EAAE;IACxB,IAAI,EAAE,OAAO,CAAA;IACb,EAAE,EAAE,OAAO,CAAA;IACX,SAAS,EAAE;QAAC,KAAK,EAAE,OAAO,CAAC;QAAC,GAAG,EAAE,OAAO,CAAA;KAAC,CAAA;IACzC,QAAQ,EAAE;QAAC,KAAK,EAAE,OAAO,CAAC;QAAC,GAAG,EAAE,OAAO,CAAA;KAAC,CAAA;IACxC,MAAM,EAAE;QAAC,MAAM,EAAE,OAAO,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAC,CAAA;IAC3C,KAAK,EAAE,OAAO,CAAA;CACjB,GAAG,KAAK,CA4CR"}

package/dist/core/std/paint/light.d.ts

@@ -0,0 +1,218 @@
+import { Expr, GpuFragmentParams } from '../../gpu/contract';
+import { FilterParams } from '../../gpu/scaffolds/pointwiseFilter';
+import { PointwiseEffect } from '../types';
+import { PropRef } from '../values';
+import { ArgSpec } from '../invoke';
+
+/** A lowered light value — evaluate against the composition params. */
+export type LightValue = (params: GpuFragmentParams) => Expr;
+/**
+ * A light part over a frame's local coordinates. Radial-frame parts read
+ * `vec2(dist, angle)`; beam-frame parts read `vec2(u, v)`.
+ */
+export type LightPart = (frame: Expr, params: GpuFragmentParams) => Expr;
+/**
+ * Distance + angle (`vec2(dist, angle)`) around an unflipped centre prop in aspect-corrected
+ * space — the radial frame of a burst, halo or sweep.
+ */
+export declare function radialFrame(center: PropRef): LightValue;
+/**
+ * The seam-free radial frame volumetric rays march in — distance plus a wrap-free angular
+ * coordinate around `center`.
+ */
+export declare function seamlessRadialFrame(center: PropRef): LightValue;
+/**
+ * The local frame of a beam anchored at a point and aimed at the canvas centre:
+ * `vec2(u, v)` — distance along the beam and lateral offset — in aspect-corrected space.
+ * Reads the raw filter context (a pointwise effect's frame, not a generator's).
+ */
+export declare function beamFrame(anchor: PropRef): LightValue;
+/**
+ * Evaluate a light part in a frame — the composition root of a framed light recipe. A `hint`
+ * names the stage and binds the frame as a WGSL local (required when the part reads the frame
+ * more than once).
+ */
+export declare function withFrame(frame: LightValue, part: LightPart, hint?: string): LightValue;
+/** Multiply light parts over one frame (a mask over a pattern). */
+export declare function modulate(first: LightPart, ...rest: LightPart[]): LightPart;
+/** Rotating sine ray lobes around the frame angle — `count` lobes, spun by the animated clock × `spin`, narrowed by `sharpness`. */
+export declare function rayLobes(slots: {
+    count: ArgSpec;
+    spin: number;
+    sharpness: ArgSpec;
+}): LightPart;
+/**
+ * {@link rayLobes} driven by a designer-facing softness slider (softness inverts into the lobe
+ * exponent, so soft rays widen without moving their centres). `spin` scales the animated clock
+ * (negative = clockwise).
+ */
+export declare function softRayLobes(slots: {
+    count: ArgSpec;
+    softness: ArgSpec;
+    spin: number;
+}): LightPart;
+/** Diffraction-style spikes with hard nulls — pass `blades / 2` as `halfCount`; high power thins. */
+export declare function raySpikes(slots: {
+    halfCount: ArgSpec;
+    power: ArgSpec;
+}): LightPart;
+/** Three concentric chromatic ring bands (R outside, B inside for positive spread) as an RGB. */
+export declare function ringBand(slots: {
+    center: ArgSpec;
+    spread: ArgSpec;
+    width: ArgSpec;
+}): LightPart;
+/** An isotropic Gaussian falloff over the frame distance: `exp(-(dist² · sharpness))`. */
+export declare function glowPoint(slots: {
+    sharpness: ArgSpec;
+}): LightPart;
+/** The outer fade of a bounded radial light: 1 inside `radius`, fading over the last `feather` fraction. */
+export declare function featherMask(slots: {
+    radius: ArgSpec;
+    feather: ArgSpec;
+}): LightPart;
+/**
+ * Two seam-free noise layers accumulated into a volumetric ray coverage over the frame,
+ * animated on the definition's clock: `density` sets sector frequency, `intensity` ray
+ * visibility, `spotty` the spot density along each ray.
+ */
+export declare function noiseRays(slots: {
+    density: ArgSpec;
+    intensity: ArgSpec;
+    spotty: ArgSpec;
+}): LightPart;
+/**
+ * The slow drift/breathing signal pack of a bleeding light: breath gain in `.x`, streak drift
+ * offsets in the rest. `flicker` sets the breathing depth, `seed` re-rolls the pattern.
+ */
+export declare function slowDrift(slots: {
+    seed: ArgSpec;
+    flicker: ArgSpec;
+}): (clock: Expr, params: GpuFragmentParams) => Expr;
+/** The main anisotropic glow pool (`.x`) and its wider shoulder (`.y`) along a beam frame. */
+export declare function beamBloom(slots: {
+    spread: ArgSpec;
+}): (frame: Expr, drift: Expr, params: GpuFragmentParams) => Expr;
+/** Drifting parallel streak bands further into the frame along the beam. */
+export declare function beamStreaks(slots: {
+    spread: ArgSpec;
+    strength: ArgSpec;
+}): (frame: Expr, drift: Expr, params: GpuFragmentParams) => Expr;
+/** Hash dither over a heat field to hide ramp banding. */
+export declare function dithered(heat: Expr, uv: Expr, clock: Expr): Expr;
+/**
+ * An elliptical Gaussian glow over a pre-normalized 2D offset (each axis already divided by its
+ * own radius): `exp(-(du² + dv²) · sharpness)`. The core of a bloom, a glare, or a soft pool.
+ */
+export declare function glowSpot(du: Expr, dv: Expr, sharpness: Expr): Expr;
+/** One soft Gaussian band across a 1D coordinate, peaking at `center` with the given `width`. */
+export declare function streakBand(u: Expr, center: Expr, width: Expr): Expr;
+/** Project a point onto a segment: `vec2(t, distance)` with `t` clamped to [0,1]. */
+export declare function segmentProject(p: Expr, a: Expr, b: Expr): Expr;
+/**
+ * The glow cross-section of a tapered beam: thickness/softness interpolate end-to-end along the
+ * segment parameter; returns `vec2(colorT, alpha)`.
+ */
+export declare function lightBeam(dist: Expr, t: Expr, thickness: {
+    start: Expr;
+    end: Expr;
+}, softness: {
+    start: Expr;
+    end: Expr;
+}): Expr;
+/**
+ * The shared frame of a camera flare: light position, flare axis, master fade (intensity ×
+ * edge fade × shimmer), and the pixel's polar coordinates about the light.
+ */
+export declare function flareFrame(slots: {
+    position: PropRef;
+    intensity: ArgSpec;
+    edgeFade: ArgSpec;
+}): LightValue;
+/**
+ * One internal-reflection ghost disc along the flare axis: `disc` = offset/size/bright/hollow,
+ * `tint` = r/g/b/gPhase.
+ */
+export declare function lensGhost(slots: {
+    intensity: ArgSpec;
+    spread: ArgSpec;
+    chroma: ArgSpec;
+}): (flare: Expr, disc: [number, number, number, number], tint: [number, number, number, number], params: GpuFragmentParams) => Expr;
+/** The chromatic halo ring about the light. */
+export declare function flareHalo(slots: {
+    intensity: ArgSpec;
+    radius: ArgSpec;
+    chroma: ArgSpec;
+    softness: ArgSpec;
+}): (flare: Expr, params: GpuFragmentParams) => Expr;
+/** The diffraction-spike starburst about the light. */
+export declare function flareStarburst(slots: {
+    intensity: ArgSpec;
+    points: ArgSpec;
+}): (flare: Expr, params: GpuFragmentParams) => Expr;
+/** The anamorphic horizontal streak through the light. */
+export declare function flareStreak(slots: {
+    intensity: ArgSpec;
+    length: ArgSpec;
+}): (flare: Expr, params: GpuFragmentParams) => Expr;
+/** The broad veiling glare about the light. */
+export declare function flareGlare(slots: {
+    intensity: ArgSpec;
+    size: ArgSpec;
+}): (flare: Expr, params: GpuFragmentParams) => Expr;
+/** The bright core at the light itself. */
+export declare function flareCore(slots: {
+    intensity: ArgSpec;
+}): (flare: Expr, params: GpuFragmentParams) => Expr;
+/** Finish an additive light stack: scale by the frame's master fade with a luminance-derived alpha. */
+export declare function flareComposite(total: Expr, flare: Expr): Expr;
+/**
+ * Quadratic corner-darkening mask about the frame centre, aspect-corrected from the effective
+ * viewport. `strength` 0 disables it; `scale` remaps a designer-range slider into mask units.
+ */
+export declare function vignetteMask(slots: {
+    strength: ArgSpec;
+    scale?: number;
+}): LightValue;
+/** Sum additive light contributions: `a + b + c + …` in the given order. */
+export declare function additive(first: Expr, ...rest: Expr[]): Expr;
+/**
+ * A slot-bound overexposure ramp (fringe → mid → hot, with chromatic per-channel taps): binds the
+ * three ramp colour props and yields the RGB of any heat field. The visible "colour story" part
+ * of a light leak or glow.
+ */
+export declare function heatRamp(colors: {
+    hot: PropRef;
+    mid: PropRef;
+    fringe: PropRef;
+}): {
+    kind: "heatRamp";
+    /** The chromatic RGB of a heat field (three offset ramp taps). */
+    taps: (heat: Expr, params: {
+        uniforms: Record<string, Expr>;
+    }) => Expr;
+};
+export type HeatRamp = ReturnType<typeof heatRamp>;
+/**
+ * Mix `color` over `background` component-wise (rgb AND alpha) by a coverage field; `hint`
+ * names the coverage stage's WGSL local.
+ */
+export declare function coverageMix(slots: {
+    color: PropRef;
+    background: PropRef;
+    coverage: LightValue;
+    hint?: string;
+}): LightValue;
+/** Straight-alpha composite of `color` over `background` by a coverage field (linear RGB). */
+export declare function coverageOver(slots: {
+    color: PropRef;
+    background: PropRef;
+    coverage: LightValue;
+}): LightValue;
+/**
+ * Screen-composite an emitted glow RGB over the child, exposure-style: screen blend +
+ * overexposure push + a slight halation lift; emitted light raises alpha over transparent
+ * areas too. The pointwise composition root of a light-bleed filter.
+ */
+export declare function screenGlow(glow: (params: FilterParams) => Expr): PointwiseEffect;
+//# sourceMappingURL=light.d.ts.map

package/dist/core/std/paint/light.d.ts.map

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