shaders 3.1.463 → 3.2.465

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

@@ -0,0 +1,281 @@
+import { Expr, GpuFragmentParams } from '../../gpu/contract';
+import { Field, Paint, Palette } from './fields';
+import { PropRef } from '../values';
+
+/**
+ * One wave: coefficients on the named axes (frequency along x/y, drift speed along t) plus
+ * an optional phase. Every field is serializable data — a wave is `{x: 3.2, t: 0.8}`:
+ * "a wave across x at frequency 3.2, drifting at speed 0.8". Negative coefficients reverse
+ * direction. Coefficient `1` emits the bare axis (no `× 1`).
+ */
+export interface Wave {
+    x?: number;
+    y?: number;
+    t?: number;
+    /** Radians, or a `hashPhase(...)` Expr for seeded decorrelation. */
+    phase?: Expr | number;
+}
+/**
+ * One term of a schedule: a single wave, or a product of waves (the "organic" move — an
+ * x-wave × a y-wave interferes instead of striping). `weight` scales the term (default 1,
+ * emitted only when ≠ 1).
+ */
+export interface WaveTerm {
+    waves: Wave[];
+    weight?: number;
+}
+/**
+ * `waves` — overlapping traveling sine waves, schedule as data. The engine under every
+ * "organic wobble": evaluates `Σ weightᵢ · Π sin(x·kx + y·ky + t·kt + phase)` over the
+ * named axes, SIGNED output (tone words shape it; `warped` coords warp it — both stay
+ * outside, deliberately). Emission is deterministic — terms sum in schedule order, waves
+ * multiply in wave order, axes emit x → y → t → phase — so a ported schedule reproduces
+ * its original arithmetic. Schedules are the caller's look; `organicWaves` generates one
+ * from intent when nobody has hand-tuned constants to preserve.
+ */
+export declare function waves(axes: {
+    x: Expr | number;
+    y?: Expr | number;
+    t?: Expr | number;
+}, schedule: WaveTerm[]): Expr;
+/**
+ * `wavyLine` — an animated organic curve: the offset of a line at coordinate `along`, as a
+ * weighted stack of traveling sines. Sugar over {@link waves} on one axis; give each wave a
+ * `hashPhase` to decorrelate a family of lines. Curtain paths, water horizons, wavy
+ * baselines, cloth edges.
+ */
+export declare function wavyLine(opts: {
+    along: Expr | number;
+    time: Expr | number;
+    waves: {
+        freq: number;
+        speed: number;
+        amount: number;
+        phase?: Expr | number;
+    }[];
+}): Expr;
+/**
+ * `organicWaves` — generate a {@link waves} schedule from intent, for authors (human or AI)
+ * who don't have hand-tuned constants to preserve. Three knobs + seed, deliberately
+ * (knobs grow under pressure from real use, never speculatively): `frequency` sets the base
+ * scale, `detail` the number of product-pair layers (each ~1.8× finer, half the weight),
+ * `drift` the animation speed. Deterministic per seed. TUNING CANDIDATE — constants pending
+ * an eye pass; treat the output as a starting point, not a spec.
+ */
+export declare function organicWaves(opts: {
+    frequency: number;
+    detail?: number;
+    drift?: number;
+    seed?: number;
+}): WaveTerm[];
+/**
+ * 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;
+/**
+ * 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;
+/**
+ * `ribbons` — flowing, gradient-colored ribbons between two anchors (the ribbons genre
+ * primitive): an ATOMIC runtime-count reduce — each ribbon'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 ribbons(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

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

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

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

@@ -0,0 +1,320 @@
+import { Expr, GpuFragmentParams, GpuMapSampleUVs } from '../../gpu/contract';
+import { RttFilterParams } from '../../gpu/scaffolds/rttFilter';
+import { GatherEffect } from '../types';
+import { PropRef } from '../values';
+
+/** A generator paint part — what `StdGeneratorDefinition.paint` accepts. */
+export type PatternPaint = (params: GpuFragmentParams) => Expr;
+/** What a paint slot accepts: a prop binding or another paint part. */
+export type PaintSlot = PropRef | PatternPaint;
+/**
+ * A lattice frame's coordinate convention. `'flippedY'` = image-style Y-down, positive rotation
+ * counter-clockwise; `'clockwise'` = Y as-is, positive rotation clockwise; `'plain'` = Y as-is,
+ * positive rotation counter-clockwise. The convention is part of each pattern's look — the
+ * shader file states it alongside the cell count.
+ */
+export type CellFrameConvention = 'flippedY' | 'clockwise' | 'plain';
+/**
+ * The lattice frame part: maps the paint UV (uvContext-aware) into rotated, aspect-corrected
+ * lattice space, scaled to `cells` lattice units. Everything drawn IN the cells composes on top.
+ */
+export declare function cellFrame(slots: {
+    cells: PropRef;
+    rotation: PropRef;
+    convention: CellFrameConvention;
+}): PatternPaint;
+/** The per-cell brightness-jitter part: scale a fill's RGB by a variation factor (alpha untouched). */
+export declare function vary(color: PaintSlot, factor: PaintSlot): PatternPaint;
+/** The stroke-over-fill part: mix `fill` → `stroke` by the stroke mask in the `space` colour space. */
+export declare function strokeOver(layers: {
+    fill: PaintSlot;
+    stroke: PaintSlot;
+    mask: PaintSlot;
+    space?: PropRef;
+}): PatternPaint;
+/**
+ * Sample the given mapped props at the CELL CENTRE rather than the fragment position, so a
+ * mapped size/thickness transitions as whole cells instead of being clipped at map-source
+ * boundaries. `rotation` (degrees) rotates the lattice about the canvas centre before snapping.
+ * Uses the raw canvas UV/viewport (the global, not effectiveViewportSize) — declare it on the
+ * definition's `mapSampleUVs` field.
+ */
+export declare function sampleMapsAtCellCentres(slots: {
+    cells: PropRef;
+    rotation?: PropRef;
+    props: string[];
+}): GpuMapSampleUVs;
+/** Pair a colour's RGB with a separately built alpha. */
+export declare function withAlpha(color: PaintSlot, alpha: PaintSlot): PatternPaint;
+/** Read a colour's alpha channel. */
+export declare function alphaOf(color: PaintSlot): PatternPaint;
+/** Read a colour's RGB channels. */
+export declare function rgbOf(color: PaintSlot): PatternPaint;
+/** Multiply two slot values. */
+export declare function times(a: PaintSlot, b: PaintSlot): PatternPaint;
+/** Linear mix `from` → `to` by `amount` (component-wise, no colour-space handling). */
+export declare function mixOf(from: PaintSlot, to: PaintSlot, amount: PaintSlot): PatternPaint;
+/** Finish an RGB value as a fully opaque colour. */
+export declare function opaque(rgb: PaintSlot): PatternPaint;
+/**
+ * Checker cells: the analytically anti-aliased checker blend factor (Quilez 2D filter over the
+ * screen-space footprint). `cells` counts cells along the canvas height (square cells).
+ */
+export declare function checkerCells(slots: {
+    cells: PropRef;
+    softness: PropRef;
+}): PatternPaint;
+/**
+ * Stripe bands: the analytically anti-aliased directional stripe mask (Quilez 1D filter,
+ * `balance` as the duty threshold), scrolled by the node's accumulated animation time plus
+ * `offset`. Requires `animatedTime: {speed}` on the definition.
+ */
+export declare function stripeBands(slots: {
+    angle: PropRef;
+    density: PropRef;
+    balance: PropRef;
+    softness: PropRef;
+    offset: PropRef;
+}): PatternPaint;
+/**
+ * Zigzag bands: the fwidth-anti-aliased chevron stripe mask, scrolled by the node's accumulated
+ * animation time plus `offset`. Requires `animatedTime: {speed}` on the definition.
+ */
+export declare function zigzagBands(slots: {
+    count: PropRef;
+    angle: PropRef;
+    balance: PropRef;
+    softness: PropRef;
+    offset: PropRef;
+}): PatternPaint;
+/**
+ * Ring waves: the mask of concentric rings emanating from `center`, animated by the node's
+ * accumulated time plus `phase`. Requires `animatedTime: {speed}` on the definition.
+ */
+export declare function ringWaves(slots: {
+    center: PropRef;
+    frequency: PropRef;
+    thickness: PropRef;
+    softness: PropRef;
+    phase: PropRef;
+}): PatternPaint;
+/**
+ * Falling streaks: directional streaks with per-column random speed/phase and a rounded leading
+ * cap, driven by the node's accumulated animation time. `mask` is the streak coverage, `fade`
+ * the lead→trail position within a streak. Requires `animatedTime: {speed}` on the definition.
+ */
+export declare function fallingStreaks(slots: {
+    angle: PropRef;
+    density: PropRef;
+    speedVariance: PropRef;
+    trailLength: PropRef;
+    strokeWidth: PropRef;
+    rounding: PropRef;
+    balance: PropRef;
+}): {
+    mask: PatternPaint;
+    fade: PatternPaint;
+};
+/**
+ * Dot lattice: the coverage of a square lattice of anti-aliased discs with optional brick-style
+ * row stagger, per-row animated drift (the node's accumulated time × per-row random speed), and
+ * a per-dot twinkle on the global clock. Requires `animatedTime: {speed}` on the definition.
+ */
+export declare function dotLattice(slots: {
+    density: PropRef;
+    dotSize: PropRef;
+    offset: PropRef;
+    speedVariance: PropRef;
+    twinkle: PropRef;
+}): PatternPaint;
+/**
+ * Grid lines drawn in a lattice frame: Quilez axis integrals over the dpdx/dpdy footprint.
+ * `lines` is the line mask, `shade` the per-cell variation factor for the cell fill.
+ */
+export declare function gridLines(slots: {
+    frame: PatternPaint;
+    thickness: PropRef;
+    softness: PropRef;
+    variation: PropRef;
+}): {
+    lines: PatternPaint;
+    shade: PatternPaint;
+};
+/**
+ * Honeycomb lines drawn in a lattice frame (pointy-top hexagons). `lines` is the line mask,
+ * `shade` the per-cell variation factor for the cell fill.
+ */
+export declare function hexLines(slots: {
+    frame: PatternPaint;
+    thickness: PropRef;
+    softness: PropRef;
+    variation: PropRef;
+}): {
+    lines: PatternPaint;
+    shade: PatternPaint;
+};
+/**
+ * Skewed equilateral-triangle lines drawn in a lattice frame, with per-row animated drift.
+ * `lines` is the line mask, `shade` the per-cell variation factor. Requires
+ * `animatedTime: {speed}` on the definition.
+ */
+export declare function triangleLines(slots: {
+    frame: PatternPaint;
+    thickness: PropRef;
+    softness: PropRef;
+    variation: PropRef;
+    speedVariance: PropRef;
+}): {
+    lines: PatternPaint;
+    shade: PatternPaint;
+};
+/**
+ * Brick courses: staggered rows with mortar gaps, optional rotation, static offset, and per-row
+ * animated drift (the node's accumulated time). `bricks` is the brick coverage mask, `shade`
+ * the per-brick variation factor. Brick keeps its OWN frame part (`patternPaints.brickFrame`)
+ * rather than the shared {@link cellFrame} slot — its raw-UV, non-uniform-cell framing is not
+ * byte-equivalent to any lattice frame convention (Gate-C candidate; see the note on
+ * `brickFrame`). Requires `animatedTime: {speed}` on the definition.
+ */
+export declare function brickCourses(slots: {
+    cellsX: PropRef;
+    cellsY: PropRef;
+    mortar: PropRef;
+    softness: PropRef;
+    variation: PropRef;
+    rotation: PropRef;
+    offset: PropRef;
+    speedVariance: PropRef;
+    seed: PropRef;
+}): {
+    bricks: PatternPaint;
+    shade: PatternPaint;
+};
+/**
+ * Truchet arcs drawn in a lattice frame: quarter-circle arc tiles, orientation hashed per tile
+ * (`seed` reshuffles the maze). Returns the arc line mask.
+ */
+export declare function truchetArcs(slots: {
+    frame: PatternPaint;
+    thickness: PropRef;
+    softness: PropRef;
+    seed: PropRef;
+}): PatternPaint;
+/**
+ * Weave threads drawn in a lattice frame: interlaced horizontal/vertical thread bands with a
+ * checkerboard over-under rule, compositing `colors[0]` (horizontal) and `colors[1]` (vertical)
+ * by per-thread alpha weight — not a colour-space mix, so there is no `space` slot.
+ */
+export declare function weaveThreads(slots: {
+    frame: PatternPaint;
+    gap: PropRef;
+    /** `[horizontal, vertical]` thread colours. */
+    colors: [PropRef, PropRef];
+}): PatternPaint;
+/**
+ * Rhombille (tumbling-blocks) faces drawn in a lattice frame — three shaded rhombus faces per
+ * hexagon read as a 3D cube. `random` is the per-cube colour hash, `tone` the face shading
+ * factor, `wire` the edge-line mask.
+ */
+export declare function isoCubeFaces(slots: {
+    frame: PatternPaint;
+    thickness: PropRef;
+    softness: PropRef;
+}): {
+    random: PatternPaint;
+    tone: PatternPaint;
+    wire: PatternPaint;
+};
+/**
+ * Halftone plate part: the rotated dot-screen coverage for one ink plate — dot size follows
+ * `intensity` (the plate's ink value at this pixel), spaced by `frequency` at the plate's screen
+ * `angle`.
+ */
+export declare function dotScreenMask(uv: Expr, aspect: Expr, angle: Expr, intensity: Expr, frequency: Expr): Expr;
+/**
+ * Halftone plate part: subtractive ink lay-down — white where the plate leaves paper bare,
+ * fading toward the ink colour (× ink alpha) where the dot covers. Plates multiply together.
+ */
+export declare function inkTransmission(inkColor: Expr, inkMask: Expr): Expr;
+/**
+ * Classic halftone gather recipe: the child sampled once (straight alpha), its brightness
+ * modulating a single rotated dot plate.
+ */
+export declare function dotScreen(slots: {
+    angle: PropRef;
+    frequency: PropRef;
+}): GatherEffect;
+/** One ink plate of a {@link cmykPress}: which CMYK channel it prints, at which screen angle, in which ink. */
+export interface InkPlateSpec {
+    readonly channel: 'cyan' | 'magenta' | 'yellow' | 'black';
+    readonly screenAngle: PropRef;
+    readonly ink: PropRef;
+}
+export declare function inkPlate(spec: InkPlateSpec): InkPlateSpec;
+/**
+ * CMYK press gather recipe: one subtractive plate per ink, laid down in order. Each plate samples
+ * the child at its own registration offset around `misprintAngle` (quarter turns per plate index;
+ * mis-registration shows as colour fringing), reads its CMYK channel, screens it through
+ * `dotScreenMask`, and multiplies its `inkTransmission` into the paper. Alpha follows the
+ * un-offset centre sample; every tap is straight-alpha.
+ */
+export declare function cmykPress(slots: {
+    paper: PropRef;
+    frequency: PropRef;
+    misprint: PropRef;
+    misprintAngle: PropRef;
+    plates: InkPlateSpec[];
+}): GatherEffect;
+/**
+ * Compile-time recipe switch: pick a whole gather recipe from a structural enum prop. `read`
+ * maps the raw compile-time value (robust to a pre-transform string) to a case key. All cases
+ * must share their alpha discipline and carry no setup hooks.
+ */
+export declare function chosenBy<K extends string>(prop: PropRef, read: (raw: unknown) => K, recipes: Record<K, GatherEffect>): GatherEffect;
+/** One post-sample gather stage: a value derived from the child RTT. */
+export type GatherStage = (params: RttFilterParams) => Expr;
+/**
+ * The dither grid frame: the shared cell geometry of a pixel-grid screen. `coord` is the dither
+ * cell coordinate, `source` the child sampled once per cell (the pixellated source colour). The
+ * grid is sized against the LOGICAL (authored-frame) resolution so the dot count stays constant
+ * under infinite-canvas resolution scaling.
+ */
+export interface PixelGrid {
+    readonly size: PropRef;
+    readonly coord: GatherStage;
+    readonly source: GatherStage;
+}
+export declare function pixelGrid(slots: {
+    size: PropRef;
+}): PixelGrid;
+/**
+ * Ordered-dither part: the threshold FIELD for a compile-time pattern mode — the closed-form
+ * Bayer 2/4/8 or clustered-dot lattice values, or the blue/white-noise hashes, at the dither
+ * cell coordinate. Feed it to `ditherOrderedResult` to quantise a luminance against it.
+ * (Floyd–Steinberg is not a threshold field — its quantisation diffuses error serially.)
+ */
+export declare function orderedThreshold(pattern: number, coord: Expr): Expr;
+/**
+ * The quantise stage: the 0..1 dither result for the grid cell. The ordered modes compose an
+ * `orderedThreshold` field with the cell luminance; the compile-time Floyd–Steinberg mode has no
+ * threshold field — it samples the 64 block-cell luminances and runs its tile-confined serpentine
+ * error diffusion, reading off this fragment's cell.
+ */
+export declare function quantise(slots: {
+    grid: PixelGrid;
+    pattern: PropRef;
+    threshold: PropRef;
+    spread: PropRef;
+}): GatherStage;
+/**
+ * The dither compose gather recipe: colour the quantised `levels`. The compile-time `mode`
+ * branches — custom mixes `colors[0]`→`colors[1]`, source darkens/brightens the grid's own
+ * pixellated child colour. Every tap is straight-alpha.
+ */
+export declare function ditherInks(slots: {
+    grid: PixelGrid;
+    levels: GatherStage;
+    mode: PropRef;
+    colors: [PropRef, PropRef];
+}): GatherEffect;
+//# sourceMappingURL=patterns.d.ts.map

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

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