shaders 3.1.463 → 3.2.464

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

@@ -0,0 +1,328 @@
+import { GpuComputeNode, GpuFragmentParams, KitTexture, Expr } from '../../gpu/contract';
+import { DirectionFrame } from '../frames';
+
+/**
+ * Evaluate `inner` only where `cond` holds; elsewhere the (cheap) `fallback`. Emits
+ * `var x = fallback; if (cond) { …inner hoists…; x = inner; }`. Values hoisted BEFORE the guard
+ * (emitted by `cond`/`fallback`, or by earlier expressions) stay in the enclosing scope and remain
+ * visible inside; values first used inside are declared inside and must not be re-read outside.
+ * A `local()` shared between the guarded interior and any later expression MUST be listed in
+ * `deps` — that emits it in the enclosing scope first (a hoist whose first use is inside the
+ * branch would otherwise be block-scoped and unreachable afterwards).
+ */
+export declare function guarded(cond: Expr, inner: Expr, fallback: Expr, hint?: string, deps?: Expr[]): Expr;
+/** WGSL `reflect(i, n)`. */
+export declare function reflect(i: Expr, n: Expr): Expr;
+/** WGSL `refract(i, n, eta)`. */
+export declare function refract(i: Expr, n: Expr, eta: Expr): Expr;
+/** WGSL `exp2(x)`. */
+export declare function exp2(x: Expr): Expr;
+/** The material-body early-exit condition as vocabulary: NOT outside the shape by > 2 device
+ *  pixels (the exact complement of the kit's `outsideShape` early-exit test). */
+export declare function insideShape(sdf: Expr, pxH: Expr): Expr;
+/** The resolved per-fragment frame the `surface:` slot shades. */
+export interface SurfaceFrame {
+    /** Placement-space UV (`sdfSpaceUV` over center/scale/rotation) — undefined for `stencil: 'none'`. */
+    sdfUV?: Expr;
+    /** Centre field tap (`.x` sdf/−chord, `.y/.z` pattern coords or baked gradients, `.w` depth). */
+    surf0?: Expr;
+    /** Forward/central stencil neighbour taps (per the declared `stencil`). */
+    surfX?: Expr;
+    surfY?: Expr;
+    /** Central-stencil extras (−eps taps); only with `stencil: {kind: 'central'}`. */
+    surfL?: Expr;
+    surfD?: Expr;
+    /** Centre-quality field sampler (materials with `stencil: 'none'` take their own taps). */
+    sampler: (uv: Expr) => Expr;
+    /** Neighbour-tap sampler (cheap bilinear on the volumetric path unless `gradSampler: 'same'`). */
+    gradSampler: (uv: Expr) => Expr;
+    /** Build-time: the active shape resolved to the compute-marched volumetric path. */
+    volumetric: boolean;
+    /** `volumetric` as the runtime 0/1 f32 the composite bodies `std.select` on. */
+    volFlag: Expr;
+    /** Build-time: the sampler carries analytic/baked gradients in `.g/.b` (skip FD taps). */
+    bakedGradients: boolean;
+    /** Child RTT (with `child: 'required'`) — compute-created when a consumer prepass made one. */
+    childTexture?: KitTexture;
+}
+export interface ShapedSurfaceSpec {
+    /** Surface-pattern coords the volumetric pre-march bakes into `.g/.b` (default 'none'). */
+    pattern?: 'none' | 'raw' | 'triplanar';
+    /** Chord measure along the march ray (default 'span'; 'firstLobe' = front-wall thickness). */
+    chord?: 'span' | 'firstLobe';
+    /** Neighbour-tap sampler quality (default 'fast'; 'same' = centre sampler everywhere). */
+    gradSampler?: 'fast' | 'same';
+    /** Baked-gradient routing (default 'none'); see `ShapeFieldSamplerOptions`. */
+    bakedGradients?: 'none' | 'volumetric' | 'all';
+    /** The field-tap frame to resolve for the material (default forward stencil at eps 0.01). */
+    stencil?: 'none' | 'centre' | {
+        kind: 'forward' | 'central';
+        eps: number;
+    };
+    /** Displace the screen UV before placement (returns the UV fed to `sdfSpaceUV`). */
+    placeUV?: (params: GpuFragmentParams) => Expr;
+    /** Resolve the child RTT into the frame; without a child the fragment returns transparent. */
+    child?: 'required';
+    /** THE MATERIAL: shade the resolved frame. */
+    surface: (frame: SurfaceFrame, params: GpuFragmentParams) => Expr;
+}
+/** The three definition halves the spine contributes — spread into the definition. */
+export interface ShapedSurfaceEffect {
+    extraFields: Record<string, {
+        schema: import('typegpu/data').AnyWgslData;
+        initial: number | number[];
+    }>;
+    compute: GpuComputeNode;
+    gpu: {
+        fragment: (params: GpuFragmentParams) => Expr;
+    };
+}
+/** The shape-effect spine noun. See the module header. */
+export declare function shapedSurface(spec: ShapedSurfaceSpec): ShapedSurfaceEffect;
+export interface SurfaceField {
+    /** Centre / forward-x / forward-y field taps, locals-bound. */
+    s0: Expr;
+    sX?: Expr;
+    sY?: Expr;
+    /** Signed distance (centre tap `.x`, divided by `scale` when given). */
+    sdf: Expr;
+    /** One pixel in UV height units. */
+    pxH: Expr;
+    /** Viewport aspect (width / height). */
+    aspect: Expr;
+}
+/** The opening block of every material: bind the field taps + sdf + pixel size to locals. */
+export declare function surfaceField(frame: SurfaceFrame, params: GpuFragmentParams, opts?: {
+    scale?: Expr;
+}): SurfaceField;
+/**
+ * The geometric surface normal, resolved at build time: marched volumetric shapes take the
+ * field-tap normal; flat shapes take the gradient normal tilted by the bevel profile.
+ */
+export declare function geometricNormal(frame: SurfaceFrame, field: SurfaceField, opts: {
+    bevelWidth: Expr;
+    bevelShape: Expr;
+    sharpness?: number;
+    eps?: number;
+    hint?: string;
+}): Expr;
+/** Surface-pattern coordinates (the coords a pattern rides the geometry in), locals-bound. */
+export declare function surfacePattern(frame: SurfaceFrame, field: SurfaceField, opts?: {
+    uv?: Expr;
+}): Expr;
+/** The in-plane field gradient (the outward direction a flat shape's shading rides). */
+export declare function fieldSlope(field: SurfaceField, eps?: number): Expr;
+/** The perspective view ray for a pseudo-3D surface, locals-bound. */
+export declare function viewRay(params: GpuFragmentParams, field: SurfaceField, fov?: number): Expr;
+/** How edge-on the surface is to the view (0 face-on → 1 grazing), locals-bound. */
+export declare function grazingOf(n: Expr, view: Expr): Expr;
+/** Tilt a normal within a direction frame: `along`/`across` are slope amounts per axis. */
+export declare function tiltNormal(n: Expr, frame: DirectionFrame, slopes: {
+    along?: Expr;
+    across?: Expr;
+}, hint?: string): Expr;
+/** The shared 5-softbox studio bank, looked up at a reflected direction. */
+export declare function studioSoftboxes(x: Expr, y: Expr, opts: {
+    /** The studio rotation as a `direction()` vector. */
+    rotation: Expr;
+    keyRadius: Expr | number;
+    drift: Expr | number;
+    strength: Expr | number;
+    skyGain: number;
+}): Expr;
+/**
+ * Grain-space noise: one octave of value noise over a direction frame's coordinates, with a
+ * frequency per axis. Octave sums, gains, and drift terms are algebra at the call site — they
+ * are the look; this is the sampling.
+ */
+export declare function grainNoise(coords: {
+    along: Expr;
+    across: Expr;
+}, opts: {
+    freq: [Expr | number, Expr | number];
+    offset?: [number, number];
+    drift?: Expr;
+}): Expr;
+/**
+ * A gaussian-weighted directional gather: sample `taps` points spread along `axis` around
+ * `center`, summed with baked normalized weights. The anisotropic smear of any 2D lookup —
+ * a reflected environment along a brush grain, a streaked highlight, a motion smear.
+ */
+export declare function smearAlong(opts: {
+    center: Expr;
+    axis: Expr;
+    spread: Expr;
+    taps?: number;
+    sigma?: number;
+    hint?: string;
+}, sample: (x: Expr, y: Expr) => Expr): Expr;
+/** A 3D light direction from a `direction()` vector and an eye-tuned elevation z. */
+export declare function lightVec3(dir: Expr, z: number, hint?: string): Expr;
+/** The house roughness/anisotropy → Ward lobe-width mapping (stretch along, squeeze across). */
+export declare function wardAlphas(roughness: Expr, anisotropy: Expr): {
+    along: Expr;
+    across: Expr;
+};
+/**
+ * Anisotropic (Ward) specular lobe: stretched along `tangent`, widths per axis from `alphas`
+ * (see {@link wardAlphas} for the designer-terms mapping).
+ */
+export declare function anisoSpecular(opts: {
+    normal: Expr;
+    /** The grain/fibre tangent (2D — in-plane). */
+    tangent: Expr;
+    /** Normalized 3D light direction (see {@link lightVec3}). */
+    light: Expr;
+    view: Expr;
+    alphas: {
+        along: Expr;
+        across: Expr;
+    };
+    gain?: Expr | number;
+}): Expr;
+/** Tilt a normal along one in-plane axis by a slope amount. */
+export declare function tiltAlong(n: Expr, axis: Expr, amount: Expr, hint?: string): Expr;
+/** Fresnel edge lift: `1 + grazing^power · amount`. */
+export declare function fresnelBoost(grazing: Expr, opts: {
+    power?: number;
+    amount: Expr | number;
+}): Expr;
+/** A two-tone tint ramp: dark → light by a lighting term (Duotone's ramp as material tint). */
+export declare function tintRamp(t: Expr, dark: Expr, light: Expr): Expr;
+/** The soft silhouette alpha at the shape boundary. */
+export declare function silhouette(field: SurfaceField, edgeSoftness: Expr): Expr;
+/** The neutral filmic tonemap shoulder (exposure grading's final step). */
+export declare function neutralTone(rgb: Expr): Expr;
+/** Nudge a normal by screen-space slope deltas (the isotropic cousin of `tiltNormal`). */
+export declare function nudgeNormal(n: Expr, dx: Expr, dy: Expr, hint?: string): Expr;
+/** The volumetric field-tap normal (marched shapes). Flat shapes shape their own — see
+ *  {@link geometricNormal} for the standard bevelled path. */
+export declare function marchedNormal(field: SurfaceField, sharpness?: number, hint?: string): Expr;
+/** The key-light frame from a `direction()` vector: `.L` light dir, `.H` half vector.
+ *  `elevation` is the material's eye-tuned z (the fleet uses −0.6 … −0.9). */
+export declare function keyLightAt(dir: Expr, elevation: number, hint?: string): Expr;
+/** {@link keyLightAt} from explicit in-plane components (shimmered / cross lights). */
+export declare function keyLightXY(x: Expr, y: Expr, elevation: number, hint?: string): Expr;
+/** Grazing factor for the fixed −z view (the fresnel input when no perspective ray exists). */
+export declare function grazingFlat(n: Expr): Expr;
+/** Sharp key-light glint lobe. */
+export declare function sharpGlint(ndh: Expr, sharpness: Expr, cfg: Expr): Expr;
+/** Clamped perlin slope — the pressed/molten waviness gradient two metals nudge normals with. */
+export declare function perlinSlope(q: Expr, gain: Expr | number): Expr;
+/** Optical body thickness of the shape field (chord on marched shapes, rim proxy on flat). */
+export declare function opticalThickness(field: SurfaceField, frame: SurfaceFrame): Expr;
+/** Beer–Lambert transmission: `exp(−thickness · absorb)` per channel. */
+export declare function beerLambert(thickness: Expr, absorb: Expr): Expr;
+/** The shared incommensurate-frequency flow-warp offset (molten folds / wind-driven waves). */
+export declare function flowWarp(warpInput: Expr, flowT: Expr): Expr;
+/** Signed value noise sampled at a surface point (the material grain/crumple basis). */
+export declare function surfaceNoise(x: Expr | number, y: Expr | number): Expr;
+/** {@link surfaceNoise} at a pre-built vec2 point. */
+export declare function surfaceNoiseAt(p: Expr): Expr;
+/** Signed noise sampled at an interior volume point (vec3) — the 3D cousin of
+ *  {@link surfaceNoiseAt}: the basis for anything sampled THROUGH a body rather than
+ *  across its surface (gas, smoke, inclusions, subsurface density). */
+export declare function volumeNoiseAt(p: Expr): Expr;
+/** IQ cosine palette: a smooth rainbow ramp with per-channel phase offsets. */
+export declare function cosineRainbow(t: Expr, phases: [number, number, number]): Expr;
+/** Worley (cellular) noise at a surface point — the facet/crack cell basis. */
+export declare function cellNoiseAt(p: Expr): Expr;
+/**
+ * Finite-difference slope of any scalar surface field: the field's value at `p` plus its
+ * x/y derivatives at step `eps` — the relief-to-normal bridge every bump recipe rides.
+ */
+export declare function fdSlope(sampleAt: (p: Expr) => Expr, p: Expr, eps: number, hint?: string): {
+    value: Expr;
+    dx: Expr;
+    dy: Expr;
+};
+/** Unsigned white-noise hash of a 2D point (film grain, flicker, per-pixel jitter). */
+export declare function hashNoise(x: Expr | number, y: Expr | number): Expr;
+/** Unsigned smooth value noise at a surface point (the [0,1] cousin of {@link surfaceNoise}). */
+export declare function valueNoise(x: Expr | number, y: Expr | number): Expr;
+/**
+ * How rotated the 3D shape is, as an in-plane pan vector: one field tap at the placement
+ * centre reads the surface-locked pattern coords of the centre hit (zero at rest on every
+ * shape, growing with 3D rotation). Spatially constant per frame, so it pans content
+ * (star planes, interior backdrops) without shearing it; flat shapes gate to zero.
+ * Requires `pattern: 'raw'`.
+ */
+export declare function rotationSensor(frame: SurfaceFrame): {
+    x: Expr;
+    y: Expr;
+};
+/**
+ * Interior coordinates bent at the shell: centered placement coords displaced along the
+ * surface normal's in-plane tilt. `n.xy` is ~0 on a flat face and large at bevels and
+ * silhouettes, so the bend concentrates where real glass would bend the interior — the
+ * cheap single-interface cousin of a full refraction trace. Also returns the unbent
+ * centered coords for anything anchored to the container rather than the interior.
+ */
+export declare function shellRefract(frame: SurfaceFrame, n: Expr, amount: Expr): {
+    x: Expr;
+    y: Expr;
+    centered: {
+        x: Expr;
+        y: Expr;
+    };
+};
+/** Schlick fresnel reflectance: `r0 + grazing^power · gain`. Physical glass is
+ *  `{r0: 0.04, gain: 0.96}`; lower the gain to keep grazing faces from curtaining
+ *  an interior behind full mirror. */
+export declare function schlickFresnel(grazing: Expr, opts: {
+    r0?: number;
+    gain: Expr | number;
+    power?: number;
+}): Expr;
+/** A per-element shimmer factor around 1: `1 − amount + sin(t·rate + phase·spread)·amount`.
+ *  `phase` decorrelates elements (a per-star/per-flake variation field). */
+export declare function twinkle(t: Expr, phase: Expr, opts: {
+    amount: Expr;
+    rate: number;
+    spread: number;
+}): Expr;
+/**
+ * A plane of point glints — stars, glitter, bokeh dust: worley feature points lit only
+ * within a tiny radius, gated to a sparse subset and sized/brightened per point by a slow
+ * variation field. Returns the glint intensity and the variation field (for tinting).
+ * The worley metric is squared distance in cell units, so radii are in those units.
+ */
+export declare function pointStars(p: Expr, opts: {
+    /** Frequency of the per-point variation field relative to `p` (slow: ~0.1). */
+    variationFreq: number;
+    /** Point radius: base + variation · jitter (squared-distance units). */
+    radius: [number, number];
+    /** smoothstep band of the variation field that keeps a point at all (sparsity). */
+    keep: [number, number];
+    /** Brightness: base + variation² · gain. */
+    brightness: [number, number];
+    /** Per-point shimmer factor, built from the variation field (see {@link twinkle}). */
+    shimmer?: (variation: Expr) => Expr;
+    /** Overall gain. */
+    gain: Expr;
+    /** Colour the glints: variation mixes `from` → `to`, scaled by the glint × `gain`. */
+    tint?: {
+        from: [number, number, number];
+        to: [number, number, number];
+        gain: number;
+    };
+    hint?: string;
+}): {
+    glint: Expr;
+    variation: Expr;
+    rgb?: Expr;
+};
+/**
+ * Two-lobe specular glint — a tight hot core plus a wide dim halo. `softness` widens or
+ * tightens both lobes around the authored exponents (0.5 is neutral: the exponents as
+ * given; 0 is ~4× sharper, 1 is ~4× softer).
+ */
+export declare function dualLobeGlint(ndh: Expr, opts: {
+    /** [exponent, gain] of the hot core lobe. */
+    core: [number, number];
+    /** [exponent, gain] of the wide halo lobe. */
+    halo: [number, number];
+    softness?: Expr;
+    gain: Expr;
+}): Expr;
+//# sourceMappingURL=materials.d.ts.map

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

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

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

@@ -0,0 +1,76 @@
+import { Expr, GpuFragmentParams } from '../../gpu/contract';
+import { PropRef } from '../values';
+
+/** The GPU half a media noun contributes to a custom-tier definition — spread it. */
+export interface MediaSurfaceHalf {
+    gpu: {
+        fragment: (params: GpuFragmentParams) => Expr;
+    };
+}
+/** The fit-surface slots every media noun shares. */
+interface MediaFitSlots {
+    /** The structural object-fit prop (`compileTime` — only the selected mode's math is emitted). */
+    fit: PropRef;
+    /**
+     * How the sample is decoded. Required rather than defaulted so each consumer states its
+     * choice (kit/media's D-1 rule).
+     */
+    decode: 'srgb-linear-alpha-cut';
+}
+/**
+ * A static image, fetched → decoded → written into a media texture sized to the image's
+ * NATIVE pixels. A 1×1 transparent placeholder shows until the image lands; the real texture
+ * is swapped in when it loads (the pass manager rebuilds the sampling bind group on the swap —
+ * no recompose), which is what makes `textureDimensions` report the real aspect. sRGB samples
+ * are decoded to linear in-shader (the media analog of the external-texture decode).
+ */
+export declare function imageMedia(opts: MediaFitSlots & {
+    /** The URL prop, read live via the URL-loader state machine. */
+    src: PropRef;
+    /** Debug label for the media texture. */
+    label: string;
+    /** Load-failure reporting — phrasing stays with the consumer. */
+    onError?: (error: unknown, url: string) => void;
+}): MediaSurfaceHalf;
+/**
+ * A URL video: the shared video-element lifecycle (created once at composition, torn down in
+ * its onCleanup) feeding a per-frame zero-copy `importExternalTexture` sample. The registered
+ * getter returns the element only when it has a decodable frame; the pass manager re-imports
+ * it each frame and skips the pass while it is null (the WGSL is fixed, so readiness never
+ * recompiles). Firefox's CanvasTexture copy-path fallback is not implemented — its single
+ * site is in the host module.
+ */
+export declare function videoMedia(opts: MediaFitSlots & {
+    /** The URL prop. */
+    src: PropRef;
+    /** The loop prop, synced to `video.loop` each frame. */
+    loop: PropRef;
+    /** Milliseconds to wait for `loadedmetadata` before giving up. */
+    metadataTimeoutMs: number;
+    onError?: (error: unknown, info: {
+        url: string | null;
+        stage: 'acquire' | 'autoplay';
+    }) => void;
+}): MediaSurfaceHalf;
+/**
+ * The user's camera: the exact `videoMedia` path, only the source is `getUserMedia` instead
+ * of a URL (which is why both share the host's `createVideoElementSource`). Autoplay is
+ * required — a webcam element that would not play is not a usable feed, unlike a URL video
+ * where a blocked autoplay still yields a first frame. `mirror` is a runtime uniform (selfie
+ * flip must not recompose) applied to the fitted UV BEFORE the letterbox alpha cut, so the
+ * cut sees the same UV that was sampled.
+ */
+export declare function webcamMedia(opts: MediaFitSlots & {
+    /** The selfie-mirror boolean prop (runtime uniform). */
+    mirror: PropRef;
+    /** `getUserMedia` constraints — behaviour data, stated by the consumer. */
+    constraints: MediaStreamConstraints;
+    /** The fixed natural-size registry key (a webcam has no URL). */
+    naturalSizeKey: string;
+    onError?: (error: unknown, info: {
+        url: string | null;
+        stage: 'acquire' | 'autoplay';
+    }) => void;
+}): MediaSurfaceHalf;
+export {};
+//# sourceMappingURL=media.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"media.d.ts","sourceRoot":"","sources":["../../../src/std/paint/media.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,EAAC,IAAI,EAAE,iBAAiB,EAAC,MAAM,oBAAoB,CAAA;AAU/D,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,WAAW,CAAA;AAEtC,qFAAqF;AACrF,MAAM,WAAW,gBAAgB;IAC7B,GAAG,EAAE;QAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,iBAAiB,KAAK,IAAI,CAAA;KAAC,CAAA;CACvD;AAED,qDAAqD;AACrD,UAAU,aAAa;IACnB,iGAAiG;IACjG,GAAG,EAAE,OAAO,CAAA;IACZ;;;OAGG;IACH,MAAM,EAAE,uBAAuB,CAAA;CAClC;AAoBD;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,aAAa,GAAG;IAC7C,gEAAgE;IAChE,GAAG,EAAE,OAAO,CAAA;IACZ,yCAAyC;IACzC,KAAK,EAAE,MAAM,CAAA;IACb,iEAAiE;IACjE,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,KAAK,IAAI,CAAA;CAClD,GAAG,gBAAgB,CAyBnB;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,aAAa,GAAG;IAC7C,oBAAoB;IACpB,GAAG,EAAE,OAAO,CAAA;IACZ,wDAAwD;IACxD,IAAI,EAAE,OAAO,CAAA;IACb,kEAAkE;IAClE,iBAAiB,EAAE,MAAM,CAAA;IACzB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE;QAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,KAAK,EAAE,SAAS,GAAG,UAAU,CAAA;KAAC,KAAK,IAAI,CAAA;CAChG,GAAG,gBAAgB,CAUnB;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,aAAa,GAAG;IAC9C,wDAAwD;IACxD,MAAM,EAAE,OAAO,CAAA;IACf,2EAA2E;IAC3E,WAAW,EAAE,sBAAsB,CAAA;IACnC,iEAAiE;IACjE,cAAc,EAAE,MAAM,CAAA;IACtB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE;QAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,KAAK,EAAE,SAAS,GAAG,UAAU,CAAA;KAAC,KAAK,IAAI,CAAA;CAChG,GAAG,gBAAgB,CAanB"}

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

@@ -0,0 +1,243 @@
+import { Expr, GpuFragmentParams } from '../../gpu/contract';
+import { Field, Paint, Palette } from './fields';
+import { PropRef } from '../values';
+
+/**
+ * The exponential-scale noise framing: aspect-correct the UV, scale by `exp(scale)` (each +1
+ * on the slider doubles-ish the frequency), offset by `seed`. Hands the inner field a vec2
+ * pattern position.
+ */
+export declare function seededPlane(field: Field, slots: {
+    scale: PropRef;
+    seed: PropRef;
+}): Field;
+/**
+ * The RAW-divide exponential-scale framing (Scratches' historical domain — the unguarded
+ * aspect divide is part of its exact arithmetic).
+ */
+export declare function rawPlane(field: Field, slots: {
+    scale: PropRef;
+    seed: PropRef;
+}): Field;
+/**
+ * The per-pixel framing: floor the device-pixel position into `grain`-sized cells, offset by
+ * `seed` — for patterns defined on the pixel grid (blue noise) rather than in UV space.
+ */
+export declare function pixelGrid(field: Field, slots: {
+    grain: PropRef;
+    seed: PropRef;
+}): Field;
+/**
+ * The linear-scale noise framing: aspect-correct the UV and multiply by `scale` directly (no
+ * exponential remap), bound as a local — for recipes whose parts read the same plane position
+ * several times.
+ */
+export declare function scaledPlane(field: Field, slots: {
+    scale: PropRef;
+}): Field;
+/**
+ * Lift a vec2 pattern position into 3D by walking the third axis with time — the difference
+ * between noise that MORPHS in place (this) and noise that slides. `rate` scales the
+ * evolution independently of the node's `speed` prop.
+ */
+export declare function evolving(field: Field, opts: {
+    rate: number;
+}): Field;
+/** Oriented sine grains at `frequency` waves per cell, phase-driven by the node's clock. Signed. */
+export declare function gaborGrains(slots: {
+    frequency: PropRef;
+}): Field;
+/** Rotating banded wavelets; `detail` is the per-octave frequency ratio. Phase-animated, signed. */
+export declare function waveletBands(slots: {
+    detail: PropRef;
+}): Field;
+/** Spatial-high-pass blue-noise speckle over a pixel-grid coordinate. Static, unit range. */
+export declare function blueSpeckle(): Field;
+/** Branching hydraulic-erosion ridge height (the `.x` of the erosion field). Static, signed. */
+export declare function erosionRidges(): Field;
+/** Swirling curl-flow speed (√2-normalized magnitude), morphing in place at `rate` × the clock. */
+export declare function curlSpeed(opts: {
+    rate: number;
+}): Field;
+/** Fine hairline streaks at `thickness`, flickering on the node's clock. Fragment-only (fwidth). */
+export declare function scratchStreaks(slots: {
+    thickness: PropRef;
+}): Field;
+/** Remap a signed [-1,1] field to the unit range (`v · 0.5 + 0.5`). */
+export declare function unitized(field: Field): Field;
+/**
+ * The shared noise tone tail: additive contrast about mid-grey + balance shift, inverted so a
+ * ramp's colorA reads as the LOW end. `contrast`/`balance` omitted = 0 (identity) for
+ * textures without tone controls.
+ */
+export declare function noiseTone(field: Field, slots?: {
+    contrast?: PropRef;
+    balance?: PropRef;
+}): Field;
+/**
+ * The signed tone tail: contrast/balance applied to the RAW [-1,1] field BEFORE the squash to
+ * [0,1] (then inverted), so high contrast rides further before clipping.
+ */
+export declare function signedTone(field: Field, slots: {
+    contrast: PropRef;
+    balance: PropRef;
+}): Field;
+/** The multiplicative tone tail (contrast is a gain, 1 = identity), non-inverted — Worley's shape. */
+export declare function gainTone(field: Field, slots: {
+    contrast: PropRef;
+    balance: PropRef;
+}): Field;
+/** Two endpoint colour props mixed in LINEAR space — for definitions without a colour-space prop. */
+export declare function linearPair(a: PropRef, b: PropRef): Palette;
+/**
+ * Multi-octave fractal Brownian motion: rotated centred plane → gated 8-octave golden-angle
+ * fBm over MaterialX simplex → weight-normalized unit field → stop ramp. `octaves` gates the
+ * fixed loop at runtime, so the slider does not recompile.
+ */
+export declare function fractalNoise(slots: {
+    angle: PropRef;
+    detail: PropRef;
+    contrast: PropRef;
+    octaves: PropRef;
+    seed: PropRef;
+    space: PropRef;
+}): Paint;
+/**
+ * Cellular (Worley) noise: aspect plane → gated 4-octave cellular sum (nearest-2 distances
+ * under a selectable metric, reduced per `mode`) → per-mode normalization → gain tone → ramp.
+ * `mode`/`distance`/`octaves` are compile-time props read as CPU values and folded to literals.
+ */
+export declare function worleyNoise(slots: {
+    scale: PropRef;
+    jitter: PropRef;
+    lacunarity: PropRef;
+    persistence: PropRef;
+    contrast: PropRef;
+    balance: PropRef;
+    seed: PropRef;
+    /** Compile-time: the field reduction (f1/f2/…), read from prop values. */
+    mode: PropRef;
+    /** Compile-time: the distance metric, read from prop values. */
+    distance: PropRef;
+    /** Compile-time: the octave gate (1–4), read from prop values. */
+    octaves: PropRef;
+    space: PropRef;
+}): Paint;
+/**
+ * The marble turbulence field: three hand-tuned MaterialX octaves over the plane position,
+ * drifting on the node's clock — the bend amount for {@link veinWave}.
+ */
+export declare function marbleTurbulence(slots: {
+    seed: PropRef;
+}): Field;
+/**
+ * The sine vein wave over the plane's x axis, bent by the `turbulence` field scaled by the
+ * `turbulence` slot. Unit range.
+ */
+export declare function veinWave(turbulence: Field, slots: {
+    turbulence: PropRef;
+}): Field;
+/**
+ * The two-band vein ladder: smoothsteps the vein parameter into `vec2(band1, band2)`, the
+ * deep band modulated by a slow cross-axis depth noise seeded by `seed`.
+ */
+export declare function veinLadder(vein: Field, slots: {
+    seed: PropRef;
+}): Field;
+/**
+ * Three-colour ladder paint over a two-band field: A → B by band `.x`, then → C by band `.y`,
+ * both mixes in the compile-time `space`. The bands bind as a local: both mixes read them.
+ */
+export declare function colorLadder(field: Field, slots: {
+    colors: [PropRef, PropRef, PropRef];
+    space?: PropRef;
+}): Paint;
+/**
+ * Nearest-two cellular distances `vec2(d1, d2)` over the aspect plane at `scale`, the cell
+ * points drifting on the node's clock. Wrap in `share` when a fill and a border mask read
+ * the same evaluation.
+ */
+export declare function cellDistances(slots: {
+    scale: PropRef;
+    seed: PropRef;
+}): Field;
+/** The F1/F2 fill gradient: `edgeIntensity` sets how far the edge colour reaches into each cell. */
+export declare function cellFill(cells: Field, slots: {
+    edgeIntensity: PropRef;
+}): Field;
+/**
+ * The cell boundary-line mask (0 on a boundary, 1 inside a cell); `scale` compensates the
+ * line width for the cell count.
+ */
+export declare function cellBorders(cells: Field, slots: {
+    softness: PropRef;
+    scale: PropRef;
+}): Field;
+/**
+ * Overlay `color` on a paint's rgb where `mask` falls to 0; the base paint keeps its alpha.
+ * The base binds as a local: both the overlay mix and the alpha read it.
+ */
+export declare function borderOverlay(paint: Paint, mask: Field, slots: {
+    color: PropRef;
+}): Paint;
+/** An rgb-only stage for {@link overRgb} — maps a paint's rgb; alpha passes through. */
+export type RgbStage = (rgb: Expr, params: GpuFragmentParams) => Expr;
+/** Apply rgb-only stages over a paint, threading the base alpha through unchanged. */
+export declare function overRgb(paint: Paint, ...stages: RgbStage[]): Paint;
+/** The closing working-space → P3-linear back-conversion at the compile-time `space` mode. */
+export declare function backToP3(slots: {
+    space?: PropRef;
+}): RgbStage;
+/** The `pow(rgb, 0.85)` tone lift. */
+export declare function tonePow(): RgbStage;
+/**
+ * The flowing ribbon accumulation field: an ATOMIC runtime-count reduce — each strand's
+ * working-space gradient lookup lives inside the loop — returning working-space rgba. Close
+ * it with {@link backToP3} (and {@link tonePow}) via {@link overRgb}. Reads BOTH of the
+ * definition's clocks: the main one drives the wave motion, the `color` extra clock
+ * (`extraAnimatedTimes: {color: ...}` stays declared on the definition) scrolls the colours.
+ */
+export declare function strandsRibbons(slots: {
+    from: PropRef;
+    to: PropRef;
+    count: PropRef;
+    width: PropRef;
+    amplitude: PropRef;
+    frequency: PropRef;
+    softness: PropRef;
+    spread: PropRef;
+    pinEdges: PropRef;
+    colorScale: PropRef;
+    colorVariance: PropRef;
+}): Paint;
+/** One entry of {@link reliefBases}: a kit height-field basis for {@link noiseRelief}. */
+export interface ReliefBasis {
+    /** The `(vec2f) → f32` height field sampled by the relief filter. */
+    readonly fn: unknown;
+    /** The emitted WGSL height-fn name. */
+    readonly hint: string;
+}
+/** The height fields {@link noiseRelief} accepts. */
+export declare const reliefBases: {
+    /** Marbled stone height field. */
+    readonly stone: {
+        readonly fn: import('typegpu').TgpuFn<(p: import('typegpu/data').Vec2f) => import('typegpu/data').F32>;
+        readonly hint: "stone12";
+    };
+    /** Interwoven fibrous fabric height field. */
+    readonly wool: {
+        readonly fn: import('typegpu').TgpuFn<(p: import('typegpu/data').Vec2f) => import('typegpu/data').F32>;
+        readonly hint: "wool12";
+    };
+};
+/**
+ * Relief filter over child content: sample the child texture through a Perlin-gradient surface
+ * distortion, then modulate its brightness by the `basis` height field (an RTT filter — the
+ * definition keeps `requiresRTT`/`requiresChild` and the shared `reliefStylizeProps` block).
+ */
+export declare function noiseRelief(basis: ReliefBasis): (params: GpuFragmentParams) => Expr;
+/** The Worley prop enum transforms + the historical hash alias, for the shader definition. */
+export declare const transformWorleyMode: (value: string) => number;
+export declare const transformWorleyDistance: (value: string) => number;
+export declare const worleyHash: import('typegpu').TgpuFn<(p: import('typegpu/data').Vec2f) => import('typegpu/data').Vec2f>;
+//# sourceMappingURL=noise.d.ts.map