shaders 3.1.463 → 3.2.465

package/dist/core/std/motion.d.ts

@@ -0,0 +1,53 @@
+import { Expr } from '../gpu/contract';
+import { Scalar } from './values';
+
+/** Position within a repeating cycle, 0..1 (`fract(t / period)`). */
+export declare function phase(t: Expr, period: Expr | number): Expr;
+/**
+ * A repeating cycle: `progress` (0..1 within the cycle) and `index` (which cycle this
+ * is) — the "every N seconds" word. Feed `index` to {@link cycleSeed} for something
+ * random-but-stable per pass (a meteor's angle, a glitch's offset).
+ */
+export declare function cycle(t: Expr, period: Expr | number): {
+    progress: Expr;
+    index: Expr;
+};
+/** A random-but-stable 0..1 value per cycle index (change `salt` for independent draws). */
+export declare function cycleSeed(index: Expr, salt?: number): Expr;
+/**
+ * An on/off rhythm: 1 for the first `duty` fraction of each cycle, 0 for the rest.
+ * `soften` (cycle-fraction units) eases both edges; 0 is a hard blink.
+ */
+export declare function pulseTrain(t: Expr, opts: {
+    period: Expr | number;
+    duty: Expr | number;
+    soften?: number;
+}): Expr;
+/** A sine sweep between `min` and `max` at `rate` cycles per second. */
+export declare function oscillate(t: Expr, opts: {
+    rate?: number;
+    min?: Expr | number;
+    max?: Expr | number;
+    offset?: number;
+}): Expr;
+export declare const easeIn: (x: Expr) => Expr;
+export declare const easeOut: (x: Expr) => Expr;
+export declare const easeInOut: (x: Expr) => Expr;
+type SignalClock = 'global' | 'node';
+/** {@link oscillate} as a slot signal. */
+export declare function oscillating(opts: {
+    rate?: number;
+    min?: Expr | number;
+    max?: Expr | number;
+    offset?: number;
+    clock?: SignalClock;
+}): Scalar;
+/** {@link pulseTrain} as a slot signal. */
+export declare function pulsing(opts: {
+    period: number;
+    duty: number;
+    soften?: number;
+    clock?: SignalClock;
+}): Scalar;
+export {};
+//# sourceMappingURL=motion.d.ts.map

package/dist/core/std/motion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"motion.d.ts","sourceRoot":"","sources":["../../src/std/motion.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,iBAAiB,CAAA;AAGzC,OAAO,EAAC,MAAM,EAAwB,MAAM,UAAU,CAAA;AAItD,qEAAqE;AACrE,wBAAgB,KAAK,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,GAAG,MAAM,GAAG,IAAI,CAE1D;AAED;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,GAAG,MAAM,GAAG;IAAC,QAAQ,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,IAAI,CAAA;CAAC,CAGnF;AAED,4FAA4F;AAC5F,wBAAgB,SAAS,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,SAAI,GAAG,IAAI,CAErD;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE;IAAC,MAAM,EAAE,IAAI,GAAG,MAAM,CAAC;IAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAC,GAAG,IAAI,CAO7G;AAED,wEAAwE;AACxE,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,IAAI,GAAG,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,IAAI,GAAG,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAC,GAAG,IAAI,CAKzH;AAID,eAAO,MAAM,MAAM,MAAO,IAAI,KAAG,IAAiB,CAAA;AAClD,eAAO,MAAM,OAAO,MAAO,IAAI,KAAG,IAAyC,CAAA;AAC3E,eAAO,MAAM,SAAS,MAAO,IAAI,KAAG,IAA2B,CAAA;AAI/D,KAAK,WAAW,GAAG,QAAQ,GAAG,MAAM,CAAA;AAQpC,0CAA0C;AAC1C,wBAAgB,WAAW,CAAC,IAAI,EAAE;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,IAAI,GAAG,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,IAAI,GAAG,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,WAAW,CAAA;CAAC,GAAG,MAAM,CAEzI;AAED,2CAA2C;AAC3C,wBAAgB,OAAO,CAAC,IAAI,EAAE;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,WAAW,CAAA;CAAC,GAAG,MAAM,CAE1G"}

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

@@ -0,0 +1,42 @@
+import { Expr, GpuFragmentParams } from '../../gpu/contract';
+
+export type Layer = Expr | {
+    paint: Expr;
+    /** 'add' (default) sums light; 'screen' folds it in with 1−(1−a)(1−b). */
+    blend?: 'add' | 'screen';
+    /** Scales the layer's contribution. */
+    opacity?: Expr | number;
+    /** A transmittance the layer is seen through (content behind a medium). */
+    behind?: Expr;
+};
+/**
+ * Weighted layering: build N variations of the same thing from a plain-data layer list and
+ * accumulate them — `weightedSum = Σ value·weight` and `totalWeight = Σ weight`, both in
+ * list order. The caller owns the blend (usually a guarded weighted mean:
+ * `weightedSum / (totalWeight + ε)`), because the guard and the remap are look decisions.
+ * Cheap depth by stacking: aurora curtains, cloud banks, echo/ghost trails. Compile-time
+ * layer counts are just `list.slice(0, n)` — disabled layers aren't emitted.
+ */
+export declare function layered<T>(layerData: readonly T[], build: (layer: T, index: number) => {
+    value: Expr;
+    weight: Expr;
+}): {
+    weightedSum: Expr;
+    totalWeight: Expr;
+};
+/** Composite a stack of paint contributions, first entry at the back. */
+export declare function layers(entries: Layer[]): Expr;
+/**
+ * `emissiveAlpha` — light as straight-alpha rgba: alpha is the peak channel and the colour is
+ * the light divided by it, so the layer composites over black exactly as the additive light it
+ * is, and over anything else as a translucent tint. The output step of any emissive paint drawn
+ * over transparency (glows, spills, flares) — never for opaque bodies.
+ */
+export declare function emissiveAlpha(rgb: Expr, hint?: string): Expr;
+/**
+ * `dithered` — the always-on ±0.002 output dither on a final rgba (hides banding on long soft
+ * ramps). Apply to the COLOR, never to a ramp coordinate. Reads the composed UV and the
+ * definition's clock.
+ */
+export declare function dithered(color: Expr, params: GpuFragmentParams): Expr;
+//# sourceMappingURL=compose.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"compose.d.ts","sourceRoot":"","sources":["../../../src/std/paint/compose.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAC,IAAI,EAAE,iBAAiB,EAAC,MAAM,oBAAoB,CAAA;AAO/D,MAAM,MAAM,KAAK,GACX,IAAI,GACJ;IACE,KAAK,EAAE,IAAI,CAAA;IACX,0EAA0E;IAC1E,KAAK,CAAC,EAAE,KAAK,GAAG,QAAQ,CAAA;IACxB,uCAAuC;IACvC,OAAO,CAAC,EAAE,IAAI,GAAG,MAAM,CAAA;IACvB,2EAA2E;IAC3E,MAAM,CAAC,EAAE,IAAI,CAAA;CAChB,CAAA;AAEL;;;;;;;GAOG;AACH,wBAAgB,OAAO,CAAC,CAAC,EACrB,SAAS,EAAE,SAAS,CAAC,EAAE,EACvB,KAAK,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK;IAAC,KAAK,EAAE,IAAI,CAAC;IAAC,MAAM,EAAE,IAAI,CAAA;CAAC,GAChE;IAAC,WAAW,EAAE,IAAI,CAAC;IAAC,WAAW,EAAE,IAAI,CAAA;CAAC,CAWxC;AAED,yEAAyE;AACzE,wBAAgB,MAAM,CAAC,OAAO,EAAE,KAAK,EAAE,GAAG,IAAI,CAe7C;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,IAAI,EAAE,IAAI,SAAa,GAAG,IAAI,CAIhE;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,iBAAiB,GAAG,IAAI,CAGrE"}

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

@@ -0,0 +1,270 @@
+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;
+/**
+ * Pick the colour-mix body for the compile-time colour space bound by `space` (linear when
+ * absent). The mode is a compile-time prop value, so it JS-branches to a specialised variant
+ * and participates in the structural hash.
+ */
+export declare function mixColorsIn(space: PropRef | undefined, params: GpuFragmentParams): import('typegpu').TgpuFn<(colorA: import('typegpu/data').Vec4f, colorB: import('typegpu/data').Vec4f, t: import('typegpu/data').F32) => import('typegpu/data').Vec4f> | import('typegpu').TgpuFn<(colorA: import('typegpu/data').Vec4f, colorB: import('typegpu/data').Vec4f, t: import('typegpu/data').F32) => import('typegpu/data').Vec4f> | import('typegpu').TgpuFn<(colorA: import('typegpu/data').Vec4f, colorB: import('typegpu/data').Vec4f, t: import('typegpu/data').F32) => import('typegpu/data').Vec4f> | import('typegpu').TgpuFn<(colorA: import('typegpu/data').Vec4f, colorB: import('typegpu/data').Vec4f, t: import('typegpu/data').F32) => import('typegpu/data').Vec4f> | import('typegpu').TgpuFn<(colorA: import('typegpu/data').Vec4f, colorB: import('typegpu/data').Vec4f, t: import('typegpu/data').F32) => import('typegpu/data').Vec4f> | import('typegpu').TgpuFn<(colorA: import('typegpu/data').Vec4f, colorB: import('typegpu/data').Vec4f, t: import('typegpu/data').F32) => import('typegpu/data').Vec4f>;
+/**
+ * A 3-colour ladder A → B (by `t1`) → C (by `t2`) in the compile-time colour `space`, chaining
+ * the space's mix variant.
+ */
+export declare function colorLadder3(slots: {
+    a: PropRef;
+    b: PropRef;
+    c: PropRef;
+    space: PropRef;
+}): (t1: Expr, t2: Expr, params: GpuFragmentParams) => Expr;
+/** 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;
+/**
+ * `scatterField` — a smooth scalar field blending unit values scattered organically across the
+ * canvas (the mesh-gradient genre primitive): golden-spiral points, gently drifting, blended by
+ * inverse distance. `softness` is the IDW exponent (higher = crisper cells); `count` gates the
+ * fixed-8 GPU loop at runtime.
+ */
+export declare function scatterField(opts: {
+    at: Expr;
+    count: Expr | number;
+    seed: Expr | number;
+    drift: Expr | number;
+    aspect: Expr | number;
+    time: Expr | number;
+    softness: Expr | number;
+}): Expr;
+/**
+ * `wrapRamp` — traverse a palette through `cycles` half-cycles as `t` rises, folding back at the
+ * ends (seam-free triangle wave; identity at cycles = 1); sub-pixel bands fade to the palette
+ * mid instead of shimmering. Fragment-only (fwidth).
+ */
+export declare function wrapRamp(opts: {
+    t: Expr;
+    cycles: Expr | number;
+}): Expr;
+/**
+ * `foldRamp` — fold an unbounded palette parameter back into [0, 1] as a seam-free triangle
+ * wave (0→1→0 every 2 units of `t`). The derivative-free cousin of {@link wrapRamp}: no
+ * sub-pixel fade, so it is safe inside a `guarded` branch (non-uniform control flow, where
+ * `fwidth` is not). Scale `t` first to set the cycle length.
+ */
+export declare function foldRamp(t: Expr): Expr;
+/**
+ * `warpedPoint` — the domain-warped position itself (two Inigo-Quilez warp levels over MaterialX
+ * noise), for recipes that need the warped COORDINATE (to feed several fields) rather than one
+ * warped field sample (`warped`). Same memoized 'warpDomain' instance as {@link warped}.
+ */
+export declare function warpedPoint(opts: {
+    at: Expr;
+    time: Expr | number;
+    amount: Expr | number;
+}): Expr;
+/**
+ * `warpStep` — one chained Inigo-Quilez domain-warp level: displace a position by two
+ * decorrelated noise reads (returned as `.z`/`.w` for tail stages to shade with). Chain steps
+ * by feeding one step's `.xy` to the next. `offsets` are the two decorrelation offsets — the
+ * caller's look data.
+ */
+export declare function warpStep(opts: {
+    at: Expr;
+    scale: number;
+    z: Expr | number;
+    offsets: [[number, number], [number, number]];
+    reach: number;
+    strength: Expr | number;
+}): Expr;
+/**
+ * The standard multi-stop / two-colour palette, read from the definition's standard palette
+ * props (colorA/colorB/stops/colorSpace). The coordinate is consumed once — the stops loop
+ * takes it as a fn parameter.
+ */
+export declare function standardPalette(t: Expr, params: GpuFragmentParams): Expr;
+/**
+ * A 2D 4-colour blend: row1 = A→B by `t1`, row2 = C→D by `t1`, base = row1→row2 by `t2`, in
+ * the compile-time colour `space`. For a non-linear space the four endpoint conversions are
+ * pixel-invariant, so the word's per-frame driver preconverts them (dirty-keyed) into the
+ * `convA`–`convD` vec3 extraFields the definition declares, and the GPU mixes the
+ * preconverted values with a single back-conversion.
+ */
+export declare function quadBlend(slots: {
+    a: PropRef;
+    b: PropRef;
+    c: PropRef;
+    d: PropRef;
+    space: PropRef;
+}): (t1: Expr, t2: Expr, params: GpuFragmentParams) => Expr;
+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":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,EAAC,IAAI,EAAE,iBAAiB,EAAC,MAAM,oBAAoB,CAAA;AAK/D,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,WAAW,CAAA;AAEtC,OAAO,EAA2B,KAAK,OAAO,EAAC,MAAM,WAAW,CAAA;AAGhE,wFAAwF;AACxF,MAAM,MAAM,KAAK,GAAG,CAAC,MAAM,EAAE,iBAAiB,KAAK,IAAI,CAAA;AAEvD,wGAAwG;AACxG,MAAM,MAAM,KAAK,GAAG,CAAC,MAAM,EAAE,iBAAiB,EAAE,KAAK,EAAE,IAAI,KAAK,IAAI,CAAA;AAEpE,+FAA+F;AAC/F,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,iBAAiB,KAAK,IAAI,CAAA;AAElE;;;;GAIG;AACH,MAAM,MAAM,WAAW,GAAG,OAAO,GAAG;IAAC,IAAI,EAAE,OAAO,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAC,CAAA;AAkC/E;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAIrD;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,SAAS,EAAE,MAAM,EAAE,iBAAiB,i/BAGhF;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE;IAAC,CAAC,EAAE,OAAO,CAAC;IAAC,CAAC,EAAE,OAAO,CAAC;IAAC,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAC,QACxE,IAAI,MAAM,IAAI,UAAU,iBAAiB,KAAG,IAAI,CAK/D;AAED,iEAAiE;AACjE,wBAAgB,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAMpE;AAED;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAmB7C;AASD;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAC,GAAG,KAAK,CAyBxF;AAID,6FAA6F;AAC7F,eAAO,MAAM,IAAI;IACb,6FAA6F;kBAC/E;QAAC,IAAI,EAAE,OAAO,CAAC;QAAC,EAAE,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,WAAW,CAAA;KAAC,GAAG,KAAK;IAStE,qHAAqH;kBACvG;QAAC,MAAM,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,WAAW,CAAC;QAAC,MAAM,EAAE,WAAW,CAAC;QAAC,IAAI,EAAE,WAAW,CAAA;KAAC,GAAG,KAAK;IASpG,0FAA0F;iBAC7E;QAAC,MAAM,EAAE,OAAO,CAAC;QAAC,QAAQ,EAAE,WAAW,CAAA;KAAC,GAAG,KAAK;IAS7D,4GAA4G;mBAC7F;QAAC,MAAM,EAAE,OAAO,CAAC;QAAC,IAAI,EAAE,WAAW,CAAC;QAAC,QAAQ,EAAE,WAAW,CAAC;QAAC,SAAS,EAAE,WAAW,CAAA;KAAC,GAAG,KAAK;IAS1G;;;;;OAKG;kBACW;QAAC,MAAM,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,WAAW,CAAC;QAAC,KAAK,EAAE,WAAW,CAAC;QAAC,OAAO,EAAE,WAAW,CAAC;QAAC,QAAQ,EAAE,WAAW,CAAA;KAAC,GAAG,KAAK;CAe/H,CAAA;AAID,mGAAmG;AACnG,wBAAgB,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,WAAW,GAAG,KAAK,CAE7D;AAED,oFAAoF;AACpF,wBAAgB,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,WAAW,GAAG,KAAK,CAE7D;AAED;;;;;GAKG;AACH,wBAAgB,IAAI,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE;IAAC,IAAI,EAAE,WAAW,CAAC;IAAC,QAAQ,EAAE,WAAW,CAAC;IAAC,OAAO,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,IAAI,CAAA;CAAC,GAAG,KAAK,CAI9H;AAED,0GAA0G;AAC1G,wBAAgB,SAAS,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,WAAW,CAAA;CAAC,GAAG,KAAK,CAOpG;AAED;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,CAUzC;AAID,sGAAsG;AACtG,QAAA,MAAM,WAAW;IACb,yEAAyE;;;;;IAEzE,0EAA0E;;;;;IAE1E,kFAAkF;;;;;IAElF,iFAAiF;;;;;CAE3E,CAAA;AAEV,MAAM,MAAM,UAAU,GAAG,MAAM,OAAO,WAAW,CAAA;AAEjD,+FAA+F;AAC/F,wBAAgB,UAAU,CAAC,KAAK,EAAE,UAAU,GAAG,KAAK,CAGnD;AAED;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE;IAAC,MAAM,EAAE,WAAW,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAC,GAAG,KAAK,CASjH;AAED,gHAAgH;AAChH,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE;IAAC,KAAK,EAAE,WAAW,CAAA;CAAC,GAAG,KAAK,CAK5E;AAID;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE;IAAC,MAAM,EAAE,WAAW,CAAA;CAAC,GAAG,KAAK,CAE7D;AAED,+FAA+F;AAC/F,wBAAgB,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,GAAG,KAAK,CAI7F;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,CAOtC;AAED,mGAAmG;AACnG,wBAAgB,SAAS,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,GAAG,KAAK,CAE1D;AAID;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE;IAC/B,EAAE,EAAE,IAAI,CAAA;IACR,KAAK,EAAE,IAAI,GAAG,MAAM,CAAA;IACpB,IAAI,EAAE,IAAI,GAAG,MAAM,CAAA;IACnB,KAAK,EAAE,IAAI,GAAG,MAAM,CAAA;IACpB,MAAM,EAAE,IAAI,GAAG,MAAM,CAAA;IACrB,IAAI,EAAE,IAAI,GAAG,MAAM,CAAA;IACnB,QAAQ,EAAE,IAAI,GAAG,MAAM,CAAA;CAC1B,GAAG,IAAI,CAKP;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE;IAAC,CAAC,EAAE,IAAI,CAAC;IAAC,MAAM,EAAE,IAAI,GAAG,MAAM,CAAA;CAAC,GAAG,IAAI,CAErE;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,CAEtC;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE;IAAC,EAAE,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAAC;IAAC,MAAM,EAAE,IAAI,GAAG,MAAM,CAAA;CAAC,GAAG,IAAI,CAI9F;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE;IAC3B,EAAE,EAAE,IAAI,CAAA;IACR,KAAK,EAAE,MAAM,CAAA;IACb,CAAC,EAAE,IAAI,GAAG,MAAM,CAAA;IAChB,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;IAC7C,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,IAAI,GAAG,MAAM,CAAA;CAC1B,GAAG,IAAI,CAQP;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,iBAAiB,GAAG,IAAI,CAExE;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE;IAAC,CAAC,EAAE,OAAO,CAAC;IAAC,CAAC,EAAE,OAAO,CAAC;IAAC,CAAC,EAAE,OAAO,CAAC;IAAC,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAC,QACjF,IAAI,MAAM,IAAI,UAAU,iBAAiB,KAAG,IAAI,CAsC/D"}

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

@@ -0,0 +1,51 @@
+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;
+//# 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;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,KAAK,EAAC,IAAI,EAAE,iBAAiB,EAAC,MAAM,oBAAoB,CAAA;AAG/D,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,WAAW,CAAA;AAEtC,OAAO,EAAuC,KAAK,OAAO,EAAC,MAAM,WAAW,CAAA;AAE5E,wFAAwF;AACxF,MAAM,MAAM,KAAK,GAAG,CAAC,MAAM,EAAE,iBAAiB,KAAK,IAAI,CAAA;AAmBvD,+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"}

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"}