@dopaminefx/core 0.1.0

package/dist/engine/color.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Algorithmic color in OKLCH.
+ *
+ * OKLCH is perceptually uniform, so walking hue by the golden angle (137.5°)
+ * yields palettes that are always harmonious yet never repeat — the novelty
+ * that keeps a reward from habituating. Lightness/chroma come from the mood
+ * (saturated + bright == higher arousal *and* positive valence).
+ *
+ * We hand the shader *linear* sRGB, because light should be summed in linear
+ * space; sRGB gamma is only for talking to CSS.
+ */
+import type { Rng } from "./seed.js";
+/** Linear sRGB, nominally 0..1 (may exceed before clamping). */
+export interface RGB {
+    r: number;
+    g: number;
+    b: number;
+}
+export interface OKLCH {
+    /** Perceptual lightness, 0..1. */
+    L: number;
+    /** Chroma (colorfulness), ~0..0.4. */
+    C: number;
+    /** Hue in degrees, 0..360. */
+    h: number;
+}
+export declare const GOLDEN_ANGLE_DEG = 137.50776405003785;
+/** Positive modulo into [0, 360). */
+export declare const wrapHue: (h: number) => number;
+/**
+ * OKLCH → linear sRGB (Björn Ottosson's OKLab matrices). Result is gamut-clamped
+ * to [0, 1] per channel.
+ */
+export declare function oklchToLinearSrgb({ L, C, h }: OKLCH): RGB;
+export interface PaletteParams {
+    /** Base lightness for the stops. */
+    lightness: number;
+    /** Base chroma for the stops. */
+    chroma: number;
+    /** Center of the hue range this mood prefers, in degrees. */
+    hueCenter: number;
+    /** Width of the random hue range around the center, in degrees. */
+    hueRange: number;
+    /** 0..1 — how far the golden-angle stops fan out from the base hue. */
+    hueSpread: number;
+}
+/**
+ * Build a 3-stop linear-RGB palette. The base hue is drawn from `rng` (so an
+ * un-pinned seed gives a unique palette each fire), biased toward the mood's
+ * preferred range. Successive stops step by the golden angle, scaled by whimsy.
+ * Lightness and chroma breathe slightly across the stops for depth.
+ */
+export declare function buildPalette(rng: Rng, p: PaletteParams): RGB[];
+/** A parsed backdrop colour the overlay composites against. */
+export interface Backdrop {
+    /** sRGB 0..1 (the value as authored — NOT linearised). */
+    rgb: RGB;
+    /** Rec.709 relative luminance in sRGB space, 0 (black) .. 1 (white). */
+    luminance: number;
+}
+/**
+ * Parse any CSS colour string into a {@link Backdrop} (sRGB 0..1 + luminance),
+ * or `null` if it can't be understood. Handles hex and `rgb()/rgba()` directly;
+ * for everything else (named colours, `hsl()`, `color()`) it falls back to the
+ * browser's own normaliser via a throwaway 2D canvas when a DOM is present. The
+ * runtime uses the luminance to decide how strongly to cast shadow as a surface
+ * lightens; the colour itself isn't sent to the shader (the light layer
+ * composites source-over against the live page).
+ */
+export declare function parseBackdrop(css: string): Backdrop | null;
+//# sourceMappingURL=color.d.ts.map

package/dist/engine/color.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"color.d.ts","sourceRoot":"","sources":["../../src/engine/color.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,WAAW,CAAC;AAErC,gEAAgE;AAChE,MAAM,WAAW,GAAG;IAClB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAED,MAAM,WAAW,KAAK;IACpB,kCAAkC;IAClC,CAAC,EAAE,MAAM,CAAC;IACV,sCAAsC;IACtC,CAAC,EAAE,MAAM,CAAC;IACV,8BAA8B;IAC9B,CAAC,EAAE,MAAM,CAAC;CACX;AAED,eAAO,MAAM,gBAAgB,qBAAqB,CAAC;AAInD,qCAAqC;AACrC,eAAO,MAAM,OAAO,GAAI,GAAG,MAAM,KAAG,MAAiC,CAAC;AAEtE;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,KAAK,GAAG,GAAG,CAkBzD;AAED,MAAM,WAAW,aAAa;IAC5B,oCAAoC;IACpC,SAAS,EAAE,MAAM,CAAC;IAClB,iCAAiC;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,6DAA6D;IAC7D,SAAS,EAAE,MAAM,CAAC;IAClB,mEAAmE;IACnE,QAAQ,EAAE,MAAM,CAAC;IACjB,uEAAuE;IACvE,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,EAAE,aAAa,GAAG,GAAG,EAAE,CAa9D;AAED,+DAA+D;AAC/D,MAAM,WAAW,QAAQ;IACvB,0DAA0D;IAC1D,GAAG,EAAE,GAAG,CAAC;IACT,wEAAwE;IACxE,SAAS,EAAE,MAAM,CAAC;CACnB;AA2BD;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,CAgB1D"}

package/dist/engine/color.js

@@ -0,0 +1,107 @@
+/**
+ * Algorithmic color in OKLCH.
+ *
+ * OKLCH is perceptually uniform, so walking hue by the golden angle (137.5°)
+ * yields palettes that are always harmonious yet never repeat — the novelty
+ * that keeps a reward from habituating. Lightness/chroma come from the mood
+ * (saturated + bright == higher arousal *and* positive valence).
+ *
+ * We hand the shader *linear* sRGB, because light should be summed in linear
+ * space; sRGB gamma is only for talking to CSS.
+ */
+export const GOLDEN_ANGLE_DEG = 137.50776405003785;
+const clamp01 = (x) => (x < 0 ? 0 : x > 1 ? 1 : x);
+/** Positive modulo into [0, 360). */
+export const wrapHue = (h) => ((h % 360) + 360) % 360;
+/**
+ * OKLCH → linear sRGB (Björn Ottosson's OKLab matrices). Result is gamut-clamped
+ * to [0, 1] per channel.
+ */
+export function oklchToLinearSrgb({ L, C, h }) {
+    const hr = (h * Math.PI) / 180;
+    const a = C * Math.cos(hr);
+    const b = C * Math.sin(hr);
+    const l_ = L + 0.3963377774 * a + 0.2158037573 * b;
+    const m_ = L - 0.1055613458 * a - 0.0638541728 * b;
+    const s_ = L - 0.0894841775 * a - 1.291485548 * b;
+    const l = l_ * l_ * l_;
+    const m = m_ * m_ * m_;
+    const s = s_ * s_ * s_;
+    return {
+        r: clamp01(4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s),
+        g: clamp01(-1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s),
+        b: clamp01(-0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s),
+    };
+}
+/**
+ * Build a 3-stop linear-RGB palette. The base hue is drawn from `rng` (so an
+ * un-pinned seed gives a unique palette each fire), biased toward the mood's
+ * preferred range. Successive stops step by the golden angle, scaled by whimsy.
+ * Lightness and chroma breathe slightly across the stops for depth.
+ */
+export function buildPalette(rng, p) {
+    const baseHue = wrapHue(p.hueCenter + (rng() - 0.5) * p.hueRange);
+    const step = GOLDEN_ANGLE_DEG * (0.35 + 0.65 * p.hueSpread);
+    const lightSteps = [0.0, 0.06, -0.05];
+    const chromaSteps = [0.0, 0.02, -0.01];
+    return [0, 1, 2].map((i) => oklchToLinearSrgb({
+        L: clamp01(p.lightness + lightSteps[i]),
+        C: Math.max(0, p.chroma + chromaSteps[i]),
+        h: wrapHue(baseHue + step * i),
+    }));
+}
+/** Parse `#rgb[a]` / `#rrggbb[aa]` hex (3/4/6/8 digits) into sRGB 0..1, or null. */
+function parseHex(s) {
+    const m = /^#([0-9a-f]{3,8})$/i.exec(s);
+    if (!m)
+        return null;
+    const h = m[1];
+    const dup = (c) => parseInt(c + c, 16) / 255;
+    if (h.length === 3 || h.length === 4)
+        return { r: dup(h[0]), g: dup(h[1]), b: dup(h[2]) };
+    if (h.length === 6 || h.length === 8) {
+        const at = (i) => parseInt(h.slice(i, i + 2), 16) / 255;
+        return { r: at(0), g: at(2), b: at(4) };
+    }
+    return null;
+}
+/** Parse `rgb()/rgba()` (comma- or space-separated, 0–255 or %), or null. */
+function parseRgbFunc(s) {
+    const m = /^rgba?\(([^)]+)\)$/i.exec(s.trim());
+    if (!m)
+        return null;
+    const parts = m[1].split(/[\s,/]+/).filter(Boolean).slice(0, 3);
+    if (parts.length < 3)
+        return null;
+    const chan = (p) => p.endsWith("%") ? clamp01(parseFloat(p) / 100) : clamp01(parseFloat(p) / 255);
+    return { r: chan(parts[0]), g: chan(parts[1]), b: chan(parts[2]) };
+}
+/**
+ * Parse any CSS colour string into a {@link Backdrop} (sRGB 0..1 + luminance),
+ * or `null` if it can't be understood. Handles hex and `rgb()/rgba()` directly;
+ * for everything else (named colours, `hsl()`, `color()`) it falls back to the
+ * browser's own normaliser via a throwaway 2D canvas when a DOM is present. The
+ * runtime uses the luminance to decide how strongly to cast shadow as a surface
+ * lightens; the colour itself isn't sent to the shader (the light layer
+ * composites source-over against the live page).
+ */
+export function parseBackdrop(css) {
+    let rgb = parseHex(css) ?? parseRgbFunc(css);
+    if (!rgb && typeof document !== "undefined") {
+        try {
+            const ctx = document.createElement("canvas").getContext("2d");
+            if (ctx) {
+                ctx.fillStyle = "#000";
+                ctx.fillStyle = css; // the browser normalises to #rrggbb or rgb(a)(...)
+                rgb = parseHex(ctx.fillStyle) ?? parseRgbFunc(ctx.fillStyle);
+            }
+        }
+        catch {
+            /* no canvas — fall through to null */
+        }
+    }
+    if (!rgb)
+        return null;
+    return { rgb, luminance: 0.2126 * rgb.r + 0.7152 * rgb.g + 0.0722 * rgb.b };
+}
+//# sourceMappingURL=color.js.map

package/dist/engine/color.js.map

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

package/dist/engine/context.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Shared WebGL2 context + program cache.
+ *
+ * Before: every fire created a fresh canvas, a fresh WebGL context, and *linked
+ * a fresh program* (compiling both shaders) — once for the light pass and again
+ * for the shadow pass. Shader compilation is the single most expensive thing we
+ * do (tens of ms under SwiftShader), so doing it per fire made rapid/concurrent
+ * celebrations stutter and leaked GL contexts (browsers cap live contexts at
+ * ~16, after which the oldest is silently lost).
+ *
+ * After: a `GLContext` wraps one WebGL2 context and caches programs by shader
+ * source, so a given effect's shader links *once* for the lifetime of that
+ * context and every subsequent fire reuses it. Uniform locations are cached on
+ * the program. The conductor keeps one light context + one shadow context alive
+ * per target for the page's lifetime, so the expensive link happens once.
+ *
+ * The context is an abstraction (`GLContext`) rather than a raw `gl` so a future
+ * WebGPU backend can implement the same surface without touching effect code.
+ */
+/** A linked program with its uniform locations pre-resolved + cached. */
+export interface CachedProgram {
+    readonly program: WebGLProgram;
+    /** Resolve (and memoize) a uniform location by name. */
+    uniform(name: string): WebGLUniformLocation | null;
+    /** Resolve a whole set of uniforms at once (memoized). */
+    uniforms<N extends string>(names: readonly N[]): Record<N, WebGLUniformLocation | null>;
+}
+export interface GLContext {
+    readonly gl: WebGL2RenderingContext;
+    readonly canvas: HTMLCanvasElement;
+    /**
+     * Get a cached program for the given vertex+fragment source, linking it once
+     * on first request and reusing it thereafter.
+     */
+    program(vertexSrc: string, fragmentSrc: string): CachedProgram;
+    /** A shared empty VAO (the effects draw a full-screen triangle, no buffers). */
+    readonly vao: WebGLVertexArrayObject;
+    /** Tear everything down — programs, VAO, context. Used on full teardown. */
+    destroy(): void;
+}
+/** Options controlling how the drawing buffer composites with the page. */
+export interface GLContextOptions {
+    /**
+     * Give the canvas a PREMULTIPLIED-alpha drawing buffer (`alpha: true`,
+     * `premultipliedAlpha: true`). The default (false) is the historical opaque
+     * buffer the `mix-blend-mode: screen` light layer relies on. The
+     * backdrop-aware compositing path turns this on so the light layer can emit
+     * premultiplied light and composite source-over — visible on any surface.
+     */
+    premultiplied?: boolean;
+}
+/** Build a `GLContext` backed by `canvas`. Throws if WebGL2 is unavailable. */
+export declare function createGLContext(canvas: HTMLCanvasElement, opts?: GLContextOptions): GLContext;
+//# sourceMappingURL=context.d.ts.map

package/dist/engine/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/engine/context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAIH,yEAAyE;AACzE,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAC;IAC/B,wDAAwD;IACxD,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,oBAAoB,GAAG,IAAI,CAAC;IACnD,0DAA0D;IAC1D,QAAQ,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,GAAG,MAAM,CAAC,CAAC,EAAE,oBAAoB,GAAG,IAAI,CAAC,CAAC;CACzF;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,EAAE,EAAE,sBAAsB,CAAC;IACpC,QAAQ,CAAC,MAAM,EAAE,iBAAiB,CAAC;IACnC;;;OAGG;IACH,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,aAAa,CAAC;IAC/D,gFAAgF;IAChF,QAAQ,CAAC,GAAG,EAAE,sBAAsB,CAAC;IACrC,4EAA4E;IAC5E,OAAO,IAAI,IAAI,CAAC;CACjB;AASD,2EAA2E;AAC3E,MAAM,WAAW,gBAAgB;IAC/B;;;;;;OAMG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,+EAA+E;AAC/E,wBAAgB,eAAe,CAC7B,MAAM,EAAE,iBAAiB,EACzB,IAAI,GAAE,gBAAqB,GAC1B,SAAS,CAoDX"}

package/dist/engine/context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.js","sourceRoot":"","sources":["../../src/engine/context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAyBtC,MAAM,OAAO,GAA2B;IACtC,KAAK,EAAE,KAAK;IACZ,SAAS,EAAE,KAAK;IAChB,kBAAkB,EAAE,KAAK;IACzB,eAAe,EAAE,kBAAkB;CACpC,CAAC;AAcF,+EAA+E;AAC/E,MAAM,UAAU,eAAe,CAC7B,MAAyB,EACzB,OAAyB,EAAE;IAE3B,MAAM,KAAK,GAA2B,IAAI,CAAC,aAAa;QACtD,CAAC,CAAC,EAAE,GAAG,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,kBAAkB,EAAE,IAAI,EAAE;QACvD,CAAC,CAAC,OAAO,CAAC;IACZ,MAAM,EAAE,GAAG,MAAM,CAAC,UAAU,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;IAC9C,IAAI,CAAC,EAAE;QAAE,MAAM,IAAI,KAAK,CAAC,mCAAmC,CAAC,CAAC;IAE9D,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAyB,CAAC;IAClD,MAAM,GAAG,GAAG,EAAE,CAAC,iBAAiB,EAAE,CAAC;IACnC,IAAI,CAAC,GAAG;QAAE,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAC;IAE5D,MAAM,UAAU,GAAG,CAAC,OAAqB,EAAiB,EAAE;QAC1D,MAAM,IAAI,GAAG,IAAI,GAAG,EAAuC,CAAC;QAC5D,MAAM,OAAO,GAAG,CAAC,IAAY,EAA+B,EAAE;YAC5D,IAAI,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;YACzB,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC;gBACtB,GAAG,GAAG,EAAE,CAAC,kBAAkB,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;gBAC3C,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;YACtB,CAAC;YACD,OAAO,GAAG,CAAC;QACb,CAAC,CAAC;QACF,OAAO;YACL,OAAO;YACP,OAAO;YACP,QAAQ,CAAmB,KAAmB;gBAC5C,OAAO,MAAM,CAAC,WAAW,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAG1D,CAAC;YACJ,CAAC;SACF,CAAC;IACJ,CAAC,CAAC;IAEF,OAAO;QACL,EAAE;QACF,MAAM;QACN,GAAG;QACH,OAAO,CAAC,SAAiB,EAAE,WAAmB;YAC5C,MAAM,GAAG,GAAG,GAAG,SAAS,IAAI,WAAW,EAAE,CAAC;YAC1C,IAAI,MAAM,GAAG,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YAC/B,IAAI,CAAC,MAAM,EAAE,CAAC;gBACZ,MAAM,GAAG,UAAU,CAAC,WAAW,CAAC,EAAE,EAAE,SAAS,EAAE,WAAW,CAAC,CAAC,CAAC;gBAC7D,QAAQ,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;YAC5B,CAAC;YACD,OAAO,MAAM,CAAC;QAChB,CAAC;QACD,OAAO;YACL,KAAK,MAAM,EAAE,OAAO,EAAE,IAAI,QAAQ,CAAC,MAAM,EAAE;gBAAE,EAAE,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;YACvE,QAAQ,CAAC,KAAK,EAAE,CAAC;YACjB,EAAE,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC;QAC5B,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/engine/gl.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Low-level WebGL2 helpers: shader compilation + program linking. Kept separate
+ * from any particular effect so every effect (and the shared context's program
+ * cache) reuses the exact same, well-tested path. This is the single place a
+ * GLSL program is compiled in the whole library.
+ */
+/** Compile + link a vertex/fragment pair into a program. */
+export declare function linkProgram(gl: WebGL2RenderingContext, vertexSrc: string, fragmentSrc: string): WebGLProgram;
+//# sourceMappingURL=gl.d.ts.map

package/dist/engine/gl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gl.d.ts","sourceRoot":"","sources":["../../src/engine/gl.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAmBH,4DAA4D;AAC5D,wBAAgB,WAAW,CACzB,EAAE,EAAE,sBAAsB,EAC1B,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,GAClB,YAAY,CAgBd"}

package/dist/engine/gl.js

@@ -0,0 +1,39 @@
+/**
+ * Low-level WebGL2 helpers: shader compilation + program linking. Kept separate
+ * from any particular effect so every effect (and the shared context's program
+ * cache) reuses the exact same, well-tested path. This is the single place a
+ * GLSL program is compiled in the whole library.
+ */
+function compileShader(gl, type, src) {
+    const sh = gl.createShader(type);
+    if (!sh)
+        throw new Error("dopamine: failed to create shader");
+    gl.shaderSource(sh, src);
+    gl.compileShader(sh);
+    if (!gl.getShaderParameter(sh, gl.COMPILE_STATUS)) {
+        const log = gl.getShaderInfoLog(sh);
+        gl.deleteShader(sh);
+        throw new Error(`dopamine: shader compile error\n${log ?? ""}`);
+    }
+    return sh;
+}
+/** Compile + link a vertex/fragment pair into a program. */
+export function linkProgram(gl, vertexSrc, fragmentSrc) {
+    const vs = compileShader(gl, gl.VERTEX_SHADER, vertexSrc);
+    const fs = compileShader(gl, gl.FRAGMENT_SHADER, fragmentSrc);
+    const program = gl.createProgram();
+    if (!program)
+        throw new Error("dopamine: failed to create program");
+    gl.attachShader(program, vs);
+    gl.attachShader(program, fs);
+    gl.linkProgram(program);
+    gl.deleteShader(vs);
+    gl.deleteShader(fs);
+    if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
+        const log = gl.getProgramInfoLog(program);
+        gl.deleteProgram(program);
+        throw new Error(`dopamine: program link error\n${log ?? ""}`);
+    }
+    return program;
+}
+//# sourceMappingURL=gl.js.map

package/dist/engine/gl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gl.js","sourceRoot":"","sources":["../../src/engine/gl.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,SAAS,aAAa,CACpB,EAA0B,EAC1B,IAAY,EACZ,GAAW;IAEX,MAAM,EAAE,GAAG,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IACjC,IAAI,CAAC,EAAE;QAAE,MAAM,IAAI,KAAK,CAAC,mCAAmC,CAAC,CAAC;IAC9D,EAAE,CAAC,YAAY,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC;IACzB,EAAE,CAAC,aAAa,CAAC,EAAE,CAAC,CAAC;IACrB,IAAI,CAAC,EAAE,CAAC,kBAAkB,CAAC,EAAE,EAAE,EAAE,CAAC,cAAc,CAAC,EAAE,CAAC;QAClD,MAAM,GAAG,GAAG,EAAE,CAAC,gBAAgB,CAAC,EAAE,CAAC,CAAC;QACpC,EAAE,CAAC,YAAY,CAAC,EAAE,CAAC,CAAC;QACpB,MAAM,IAAI,KAAK,CAAC,mCAAmC,GAAG,IAAI,EAAE,EAAE,CAAC,CAAC;IAClE,CAAC;IACD,OAAO,EAAE,CAAC;AACZ,CAAC;AAED,4DAA4D;AAC5D,MAAM,UAAU,WAAW,CACzB,EAA0B,EAC1B,SAAiB,EACjB,WAAmB;IAEnB,MAAM,EAAE,GAAG,aAAa,CAAC,EAAE,EAAE,EAAE,CAAC,aAAa,EAAE,SAAS,CAAC,CAAC;IAC1D,MAAM,EAAE,GAAG,aAAa,CAAC,EAAE,EAAE,EAAE,CAAC,eAAe,EAAE,WAAW,CAAC,CAAC;IAC9D,MAAM,OAAO,GAAG,EAAE,CAAC,aAAa,EAAE,CAAC;IACnC,IAAI,CAAC,OAAO;QAAE,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAC;IACpE,EAAE,CAAC,YAAY,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;IAC7B,EAAE,CAAC,YAAY,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;IAC7B,EAAE,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;IACxB,EAAE,CAAC,YAAY,CAAC,EAAE,CAAC,CAAC;IACpB,EAAE,CAAC,YAAY,CAAC,EAAE,CAAC,CAAC;IACpB,IAAI,CAAC,EAAE,CAAC,mBAAmB,CAAC,OAAO,EAAE,EAAE,CAAC,WAAW,CAAC,EAAE,CAAC;QACrD,MAAM,GAAG,GAAG,EAAE,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC;QAC1C,EAAE,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;QAC1B,MAAM,IAAI,KAAK,CAAC,iCAAiC,GAAG,IAAI,EAAE,EAAE,CAAC,CAAC;IAChE,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC"}

package/dist/engine/look/glsl.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Shared GLSL "look" chunk library.
+ *
+ * The three effects grew in parallel and each re-implemented (and drifted) the
+ * same building blocks inside its own shader: value-noise + fbm + domain warp,
+ * the palette mix, the segment SDF, the ACES tonemap, the IQ-cosine iridescence,
+ * the Ben-Day halftone and the ordered dither. Per the cross-pollination plan,
+ * those are lifted here into ONE canonical copy each, so every shader composes
+ * the SAME function instead of a private fork. Effects assemble their fragment
+ * source by concatenating the chunks they need ahead of their own `main()`.
+ *
+ * Each chunk is a self-contained GLSL snippet (no `#version`/`precision`/IO —
+ * those stay in the per-effect shader). The text below is byte-identical to the
+ * canonical implementations the effects already shipped, so adopting the library
+ * does not change any effect's look; it only removes the duplication + drift.
+ *
+ * NOTE: This is a GLSL *chunk* library (string includes), not a transpiler — it
+ * maps onto the `.dope` format's referenced shader bodies (the format references
+ * GLSL; it does not generate it).
+ */
+/** TAU + a couple of constants every effect uses. */
+export declare const GLSL_CONSTANTS = "\n#define TAU 6.28318530718\n";
+/**
+ * Hash helpers (Dave Hoskins style) — `hash11` (1→1) and `hash21` (1→2). Used
+ * by the noise field, the particles, and the per-frame dither.
+ */
+export declare const GLSL_HASH = "\nfloat hash11(float p){ p = fract(p * 0.1031); p *= p + 33.33; p *= p + p; return fract(p); }\nvec2 hash21(float p){\n  vec3 p3 = fract(vec3(p) * vec3(0.1031, 0.1030, 0.0973));\n  p3 += dot(p3, p3.yzx + 33.33);\n  return fract((p3.xx + p3.yz) * p3.zy);\n}\n";
+/**
+ * Value noise + 4-octave fbm with a per-octave rotation (kills axis-aligned
+ * artifacts). Requires GLSL_HASH. This is the volumetric texture source for the
+ * bloom interior and the wet-ink edge wobble.
+ */
+export declare const GLSL_FBM = "\nfloat vnoise(vec2 p){\n  vec2 i = floor(p), f = fract(p);\n  vec2 u = f * f * (3.0 - 2.0 * f);\n  float a = hash11(dot(i, vec2(1.0, 57.0)));\n  float b = hash11(dot(i + vec2(1.0, 0.0), vec2(1.0, 57.0)));\n  float c = hash11(dot(i + vec2(0.0, 1.0), vec2(1.0, 57.0)));\n  float d = hash11(dot(i + vec2(1.0, 1.0), vec2(1.0, 57.0)));\n  return mix(mix(a, b, u.x), mix(c, d, u.x), u.y);\n}\nfloat fbm(vec2 p){\n  float s = 0.0, a = 0.5;\n  mat2 rot = mat2(0.80, -0.60, 0.60, 0.80);\n  for (int i = 0; i < 4; i++) { s += a * vnoise(p); p = rot * p * 2.03; a *= 0.5; }\n  return s;\n}\n";
+/**
+ * Two-level domain warp: warp the sample point by an fbm-derived offset, then
+ * sample fbm again — the smoke-like living interior of a real bloom. Returns the
+ * warped fbm value at `p`; `t` is time, `amount` the warp strength. Requires
+ * GLSL_FBM.
+ */
+export declare const GLSL_DOMAIN_WARP = "\nfloat domainWarp(vec2 p, float t, float amount){\n  vec2 warp = vec2(fbm(p + t * 0.18), fbm(p.yx - t * 0.12)) - 0.5;\n  return fbm(p + warp * 1.2 * amount + t * 0.25);\n}\n";
+/** 3-stop palette mix (inner→mid→outer). Effects declare uC0/uC1/uC2 uniforms. */
+export declare const GLSL_PALETTE_MIX = "\nvec3 paletteMix(float t){\n  t = clamp(t, 0.0, 1.0);\n  return t < 0.5 ? mix(uC0, uC1, t * 2.0) : mix(uC1, uC2, (t - 0.5) * 2.0);\n}\n";
+/**
+ * Inigo Quilez cosine palette — a smooth spectral sweep used for thin-film
+ * iridescence (oil-on-water sheen): cycles through complementary hues, NOT the
+ * mood palette, so it reads as an iridescent film over the mark.
+ */
+export declare const GLSL_IRIDESCENT = "\nvec3 iridescent(float t){\n  return 0.55 + 0.45 * cos(TAU * (vec3(1.0) * t + vec3(0.0, 0.33, 0.67)));\n}\n";
+/**
+ * Spectral dispersion amount at a refractive edge — grows toward the rim and
+ * with amplitude, gated by a 0..1 strength. `dn` is normalized radius/edge
+ * proximity (1 == edge); used to sample a profile at channel-shifted positions.
+ */
+export declare const GLSL_DISPERSION = "\nfloat dispersionAmount(float strength, float dn, float amp){\n  return strength * (0.06 + 0.12 * smoothstep(0.2, 1.1, dn)) * (0.7 + 0.5 * amp);\n}\n";
+/** Capsule/segment SDF (the safe variant — guards zero-length segments). */
+export declare const GLSL_SD_SEG = "\nfloat sdSeg(vec2 p, vec2 a, vec2 b){\n  vec2 pa = p - a, ba = b - a;\n  float h = clamp(dot(pa, ba) / max(dot(ba, ba), 1e-3), 0.0, 1.0);\n  return length(pa - ba * h);\n}\n";
+/**
+ * ACES filmic tonemap (Narkowicz) — richer highlight rolloff than `x/(1+x)`,
+ * keeps highlights from going chalky while preserving saturated mid-lights.
+ */
+export declare const GLSL_TONEMAP_ACES = "\nvec3 tonemapACES(vec3 x){\n  const float a = 2.51, b = 0.03, c = 2.43, d = 0.59, e = 0.14;\n  return clamp((x * (a * x + b)) / (x * (c * x + d) + e), 0.0, 1.0);\n}\n";
+/**
+ * Ordered/triangular-hash dither, ~1/255, to break the smooth-gradient banding
+ * the screen blend reveals on the page beneath. `frag` device px, `t` seconds,
+ * `fade` 0..1 (1 = full dither; effects fade it out toward the cel/pop end where
+ * hard bands are intended). Requires GLSL_HASH.
+ */
+export declare const GLSL_DITHER = "\nvec3 ditherAdd(vec3 col, vec2 frag, float t, float fade){\n  float dz = hash11(dot(frag, vec2(12.989, 78.233)) + t) - 0.5;\n  return col + (dz / 255.0) * fade;\n}\n";
+/**
+ * Ben-Day halftone coverage: 1 inside a dot, 0 outside, antialiased. Dot RADIUS
+ * grows with tone `v`; the screen is rotated by `ang` (classic per-channel
+ * screen angle). Requires the matrix helper below.
+ */
+export declare const GLSL_ROT2 = "\nmat2 rot2(float a){ float s = sin(a), c = cos(a); return mat2(c, -s, s, c); }\n";
+export declare const GLSL_HALFTONE = "\nfloat benday(vec2 frag, float cell, float v, float ang){\n  vec2 p = rot2(ang) * frag / cell;\n  vec2 g = fract(p) - 0.5;\n  float d = length(g);\n  float r = 0.52 * sqrt(clamp(v, 0.0, 1.0));\n  float aa = 0.7 / cell + fwidth(d);\n  return 1.0 - smoothstep(r - aa, r + aa, d);\n}\n";
+/**
+ * PREMULTIPLIED LIGHT OUT — the portable compositing emit.
+ *
+ * The default web overlay leans on CSS `mix-blend-mode: screen` to cast the
+ * effect's light onto the page, which is rich on a dark UI but mathematically
+ * invisible on white (`screen(x, 1) == 1`). The native stacks (iOS/Android) have
+ * no per-surface screen blend, so they instead emit PREMULTIPLIED light — `rgb`
+ * unchanged, `alpha = its own brightness` — and let the OS composite it
+ * source-over: dark regions go transparent (the host shows through), bright
+ * light reads as cast colour, and crucially it stays visible on ANY backdrop,
+ * white included. This is byte-identical to Android's `Look.kt` `dopLightOut`.
+ *
+ * The web runtime reuses this for its "backdrop"-aware compositing path: when a
+ * caller passes a known surface colour, the light pass swaps its opaque
+ * `vec4(col, 1.0)` emit for `dopLightOut(col)` and composites source-over
+ * (`mix-blend-mode: normal`) instead of screen — see `pass-common.ts`'s
+ * `compositeLightFragment`.
+ */
+export declare const GLSL_LIGHT_OUT = "\nvec4 dopLightOut(vec3 col){\n  col = max(col, 0.0);\n  float a = clamp(max(max(col.r, col.g), col.b), 0.0, 1.0);\n  return vec4(col, a);\n}\n";
+//# sourceMappingURL=glsl.d.ts.map

package/dist/engine/look/glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glsl.d.ts","sourceRoot":"","sources":["../../../src/engine/look/glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,qDAAqD;AACrD,eAAO,MAAM,cAAc,kCAE1B,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,SAAS,uQAOrB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,QAAQ,0kBAgBpB,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,mLAK5B,CAAC;AAEF,kFAAkF;AAClF,eAAO,MAAM,gBAAgB,6IAK5B,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,eAAe,iHAI3B,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,eAAe,2JAI3B,CAAC;AAEF,4EAA4E;AAC5E,eAAO,MAAM,WAAW,mLAMvB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,iBAAiB,4KAK7B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,WAAW,2KAKvB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,SAAS,sFAErB,CAAC;AAEF,eAAO,MAAM,aAAa,gSASzB,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,cAAc,oJAM1B,CAAC"}

package/dist/engine/look/glsl.js

@@ -0,0 +1,171 @@
+/**
+ * Shared GLSL "look" chunk library.
+ *
+ * The three effects grew in parallel and each re-implemented (and drifted) the
+ * same building blocks inside its own shader: value-noise + fbm + domain warp,
+ * the palette mix, the segment SDF, the ACES tonemap, the IQ-cosine iridescence,
+ * the Ben-Day halftone and the ordered dither. Per the cross-pollination plan,
+ * those are lifted here into ONE canonical copy each, so every shader composes
+ * the SAME function instead of a private fork. Effects assemble their fragment
+ * source by concatenating the chunks they need ahead of their own `main()`.
+ *
+ * Each chunk is a self-contained GLSL snippet (no `#version`/`precision`/IO —
+ * those stay in the per-effect shader). The text below is byte-identical to the
+ * canonical implementations the effects already shipped, so adopting the library
+ * does not change any effect's look; it only removes the duplication + drift.
+ *
+ * NOTE: This is a GLSL *chunk* library (string includes), not a transpiler — it
+ * maps onto the `.dope` format's referenced shader bodies (the format references
+ * GLSL; it does not generate it).
+ */
+/** TAU + a couple of constants every effect uses. */
+export const GLSL_CONSTANTS = /* glsl */ `
+#define TAU 6.28318530718
+`;
+/**
+ * Hash helpers (Dave Hoskins style) — `hash11` (1→1) and `hash21` (1→2). Used
+ * by the noise field, the particles, and the per-frame dither.
+ */
+export const GLSL_HASH = /* glsl */ `
+float hash11(float p){ p = fract(p * 0.1031); p *= p + 33.33; p *= p + p; return fract(p); }
+vec2 hash21(float p){
+  vec3 p3 = fract(vec3(p) * vec3(0.1031, 0.1030, 0.0973));
+  p3 += dot(p3, p3.yzx + 33.33);
+  return fract((p3.xx + p3.yz) * p3.zy);
+}
+`;
+/**
+ * Value noise + 4-octave fbm with a per-octave rotation (kills axis-aligned
+ * artifacts). Requires GLSL_HASH. This is the volumetric texture source for the
+ * bloom interior and the wet-ink edge wobble.
+ */
+export const GLSL_FBM = /* glsl */ `
+float vnoise(vec2 p){
+  vec2 i = floor(p), f = fract(p);
+  vec2 u = f * f * (3.0 - 2.0 * f);
+  float a = hash11(dot(i, vec2(1.0, 57.0)));
+  float b = hash11(dot(i + vec2(1.0, 0.0), vec2(1.0, 57.0)));
+  float c = hash11(dot(i + vec2(0.0, 1.0), vec2(1.0, 57.0)));
+  float d = hash11(dot(i + vec2(1.0, 1.0), vec2(1.0, 57.0)));
+  return mix(mix(a, b, u.x), mix(c, d, u.x), u.y);
+}
+float fbm(vec2 p){
+  float s = 0.0, a = 0.5;
+  mat2 rot = mat2(0.80, -0.60, 0.60, 0.80);
+  for (int i = 0; i < 4; i++) { s += a * vnoise(p); p = rot * p * 2.03; a *= 0.5; }
+  return s;
+}
+`;
+/**
+ * Two-level domain warp: warp the sample point by an fbm-derived offset, then
+ * sample fbm again — the smoke-like living interior of a real bloom. Returns the
+ * warped fbm value at `p`; `t` is time, `amount` the warp strength. Requires
+ * GLSL_FBM.
+ */
+export const GLSL_DOMAIN_WARP = /* glsl */ `
+float domainWarp(vec2 p, float t, float amount){
+  vec2 warp = vec2(fbm(p + t * 0.18), fbm(p.yx - t * 0.12)) - 0.5;
+  return fbm(p + warp * 1.2 * amount + t * 0.25);
+}
+`;
+/** 3-stop palette mix (inner→mid→outer). Effects declare uC0/uC1/uC2 uniforms. */
+export const GLSL_PALETTE_MIX = /* glsl */ `
+vec3 paletteMix(float t){
+  t = clamp(t, 0.0, 1.0);
+  return t < 0.5 ? mix(uC0, uC1, t * 2.0) : mix(uC1, uC2, (t - 0.5) * 2.0);
+}
+`;
+/**
+ * Inigo Quilez cosine palette — a smooth spectral sweep used for thin-film
+ * iridescence (oil-on-water sheen): cycles through complementary hues, NOT the
+ * mood palette, so it reads as an iridescent film over the mark.
+ */
+export const GLSL_IRIDESCENT = /* glsl */ `
+vec3 iridescent(float t){
+  return 0.55 + 0.45 * cos(TAU * (vec3(1.0) * t + vec3(0.0, 0.33, 0.67)));
+}
+`;
+/**
+ * Spectral dispersion amount at a refractive edge — grows toward the rim and
+ * with amplitude, gated by a 0..1 strength. `dn` is normalized radius/edge
+ * proximity (1 == edge); used to sample a profile at channel-shifted positions.
+ */
+export const GLSL_DISPERSION = /* glsl */ `
+float dispersionAmount(float strength, float dn, float amp){
+  return strength * (0.06 + 0.12 * smoothstep(0.2, 1.1, dn)) * (0.7 + 0.5 * amp);
+}
+`;
+/** Capsule/segment SDF (the safe variant — guards zero-length segments). */
+export const GLSL_SD_SEG = /* glsl */ `
+float sdSeg(vec2 p, vec2 a, vec2 b){
+  vec2 pa = p - a, ba = b - a;
+  float h = clamp(dot(pa, ba) / max(dot(ba, ba), 1e-3), 0.0, 1.0);
+  return length(pa - ba * h);
+}
+`;
+/**
+ * ACES filmic tonemap (Narkowicz) — richer highlight rolloff than `x/(1+x)`,
+ * keeps highlights from going chalky while preserving saturated mid-lights.
+ */
+export const GLSL_TONEMAP_ACES = /* glsl */ `
+vec3 tonemapACES(vec3 x){
+  const float a = 2.51, b = 0.03, c = 2.43, d = 0.59, e = 0.14;
+  return clamp((x * (a * x + b)) / (x * (c * x + d) + e), 0.0, 1.0);
+}
+`;
+/**
+ * Ordered/triangular-hash dither, ~1/255, to break the smooth-gradient banding
+ * the screen blend reveals on the page beneath. `frag` device px, `t` seconds,
+ * `fade` 0..1 (1 = full dither; effects fade it out toward the cel/pop end where
+ * hard bands are intended). Requires GLSL_HASH.
+ */
+export const GLSL_DITHER = /* glsl */ `
+vec3 ditherAdd(vec3 col, vec2 frag, float t, float fade){
+  float dz = hash11(dot(frag, vec2(12.989, 78.233)) + t) - 0.5;
+  return col + (dz / 255.0) * fade;
+}
+`;
+/**
+ * Ben-Day halftone coverage: 1 inside a dot, 0 outside, antialiased. Dot RADIUS
+ * grows with tone `v`; the screen is rotated by `ang` (classic per-channel
+ * screen angle). Requires the matrix helper below.
+ */
+export const GLSL_ROT2 = /* glsl */ `
+mat2 rot2(float a){ float s = sin(a), c = cos(a); return mat2(c, -s, s, c); }
+`;
+export const GLSL_HALFTONE = /* glsl */ `
+float benday(vec2 frag, float cell, float v, float ang){
+  vec2 p = rot2(ang) * frag / cell;
+  vec2 g = fract(p) - 0.5;
+  float d = length(g);
+  float r = 0.52 * sqrt(clamp(v, 0.0, 1.0));
+  float aa = 0.7 / cell + fwidth(d);
+  return 1.0 - smoothstep(r - aa, r + aa, d);
+}
+`;
+/**
+ * PREMULTIPLIED LIGHT OUT — the portable compositing emit.
+ *
+ * The default web overlay leans on CSS `mix-blend-mode: screen` to cast the
+ * effect's light onto the page, which is rich on a dark UI but mathematically
+ * invisible on white (`screen(x, 1) == 1`). The native stacks (iOS/Android) have
+ * no per-surface screen blend, so they instead emit PREMULTIPLIED light — `rgb`
+ * unchanged, `alpha = its own brightness` — and let the OS composite it
+ * source-over: dark regions go transparent (the host shows through), bright
+ * light reads as cast colour, and crucially it stays visible on ANY backdrop,
+ * white included. This is byte-identical to Android's `Look.kt` `dopLightOut`.
+ *
+ * The web runtime reuses this for its "backdrop"-aware compositing path: when a
+ * caller passes a known surface colour, the light pass swaps its opaque
+ * `vec4(col, 1.0)` emit for `dopLightOut(col)` and composites source-over
+ * (`mix-blend-mode: normal`) instead of screen — see `pass-common.ts`'s
+ * `compositeLightFragment`.
+ */
+export const GLSL_LIGHT_OUT = /* glsl */ `
+vec4 dopLightOut(vec3 col){
+  col = max(col, 0.0);
+  float a = clamp(max(max(col.r, col.g), col.b), 0.0, 1.0);
+  return vec4(col, a);
+}
+`;
+//# sourceMappingURL=glsl.js.map

package/dist/engine/look/glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glsl.js","sourceRoot":"","sources":["../../../src/engine/look/glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,qDAAqD;AACrD,MAAM,CAAC,MAAM,cAAc,GAAG,UAAU,CAAC;;CAExC,CAAC;AAEF;;;GAGG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,UAAU,CAAC;;;;;;;CAOnC,CAAC;AAEF;;;;GAIG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;CAgBlC,CAAC;AAEF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,UAAU,CAAC;;;;;CAK1C,CAAC;AAEF,kFAAkF;AAClF,MAAM,CAAC,MAAM,gBAAgB,GAAG,UAAU,CAAC;;;;;CAK1C,CAAC;AAEF;;;;GAIG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,UAAU,CAAC;;;;CAIzC,CAAC;AAEF;;;;GAIG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,UAAU,CAAC;;;;CAIzC,CAAC;AAEF,4EAA4E;AAC5E,MAAM,CAAC,MAAM,WAAW,GAAG,UAAU,CAAC;;;;;;CAMrC,CAAC;AAEF;;;GAGG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,UAAU,CAAC;;;;;CAK3C,CAAC;AAEF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,UAAU,CAAC;;;;;CAKrC,CAAC;AAEF;;;;GAIG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,UAAU,CAAC;;CAEnC,CAAC;AAEF,MAAM,CAAC,MAAM,aAAa,GAAG,UAAU,CAAC;;;;;;;;;CASvC,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,UAAU,CAAC;;;;;;CAMxC,CAAC"}

package/dist/engine/look/particles.glsl.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Shared GPU-particle GLSL chunk.
+ *
+ * Solarbloom's drifting "motes" and Verdict's flung "droplets" are both
+ * point-sprite particle fields that differ only in their MOTION model (motes:
+ * outward drift + buoyancy + curl, with motion-blur streaks; droplets: a
+ * ballistic arc under gravity) and their styling. The cross-pollination plan
+ * asks for one parametric particle module behind a shared include + params.
+ *
+ * Here we extract the parts that were duplicated verbatim between the two: the
+ * per-particle soft round sprite (`particleSprite`), the ballistic position
+ * (`ballisticPos`), and the standard fade-in/out over a particle's life
+ * (`particleFade`). Each effect keeps its own emit shape + motion (the part that
+ * is its identity) and composes these shared primitives, so the dot falloff,
+ * the gravity arc and the lifetime curve no longer drift between effects.
+ *
+ * Comic debris can adopt the same primitives later (deferred — noted in the
+ * plan as P2). Requires no other chunk.
+ */
+export declare const GLSL_PARTICLES = "\n// Soft round particle sprite: an inverse-distance dot that, squared, gives the\n// glowing-photon falloff both motes and droplets use. `d` is distance to the\n// particle centre, `size` its radius in device px.\nfloat particleSprite(float d, float size){\n  float s = size / (d + size * 0.5);\n  return s * s;\n}\n\n// Ballistic arc: launch from `origin` along `dir` at `speed`, pulled down by\n// `gravity` (device px) over normalized particle life `t` (0..1). Screen y is\n// up, so gravity subtracts on y. Used by Verdict's flung ink droplets and any\n// effect that wants sparks thrown off an impact.\nvec2 ballisticPos(vec2 origin, vec2 dir, float speed, float gravity, float t){\n  return origin + dir * speed * t - vec2(0.0, 1.0) * gravity * t * t;\n}\n\n// Standard particle fade: ramps in fast then fades out across its life. `t` is\n// normalized particle life (0..1); `tailPow` shapes the decay (higher = longer\n// luminous body before it dims).\nfloat particleFade(float t, float tailPow){\n  return (1.0 - pow(t, tailPow)) * smoothstep(0.0, 0.08, t);\n}\n";
+//# sourceMappingURL=particles.glsl.d.ts.map

package/dist/engine/look/particles.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"particles.glsl.d.ts","sourceRoot":"","sources":["../../../src/engine/look/particles.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,eAAO,MAAM,cAAc,qjCAuB1B,CAAC"}