shaders 3.0.453 → 3.1.455

package/dist/core/gpu/kit/host/mediaLifecycle.d.ts

@@ -0,0 +1,173 @@
+import { GpuFragmentParams, KitTexture } from '../../contract';
+
+export interface SwappableMediaTextureOptions {
+    /** Texture label (shows up in WebGPU error messages / the texture manager's accounting). */
+    label: string;
+    /**
+     * Size of the initial placeholder. Default 1×1 — a transparent texel, so the pass always has
+     * something valid to bind and the layer renders transparent until content lands. Text and
+     * HTMLInCanvas start larger only because their first write is imminent.
+     */
+    initial?: {
+        width: number;
+        height: number;
+    };
+    /** Base format, forwarded to `createMediaTexture`. Default `rgba8unorm`. */
+    format?: GPUTextureFormat;
+}
+export interface SwappableMediaTexture {
+    /** The registered `KitTexture` for the fragment builder. Follows swaps — register it ONCE. */
+    readonly kit: KitTexture;
+    /**
+     * Ensure the backing texture is exactly `width`×`height` (each floored at 1), allocating and
+     * swapping when it is not. Destroying the old texture is safe: WebGPU keeps it alive for frames
+     * already submitted. No-op after cleanup.
+     */
+    ensureSize(width: number, height: number): void;
+    /** Upload pixel content (ImageBitmap / HTMLCanvasElement / ImageData / TypedArray). */
+    write(source: unknown): void;
+    /** The raw `GPUTexture`, for `queue.copyElementImageToTexture` (HTMLInCanvas). */
+    unwrap(): GPUTexture;
+    readonly width: number;
+    readonly height: number;
+    /** True once the shader has been cleaned up — check it after an await before writing. */
+    readonly disposed: boolean;
+}
+/**
+ * A media texture that can change size: allocate → swap the getter → destroy the previous one, with
+ * the placeholder and the cleanup wired up.
+ *
+ * Media textures are STATIC-sized, so a new image at its native resolution, a re-rastered text run
+ * or a resized DOM capture means a NEW texture. The pass manager notices the backing texture's
+ * identity changed and rebuilds only the sampling pass's bind group — no recompose, no pipeline
+ * rebuild. Shaders whose texture never changes size (Ascii's and ObjectTracker's glyph atlases) use
+ * this too and simply never call `ensureSize`; they get the dispose-guarded `write` for free.
+ */
+export declare function createSwappableMediaTexture(params: GpuFragmentParams, opts: SwappableMediaTextureOptions): SwappableMediaTexture;
+/** What a `load` callback is handed alongside the URL. */
+export interface UrlLoadContext {
+    /**
+     * True once the shader has been cleaned up. Check it after EVERY await and bail — the textures
+     * the load would write into are gone.
+     */
+    isDisposed(): boolean;
+    /**
+     * Mark this URL as loaded, which stops the per-frame watch from re-requesting it. Call it after
+     * the last await that could fail, so a failed load stays retryable (see the module note).
+     */
+    commit(): void;
+}
+export interface UrlSourceLoaderOptions {
+    /** Name of the URL prop, read live via `getCpuValue`. */
+    prop: string;
+    /** Do the load. Owns its own decode/apply; the loader owns only the state machine. */
+    load(url: string, ctx: UrlLoadContext): Promise<void>;
+    /** Reported for anything `load` throws. Error TAXONOMY stays per-shader by design. */
+    onError?(error: unknown, url: string): void;
+}
+export interface UrlSourceLoader {
+    /** The URL currently loaded (empty until the first `commit`). */
+    currentUrl(): string;
+    /** A load is in flight — the per-frame watch stands down while it is. */
+    isLoading(): boolean;
+    /** Force a load of `url` now, bypassing the per-frame watch. Used by the kickoff and by tests. */
+    request(url: string): void;
+}
+/**
+ * The URL-prop state machine: kick off the initial load, watch the prop for changes each frame, and
+ * keep exactly one load in flight.
+ *
+ * NOTE the `setTimeout(…, 0)` kickoff: the load must not start until the node's uniforms are
+ * populated, because `getCpuValue` reads the live handle. Deferring by a macrotask is the workaround,
+ * not the fix — the fix is an `onUniformsReady` hook on `GpuFragmentParams` (PRIMITIVES_PLAN.md
+ * Phase 12 item 3), at which point this function is the single site that changes.
+ */
+export declare function createUrlSourceLoader(params: GpuFragmentParams, opts: UrlSourceLoaderOptions): UrlSourceLoader;
+/**
+ * A decoded image ready to upload. The two size pairs are NOT interchangeable:
+ *
+ *   - `width`/`height` are the RASTER size — what the GPU texture must be.
+ *   - `naturalWidth`/`naturalHeight` are the INTRINSIC size — the layout-facing "how big is this
+ *     element" answer that goes to the natural-size registry. For a bitmap they are the same; for an
+ *     SVG they differ, and conflating them makes a 32px logo slot at 2048px in a layout column.
+ */
+export interface DecodedImageSource {
+    source: ImageBitmap | HTMLCanvasElement;
+    width: number;
+    height: number;
+    naturalWidth: number;
+    naturalHeight: number;
+    /** Release transient decode resources (closes an `ImageBitmap`). Safe to call twice. */
+    close(): void;
+}
+/**
+ * Fetch + decode an image URL to something uploadable. SVGs go through a canvas rasterization (with
+ * the intrinsic/raster split above); everything else is a CORS fetch → blob → `createImageBitmap`.
+ */
+export declare function decodeImageSource(url: string): Promise<DecodedImageSource>;
+/** Where the video frames come from. */
+export type VideoSourceSpec = {
+    kind: 'url';
+    prop: string;
+} | {
+    kind: 'webcam';
+    constraints?: MediaStreamConstraints;
+};
+/**
+ * Which step failed, so a shader's `onError` can keep its own message taxonomy. `'acquire'` covers
+ * everything up to and including metadata (a bad URL, a load timeout, a denied camera) and is
+ * reported ONCE per attempt; `'autoplay'` is the browser refusing to start playback, which is not
+ * necessarily fatal — see `autoplayRequired`.
+ */
+export type VideoLoadStage = 'acquire' | 'autoplay';
+export interface VideoElementSourceOptions {
+    source: VideoSourceSpec;
+    /**
+     * Keep `video.loop` synced to a boolean prop each frame (URL sources only). The prop packs to an
+     * f32 field (1 = true), and an UNSET value reads as true — both current consumers default their
+     * loop prop to true.
+     */
+    loop?: {
+        prop: string;
+    };
+    /**
+     * Key the source's pixel dimensions are published under in the natural-size registry. Defaults
+     * to the URL for a URL source; a webcam has no URL and must pass its own fixed key.
+     */
+    naturalSizeKey?: string;
+    /**
+     * Milliseconds to wait for `loadedmetadata` before giving up. Default 0 = wait indefinitely
+     * (the webcam's behaviour — a permission prompt can legitimately take a while).
+     */
+    metadataTimeoutMs?: number;
+    /**
+     * Whether a rejected `play()` aborts the load. False (VideoTexture) reports it and keeps the
+     * element, since a browser autoplay block still leaves a decodable first frame; true
+     * (WebcamTexture) discards it. The two consumers genuinely differ here, so there is no default
+     * winner beyond the more forgiving one.
+     */
+    autoplayRequired?: boolean;
+    onError?(error: unknown, info: {
+        url: string | null;
+        stage: VideoLoadStage;
+    }): void;
+}
+export interface VideoElementSource {
+    /**
+     * The readiness-gated getter to hand `registerExternalTexture`. Returns the element only when it
+     * has a decodable frame; the pass manager skips the pass for a frame where it is null.
+     */
+    getSource(): HTMLVideoElement | null;
+    /** The live element, or null before the first successful load. */
+    element(): HTMLVideoElement | null;
+}
+/**
+ * The video-element half of VideoTexture and WebcamTexture: acquire a source (a URL or
+ * `getUserMedia`), wait for metadata, start playback, publish the frame size for layout, and gate
+ * the element behind a readiness check so the renderer never imports an undecodable frame.
+ *
+ * The GPU side is identical for both consumers — a per-frame zero-copy `importExternalTexture` — so
+ * only the acquisition differs, and both paths live here rather than in the two shaders.
+ */
+export declare function createVideoElementSource(params: GpuFragmentParams, opts: VideoElementSourceOptions): VideoElementSource;
+//# sourceMappingURL=mediaLifecycle.d.ts.map

package/dist/core/gpu/kit/host/mediaLifecycle.d.ts.map

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

package/dist/core/gpu/kit/host/pointer.d.ts

@@ -0,0 +1,155 @@
+import { ComputeStep } from '../../compute';
+
+/** What a pointer looks like in the per-frame params the renderer hands a compute hook. */
+export interface PointerLike {
+    x?: number;
+    y?: number;
+}
+/** One frame of resolved pointer motion. All positions are in [0, 1] viewport UV. */
+export interface PointerFrame {
+    /** Current position (the previous position when the renderer reports no pointer). */
+    x: number;
+    y: number;
+    /** Position at the previous update. */
+    prevX: number;
+    prevY: number;
+    /** Per-frame delta, ZEROED on a teleport frame so downstream forces see no impulse. */
+    dx: number;
+    dy: number;
+    /** `|delta|` — the RAW distance, reported even on a teleport frame. */
+    dragDist: number;
+    /** Delta per second (`dx / dt`), zeroed on a teleport frame. */
+    velX: number;
+    velY: number;
+    /** Exponentially smoothed `velX`/`velY`. A teleport frame decays it rather than spiking it. */
+    smoothVelX: number;
+    smoothVelY: number;
+    /** `|smoothVel|`. */
+    smoothSpeed: number;
+    /** The drag jumped further than `teleportGuard` in one frame — treat it as a discontinuity. */
+    teleport: boolean;
+    /** A real stroke this frame: moved more than `minDrag` and did not teleport. */
+    moving: boolean;
+}
+export interface PointerVelocityTrackerOptions {
+    /** Blend factor for the smoothed velocity, per frame. Default 0.2 (SmokeFlow's value). */
+    smoothing?: number;
+    /**
+     * A one-frame jump beyond this UV distance is a pointer teleport — the cursor entering the
+     * canvas, a tab switch, a window focus change — not a stroke. Without the guard the sim receives
+     * a single enormous impulse and lays a splat ribbon or a force wake clean across the field.
+     * Default 0.25 (a quarter of the viewport), ParticleFlow's original value.
+     */
+    teleportGuard?: number;
+    /** Below this per-frame UV distance, `moving` stays false. Default 0.0006 (InkFlow's value). */
+    minDrag?: number;
+    /** Initial pointer position, used until the renderer reports one. Default centre. */
+    initialX?: number;
+    initialY?: number;
+}
+export interface PointerVelocityTracker {
+    /** Advance the tracker one frame. `dt` is in seconds and is floored at 1 ms for the divide. */
+    update(pointer: PointerLike | undefined, dt: number): PointerFrame;
+}
+/**
+ * Track pointer position, per-frame delta, per-second velocity and a smoothed velocity, with the
+ * teleport guard applied.
+ *
+ * Structural vs runtime does not apply here (this is all CPU), but note the guard's semantics: on a
+ * teleport frame the tracker still ADVANCES its previous position — the jump is absorbed, not
+ * deferred — and reports zero motion. The next frame therefore measures from where the pointer
+ * actually is.
+ */
+export declare function createPointerVelocityTracker(opts?: PointerVelocityTrackerOptions): PointerVelocityTracker;
+export interface IdleGateOptions {
+    /**
+     * How many frames must have been dispatched (counted via `tickFrame`) before the gate is allowed
+     * to report a skip. A sim whose first frames initialize state and let it settle must not freeze
+     * mid-warm-up, or it freezes on garbage. Default 0 — no warm-up requirement.
+     */
+    warmupFrames?: number;
+}
+export interface IdleGate {
+    /**
+     * Record that something is driving the sim right now. `now` is a MILLISECOND timestamp on the same
+     * clock the caller passes to {@link IdleGate.shouldSkip} (`performance.now()` in practice), and
+     * `0` is a legitimate value — the gate tracks never-active separately.
+     */
+    markActive(now: number): void;
+    /** Count one dispatched frame toward the warm-up. Call it once the frame is committed. */
+    tickFrame(): void;
+    /** Nothing has ever driven the sim — there is no state worth advancing. */
+    readonly neverActive: boolean;
+    /** The warm-up has elapsed (always true when `warmupFrames` is 0). */
+    readonly warmedUp: boolean;
+    /**
+     * Whether this frame can be skipped entirely: nothing is driving the sim AND either it has never
+     * been driven or the last input is older than `fadeSeconds`.
+     *
+     * `driving` is the caller's own "something wants this frame" signal (a stroke in progress, an
+     * ambient force, a pending init). Pass `false` when the only driver is the pointer.
+     */
+    shouldSkip(now: number, fadeSeconds: number, driving?: boolean): boolean;
+}
+/**
+ * The "settle then freeze" gate: once the last input is far enough in the past that the field has
+ * decayed to invisibility, stop dispatching. The previously rendered texture persists on screen, so
+ * a settled sim costs zero GPU time.
+ *
+ * TimeTrail's reasoning is worth restating because it is the trap here: pointer *speed* being zero is
+ * NOT a valid skip condition. A stationary cursor over a field that is still evolving must keep
+ * dispatching — the gate is about elapsed time since the last input, never about instantaneous
+ * speed.
+ */
+export declare function createIdleGate(opts?: IdleGateOptions): IdleGate;
+/**
+ * Seconds for an exponentially decaying field to fall by a factor of `ratio` at `rate` per second —
+ * `ln(ratio) / max(rate, minRate)`. The floor keeps a near-zero dissipation rate from producing an
+ * infinite (or negative) fade window.
+ *
+ * `ratio` is the visibility budget: 255 means "wait until the field is 1/255 of its peak" (below one
+ * 8-bit level), 64 is a coarser, cheaper choice.
+ */
+export declare function decayFadeSeconds(ratio: number, rate: number, minRate?: number): number;
+export interface PathStampRibbonOptions<T> {
+    /** Stroke start, in the same units as `dx`/`dy` (viewport UV for every current consumer). */
+    fromX: number;
+    fromY: number;
+    /** Stroke delta for this frame. */
+    dx: number;
+    dy: number;
+    /** `|delta|`, in the same units as `stepSize`. */
+    dragDist: number;
+    /** Spacing between stamps. Typically a fraction of the brush radius. */
+    stepSize: number;
+    /** Hard cap on stamps per frame, so a huge flick cannot blow out the dispatch count. */
+    maxSteps: number;
+    /** Multiplier applied to the interpolated position before it reaches `write`. Default 1. */
+    scale?: number;
+    /**
+     * Optional per-stamp state resolved at BUILD time, in stamp order. Use this for anything that
+     * must advance once per stamp regardless of dispatch (InkFlow's colour cycle).
+     */
+    prepare?: (t: number) => T;
+    /**
+     * Write the stamp's uniform. Runs inside a thunk at DISPATCH time — the pass manager runs the
+     * thunk then the dispatch in `device.queue` order, which is what lets a single uniform buffer
+     * carry a different value per stamp.
+     */
+    write: (posX: number, posY: number, t: number, prepared: T) => void;
+    /** The splat/force pass dispatched after each write. */
+    pass: ComputeStep;
+}
+/**
+ * Append an interpolated ribbon of stamps along this frame's drag path to `nodes`, as alternating
+ * write-thunk / dispatch pairs.
+ *
+ * A fast flick covers a lot of ground in one frame; stamping only at the current pointer position
+ * leaves dotted gaps. Interpolating along the path at `stepSize` spacing lays a continuous ribbon.
+ * Stamps are placed at cell centres (`t = (s + 0.5) / n`) so a one-stamp frame lands mid-stroke
+ * rather than at either end.
+ *
+ * Returns the number of stamps appended.
+ */
+export declare function pathStampRibbon<T = undefined>(nodes: ComputeStep[], opts: PathStampRibbonOptions<T>): number;
+//# sourceMappingURL=pointer.d.ts.map

package/dist/core/gpu/kit/host/pointer.d.ts.map

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

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

@@ -26,6 +26,14 @@ export declare function select<T extends AnyVecInstance>(cond: boolean | AnyVecI
  * magnitudes.
  */
 export declare function lengthSq(v: AnyVecInstance): number;
+export * as constants from './constants';
+export * as tone from './tone';
+export * as geom from './geom';
+export * as cells from './cells';
+export * as aa from './aa';
+export * as fields from './fields';
+export * as cellular from './cellular';
+export * as lightfields from './lightfields';
 export * as blend from './blend';
 export * as mask from './mask';
 export * as colorMixing from './colorMixing';
@@ -40,6 +48,8 @@ export * as noise from './noise';
 export * as noiseColor from './noiseColor';
 export * as noiseStylize from './noiseStylize';
 export * as blur from './blur';
+export * as reveal from './reveal';
+export * as lighting from './lighting';
 export * as sdf from './sdf';
 export * as sdf3d from './sdf3d';
 export { toHalfFloat } from './dataEncoding';

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/gpu/kit/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,IAAI,MAAM,SAAS,CAAA;AAC1B,OAAO,KAAK,CAAC,MAAM,cAAc,CAAA;AACjC,OAAO,KAAK,GAAG,MAAM,aAAa,CAAA;AAClC,OAAO,KAAK,EAAC,cAAc,EAAE,WAAW,EAAC,MAAM,cAAc,CAAA;AAK7D,OAAO,EAAC,IAAI,EAAE,CAAC,EAAE,GAAG,EAAC,CAAA;AAErB;;GAEG;AACH,MAAM,MAAM,OAAO,GAAG,MAAM,GAAG,cAAc,GAAG,WAAW,CAAA;AAE3D;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;AAC3C,wBAAgB,QAAQ,CAAC,CAAC,SAAS,cAAc,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,CAAA;AAM3D;;;GAGG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAAA;AACjF,wBAAgB,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAAA;AAC9E,wBAAgB,MAAM,CAAC,CAAC,SAAS,cAAc,EAAE,IAAI,EAAE,OAAO,GAAG,cAAc,EAAE,MAAM,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,CAAC,CAAA;AAM1G;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,cAAc,GAAG,MAAM,CAGlD;AAMD,OAAO,KAAK,KAAK,MAAM,SAAS,CAAA;AAChC,OAAO,KAAK,IAAI,MAAM,QAAQ,CAAA;AAC9B,OAAO,KAAK,WAAW,MAAM,eAAe,CAAA;AAC5C,OAAO,KAAK,OAAO,MAAM,WAAW,CAAA;AACpC,OAAO,KAAK,MAAM,MAAM,UAAU,CAAA;AAClC,OAAO,KAAK,KAAK,MAAM,SAAS,CAAA;AAChC,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAA;AACtC,OAAO,KAAK,WAAW,MAAM,eAAe,CAAA;AAC5C,OAAO,KAAK,OAAO,MAAM,QAAQ,CAAA;AACjC,OAAO,KAAK,UAAU,MAAM,cAAc,CAAA;AAC1C,OAAO,KAAK,KAAK,MAAM,SAAS,CAAA;AAChC,OAAO,KAAK,UAAU,MAAM,cAAc,CAAA;AAC1C,OAAO,KAAK,YAAY,MAAM,gBAAgB,CAAA;AAC9C,OAAO,KAAK,IAAI,MAAM,QAAQ,CAAA;AAC9B,OAAO,KAAK,GAAG,MAAM,OAAO,CAAA;AAC5B,OAAO,KAAK,KAAK,MAAM,SAAS,CAAA;AAGhC,OAAO,EAAC,WAAW,EAAC,MAAM,gBAAgB,CAAA;AAC1C,OAAO,KAAK,OAAO,MAAM,WAAW,CAAA;AACpC,OAAO,KAAK,KAAK,MAAM,SAAS,CAAA;AAChC,OAAO,KAAK,MAAM,MAAM,UAAU,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/gpu/kit/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,IAAI,MAAM,SAAS,CAAA;AAC1B,OAAO,KAAK,CAAC,MAAM,cAAc,CAAA;AACjC,OAAO,KAAK,GAAG,MAAM,aAAa,CAAA;AAClC,OAAO,KAAK,EAAC,cAAc,EAAE,WAAW,EAAC,MAAM,cAAc,CAAA;AAK7D,OAAO,EAAC,IAAI,EAAE,CAAC,EAAE,GAAG,EAAC,CAAA;AAErB;;GAEG;AACH,MAAM,MAAM,OAAO,GAAG,MAAM,GAAG,cAAc,GAAG,WAAW,CAAA;AAE3D;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;AAC3C,wBAAgB,QAAQ,CAAC,CAAC,SAAS,cAAc,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,CAAA;AAM3D;;;GAGG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAAA;AACjF,wBAAgB,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAAA;AAC9E,wBAAgB,MAAM,CAAC,CAAC,SAAS,cAAc,EAAE,IAAI,EAAE,OAAO,GAAG,cAAc,EAAE,MAAM,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,CAAC,CAAA;AAM1G;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,cAAc,GAAG,MAAM,CAGlD;AAMD,OAAO,KAAK,SAAS,MAAM,aAAa,CAAA;AACxC,OAAO,KAAK,IAAI,MAAM,QAAQ,CAAA;AAC9B,OAAO,KAAK,IAAI,MAAM,QAAQ,CAAA;AAC9B,OAAO,KAAK,KAAK,MAAM,SAAS,CAAA;AAChC,OAAO,KAAK,EAAE,MAAM,MAAM,CAAA;AAC1B,OAAO,KAAK,MAAM,MAAM,UAAU,CAAA;AAClC,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAA;AACtC,OAAO,KAAK,WAAW,MAAM,eAAe,CAAA;AAC5C,OAAO,KAAK,KAAK,MAAM,SAAS,CAAA;AAChC,OAAO,KAAK,IAAI,MAAM,QAAQ,CAAA;AAC9B,OAAO,KAAK,WAAW,MAAM,eAAe,CAAA;AAC5C,OAAO,KAAK,OAAO,MAAM,WAAW,CAAA;AACpC,OAAO,KAAK,MAAM,MAAM,UAAU,CAAA;AAClC,OAAO,KAAK,KAAK,MAAM,SAAS,CAAA;AAChC,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAA;AACtC,OAAO,KAAK,WAAW,MAAM,eAAe,CAAA;AAC5C,OAAO,KAAK,OAAO,MAAM,QAAQ,CAAA;AACjC,OAAO,KAAK,UAAU,MAAM,cAAc,CAAA;AAC1C,OAAO,KAAK,KAAK,MAAM,SAAS,CAAA;AAChC,OAAO,KAAK,UAAU,MAAM,cAAc,CAAA;AAC1C,OAAO,KAAK,YAAY,MAAM,gBAAgB,CAAA;AAC9C,OAAO,KAAK,IAAI,MAAM,QAAQ,CAAA;AAC9B,OAAO,KAAK,MAAM,MAAM,UAAU,CAAA;AAClC,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAA;AACtC,OAAO,KAAK,GAAG,MAAM,OAAO,CAAA;AAC5B,OAAO,KAAK,KAAK,MAAM,SAAS,CAAA;AAGhC,OAAO,EAAC,WAAW,EAAC,MAAM,gBAAgB,CAAA;AAC1C,OAAO,KAAK,OAAO,MAAM,WAAW,CAAA;AACpC,OAAO,KAAK,KAAK,MAAM,SAAS,CAAA;AAChC,OAAO,KAAK,MAAM,MAAM,UAAU,CAAA"}

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

@@ -0,0 +1,114 @@
+import { d } from './index';
+
+/**
+ * Gaussian radial falloff: `exp(-(dist² · sharpness))`. 1 at the centre, decaying smoothly with no
+ * hard cutoff — the shape of a glare, a bloom core, or a soft light pool.
+ *
+ * `sharpness` is an inverse squared radius, not a radius: larger is TIGHTER. A light whose size is
+ * authored as a radius should pass `1 / (r² + ε)`, which is why the callers that expose a size
+ * slider compute their sharpness rather than passing the slider through.
+ */
+export declare const radialGaussianFalloff: import('typegpu').TgpuFn<(dist: d.F32, sharpness: d.F32) => d.F32>;
+/**
+ * Gaussian falloff over an already-normalized 2D offset: `exp((du² + dv²) · -sharpness)`.
+ *
+ * "Normalized" means each axis has been divided by its own radius before the call, which is what
+ * makes the spot ELLIPTICAL — pass `u/su, v/sv` with different radii and the falloff stretches along
+ * the wider axis. Callers layering several spots at different sharpnesses over the same `du, dv`
+ * (a core plus a wide shoulder) get the anisotropy for free.
+ */
+export declare const anisotropicGaussianSpot: import('typegpu').TgpuFn<(du: d.F32, dv: d.F32, sharpness: d.F32) => d.F32>;
+/**
+ * A round glow at a point in aspect-corrected UV space: `exp(-0.5 · dist² / sizeSq)`.
+ *
+ * Takes the light position as loose scalars and `sizeSq` as a SQUARED radius because the callers
+ * that place several of these per frame compute the positions and radii on the CPU (they are
+ * pixel-invariant) and pass them in packed vec4 extraFields — squaring on the GPU would be per-pixel
+ * work for a per-frame value.
+ */
+export declare const radialGaussianGlow: import('typegpu').TgpuFn<(uv: d.Vec2f, aspect: d.F32, lx: d.F32, ly: d.F32, sizeSq: d.F32) => d.F32>;
+/**
+ * Rotating sine lobes around an angle: `pow(sin(angle · count + phase) · 0.5 + 0.5, sharpness)`.
+ *
+ * The `·0.5 + 0.5` before the `pow` is what makes this read as rays rather than alternating bands:
+ * the sine's negative half becomes the gap between lobes, and raising the whole [0,1] wave to a
+ * power narrows the bright part without moving the lobe centres. `sharpness` below 1 widens.
+ *
+ * `phase` is signed time in practice — NEGATE the accumulated time to rotate clockwise.
+ */
+export declare const angularSineLobes: import('typegpu').TgpuFn<(angle: d.F32, count: d.F32, phase: d.F32, sharpness: d.F32) => d.F32>;
+/**
+ * Diffraction-style spikes around an angle: `pow(abs(cos(angle · halfCount)), power)`.
+ *
+ * `abs` (rather than the `·0.5 + 0.5` of {@link angularSineLobes}) is why this gives 2·halfCount
+ * spikes with hard nulls between them, the signature of an aperture's blade count — pass
+ * `blades / 2`. High `power` (3–8) is what makes them thin. Layering two calls at different powers
+ * and a small angular offset is the standard way to get a primary/secondary spike pattern.
+ */
+export declare const angularCosineSpikes: import('typegpu').TgpuFn<(angle: d.F32, halfCount: d.F32, power: d.F32) => d.F32>;
+/**
+ * Seam-free angular coordinates for a radial field, returned as
+ * `vec3(angle, angleWrapped, blend)`.
+ *
+ * THE PROBLEM THIS SOLVES: `atan2` returns [−π, π], so any pattern periodic in the angle has a
+ * discontinuity along the −x axis where the value jumps by 2π. Wrapping the angle into [0, 2π)
+ * moves the seam but does not remove it. The fix is to evaluate the pattern TWICE — once on each
+ * branch — and cross-fade between them across the seam, using a blend that is 0/1 well away from it.
+ * A conditional branch instead of a blend puts the seam back.
+ *
+ * Callers evaluate their pattern at `.x` and `.y` and `mix(atWrapped, atAngle, .z)`. Both
+ * evaluations must stay unconditional.
+ */
+export declare const seamlessAngularField: import('typegpu').TgpuFn<(delta: d.Vec2f) => d.Vec3f>;
+/**
+ * Three concentric ring bands at radii `center + spread`, `center`, `center − spread`, returned as
+ * an RGB triple — the prismatic edge of a lens element or a dispersed halo.
+ *
+ * Each channel is `1 − smoothstep(0, width, abs(dist − r))`, i.e. a band peaking ON its radius. The
+ * red channel takes the OUTER radius by convention (longer wavelength refracts less), so a positive
+ * `spread` gives the physically-expected red-outside/blue-inside fringe; pass a negative spread to
+ * invert it.
+ *
+ * `width` is floored at 1e-4 because callers derive it from a size slider (LensFlare's ring width is
+ * `size · 0.10`), and a zero width makes `smoothstep(0, 0, ·)` undefined.
+ */
+export declare const chromaticRingBand: import('typegpu').TgpuFn<(dist: d.F32, center: d.F32, spread: d.F32, width: d.F32) => d.Vec3f>;
+/**
+ * Project a point onto a segment: returns `vec2(t, distance)` where `t` ∈ [0,1] is the clamped
+ * parameter of the closest point along `a → b`.
+ *
+ * Returning BOTH values is the point — a tapered beam needs the parameter to interpolate its
+ * thickness and the distance to shade its cross-section, and recomputing either costs the same as
+ * the whole projection. The `max(lengthSq, 1e-4)` guard keeps a degenerate (zero-length) segment
+ * finite rather than NaN, which matters because a UI lets both endpoints sit on the same pixel.
+ */
+export declare const pointToSegment: import('typegpu').TgpuFn<(p: d.Vec2f, a: d.Vec2f, b: d.Vec2f) => d.Vec2f>;
+/**
+ * The glow cross-section of a tapered beam: given the perpendicular `dist` and the along-beam
+ * parameter `t` from {@link pointToSegment}, interpolate thickness and softness end-to-end and
+ * return `vec2(colorT, alpha)`.
+ *
+ * `alpha` is a smoothstep shoulder from the beam edge outward, raised to `1 + softness · 1.5` so a
+ * soft beam does not merely get wider but also fades non-linearly — a linear ramp reads as a flat
+ * band with a visible outer edge. `colorT` is the inside→outside colour parameter over the same
+ * transition zone, so a caller can shade the core and the falloff differently.
+ *
+ * The interpolated softness is floored at 1e-4 for the same reason `thickness` is: the softness props
+ * bottom out at 0 (Beam's do), and a zero softness collapses both transition zones to
+ * `smoothstep(1, 1, ·)`, which is undefined.
+ */
+export declare const taperedSegmentGlow: import('typegpu').TgpuFn<(dist: d.F32, t: d.F32, startThickness: d.F32, endThickness: d.F32, startSoftness: d.F32, endSoftness: d.F32) => d.Vec2f>;
+/**
+ * The local frame of a beam anchored at a point and aimed at the canvas centre: returns
+ * `vec2(u, v)` — distance ALONG the beam and LATERAL offset from it, in aspect-corrected space.
+ *
+ * `anchorRaw` is a TRANSFORMED position prop (`transformPosition` stores `1 − y`), so this recovers
+ * the authored y itself. The direction degenerates when the anchor sits at the centre; below a 0.02
+ * length it falls back to +x rather than normalizing near-zero, which would make the frame spin
+ * wildly as the anchor crosses the middle.
+ *
+ * Everything downstream (bloom, streak bands, falloff) is authored in this frame, which is what lets
+ * a light leak be dragged anywhere on the canvas and still point inward.
+ */
+export declare const beamLocalFrame: import('typegpu').TgpuFn<(uv: d.Vec2f, aspect: d.F32, anchorRaw: d.Vec2f) => d.Vec2f>;
+//# sourceMappingURL=lightfields.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lightfields.d.ts","sourceRoot":"","sources":["../../../src/gpu/kit/lightfields.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,EAAO,CAAC,EAAM,MAAM,SAAS,CAAA;AAKpC;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,oEAGhC,CAAA;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,uBAAuB,6EAGlC,CAAA;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,sGAOzB,CAAA;AAIN;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,iGAKvB,CAAA;AAEN;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,mFAG9B,CAAA;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,oBAAoB,uDAO/B,CAAA;AAIF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,iBAAiB,gGAQxB,CAAA;AAIN;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc,2EAUzB,CAAA;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,kBAAkB,oJAmBzB,CAAA;AAEN;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,cAAc,uFAWzB,CAAA"}

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

@@ -0,0 +1,115 @@
+import { d } from './index';
+
+/**
+ * The in-plane SDF gradient from the `.x` channel by forward difference:
+ * `((surfX.x − surf0.x)/eps, (surfY.x − surf0.x)/eps)`. Points OUTWARD (distance grows outward),
+ * with magnitude ≈ 1 for a true 2D distance field and ≫ 1 across a volumetric chord discontinuity —
+ * callers that build a direction from it must normalize with a guarded length. Pure.
+ */
+export declare const fieldGradient: import('typegpu').TgpuFn<(surf0: d.Vec4f, surfX: d.Vec4f, surfY: d.Vec4f, eps: d.F32) => d.Vec2f>;
+/**
+ * Surface normal of a VOLUMETRIC field: the marched depth in `.w` differentiated by forward
+ * difference and clamped, with `z = −1` (the renderer's view direction) before normalizing.
+ *
+ * `gradClamp` is the per-shader slope bound and is load-bearing, not decorative. A chord field is
+ * discontinuous where one lobe occludes another, so an unclamped slope spikes for a texel or two at
+ * every overlap and the normal there points nearly sideways — which reads as a bright seam. Tighter
+ * bounds give flatter, calmer surfaces; the fleet's current values are ±5 (LiquidMetal, Chrome,
+ * Water, BrushedMetal, CarbonFiber), ±4 (Plastic, Frost, Crystal) and ±6 (Goo). Pure.
+ */
+export declare const volumetricNormal: import('typegpu').TgpuFn<(surf0: d.Vec4f, surfX: d.Vec4f, surfY: d.Vec4f, eps: d.F32, gradClamp: d.F32) => d.Vec3f>;
+/**
+ * Flat-path normal for a bevelled 2D shape: tilt away from the face along the in-plane field
+ * gradient by `sinTilt` (the sine of the tilt angle, from a bevel profile such as
+ * `effects.bevel.bevelSin`), then complete the unit vector with `z = −cos`.
+ *
+ * `sinTilt` is CLAMPED to ≤ 0.9995 here — at exactly 1 the `z` term is 0 and the normal lies in the
+ * plane, which makes the reflected ray graze to infinity. Pure.
+ */
+export declare const bevelledFlatNormal: import('typegpu').TgpuFn<(grad: d.Vec2f, sinTilt: d.F32) => d.Vec3f>;
+/**
+ * Shape-local pattern coordinates: `sdfUV − 0.5` on the flat path, the sampler's surface-locked
+ * `.g/.b` coords on the volumetric path. This is what makes a surface pattern (molten relief,
+ * brush grain, weave, foil crinkle) STICK to a 3D shape instead of sliding across it in screen
+ * space. `volumetric` is the runtime 0/1 flag. Pure.
+ */
+export declare const patternCoords: import('typegpu').TgpuFn<(sdfUV: d.Vec2f, surf0: d.Vec4f, volumetric: d.F32) => d.Vec2f>;
+/**
+ * `true` when the fragment is outside the shape by more than two device pixels — the early-exit
+ * test at the top of a shape-effect composite body (`if (outsideShape(sdf, pxH)) return vec4(0)`).
+ * The two-pixel slack keeps the anti-aliased edge inside the shaded region. Pure.
+ */
+export declare const outsideShape: import('typegpu').TgpuFn<(sdf: d.F32, pxH: d.F32) => d.Bool>;
+/**
+ * The inside coverage mask: `clamp(−sdf / w, 0, 1)` over a transition width `w` derived from the
+ * shader's `sharpEdge` (`max(edgeSoftness · 0.5, 0.001)`) as `sharpEdge / 32`.
+ *
+ * The width is CLAMPED to at least `minPixels` device pixels. That clamp is the point of this fn:
+ * without it, `edgeSoftness → 0` collapses the transition below a pixel and the silhouette resolves
+ * as a raw aliased step. At the house value of 1.5 px the edge is anti-aliased and the extra half
+ * pixel also hides sub-pixel contour noise from the field's texel lattice (`glassComposite` set the
+ * precedent; D-7 propagated it to the metals). Pure.
+ */
+export declare const insideMask: import('typegpu').TgpuFn<(sdf: d.F32, sharpEdge: d.F32, pxH: d.F32, minPixels: d.F32) => d.F32>;
+/**
+ * The perspective view ray through a screen UV, pointing INTO the scene (`+z`), aspect-corrected
+ * and normalized. `fov` scales the off-axis spread: the fleet uses 0.6 (LiquidMetal, BrushedMetal,
+ * CarbonFiber, Water) and 0.55 (Chrome). A perspective ray is what lets a flat face sweep the
+ * environment across the canvas instead of reflecting one constant direction. Pure.
+ */
+export declare const perspectiveViewRay: import('typegpu').TgpuFn<(uv: d.Vec2f, aspect: d.F32, fov: d.F32) => d.Vec3f>;
+/** An orthonormal surface frame: `tangent` projected into the plane of `normal`, plus their cross
+ *  product. The basis anisotropic shading needs. */
+export declare const TangentFrame: d.WgslStruct<{
+    tangent: d.Vec3f;
+    bitangent: d.Vec3f;
+}>;
+/**
+ * Gram–Schmidt an arbitrary direction into the surface plane and complete the frame:
+ * `T = normalize(dir − n·(n·dir))`, `B = n × T`. `dir` supplies the anisotropy axis — the brush
+ * direction, or the per-cell tow direction of a weave. Pure.
+ */
+export declare const orthonormalTangentFrame: import('typegpu').TgpuFn<(normal: d.Vec3f, dir: d.Vec3f) => d.WgslStruct<{
+    tangent: d.Vec3f;
+    bitangent: d.Vec3f;
+}>>;
+/** Inputs to {@link wardAnisotropicSpecular} — a struct per C1 (six values). `view` points INTO
+ *  the scene (the `perspectiveViewRay` convention), `light` points at the light. */
+export declare const WardSpecularInput: d.WgslStruct<{
+    normal: d.Vec3f;
+    /** The anisotropy axis (brush / tow direction). Need not lie in the surface plane. */
+    tangent: d.Vec3f;
+    light: d.Vec3f;
+    view: d.Vec3f;
+    /** Roughness along the tangent. Larger → the highlight smears further along the grain. */
+    alphaAlong: d.F32;
+    /** Roughness across the tangent. Smaller → a tighter streak. */
+    alphaAcross: d.F32;
+}>;
+/**
+ * Ward anisotropic specular lobe, unit gain: `exp(−((h·T/αT)² + (h·B/αB)²) / ((h·N + 1)/2))` for
+ * the half-vector `h = normalize(L − V)`. Multiply by the material's specular gain at the call
+ * site. This is the streak that runs ALONG a brushed grain or a carbon tow — an isotropic
+ * Blinn–Phong lobe cannot produce it. Pure. */
+export declare const wardAnisotropicSpecular: import('typegpu').TgpuFn<(p: d.WgslStruct<{
+    normal: d.Vec3f;
+    /** The anisotropy axis (brush / tow direction). Need not lie in the surface plane. */
+    tangent: d.Vec3f;
+    light: d.Vec3f;
+    view: d.Vec3f;
+    /** Roughness along the tangent. Larger → the highlight smears further along the grain. */
+    alphaAlong: d.F32;
+    /** Roughness across the tangent. Smaller → a tighter streak. */
+    alphaAcross: d.F32;
+}>) => d.F32>;
+/**
+ * IQ cosine palette: `cos((t + phase)·2π)·0.5 + 0.5` per channel. The smooth spectral cycle behind
+ * every diffraction look in the library (holographic foil, thin-film iridescence). `t` wraps every
+ * 1.0.
+ *
+ * The phases are ARGUMENTS rather than baked thirds because the fleet's copies disagree in the 4th
+ * decimal (`1/3, 2/3` in Holographic vs `0.3333, 0.6667` in thinFilm). Unifying them would be a
+ * pixel change; passing each caller's current values keeps adoption pixel-neutral. Pure.
+ */
+export declare const cosinePalette: import('typegpu').TgpuFn<(t: d.F32, phaseR: d.F32, phaseG: d.F32, phaseB: d.F32) => d.Vec3f>;
+//# sourceMappingURL=lighting.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lighting.d.ts","sourceRoot":"","sources":["../../../src/gpu/kit/lighting.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,OAAO,EAAO,CAAC,EAAM,MAAM,SAAS,CAAA;AAKpC;;;;;GAKG;AACH,eAAO,MAAM,aAAa,mGAGxB,CAAA;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB,qHAMvB,CAAA;AAEN;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,sEAK7B,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,aAAa,0FAMxB,CAAA;AAIF;;;;GAIG;AACH,eAAO,MAAM,YAAY,8DAGvB,CAAA;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,UAAU,iGAIrB,CAAA;AAIF;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,+EAG7B,CAAA;AAIF;oDACoD;AACpD,eAAO,MAAM,YAAY;;;EAAmD,CAAA;AAE5E;;;;GAIG;AACH,eAAO,MAAM,uBAAuB;;;GASlC,CAAA;AAEF;oFACoF;AACpF,eAAO,MAAM,iBAAiB;;IAE1B,sFAAsF;;;;IAItF,0FAA0F;;IAE1F,gEAAgE;;EAElE,CAAA;AAEF;;;;+CAI+C;AAC/C,eAAO,MAAM,uBAAuB;;IAfhC,sFAAsF;;;;IAItF,0FAA0F;;IAE1F,gEAAgE;;aAsBlE,CAAA;AAIF;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,8FAOxB,CAAA"}