react-native-webrtc-kaleidoscope 2.0.0 → 2.1.0

package/dist/web-driver/shaders.generated.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shaders.generated.js","sourceRoot":"","sources":["../../web-driver/shaders.generated.ts"],"names":[],"mappings":";AAAA,qEAAqE;AACrE,6CAA6C;;;AAEhC,QAAA,oBAAoB,GAAG;;;;;;;;CAQnC,CAAC;AAEW,QAAA,yBAAyB,GAAG;;;;;;;;CAQxC,CAAC;AAEW,QAAA,uBAAuB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;CAwBtC,CAAC;AAEW,QAAA,wBAAwB,GAAG;;;;;;;;;;;CAWvC,CAAC;AAEW,QAAA,0BAA0B,GAAG;;;;;;;;;;;;;;;;;CAiBzC,CAAC;AAEW,QAAA,yBAAyB,GAAG;;;;;;;;;;;;;;;;;CAiBxC,CAAC;AAEW,QAAA,eAAe,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkC9B,CAAC;AAEW,QAAA,eAAe,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuG9B,CAAC;AAEW,QAAA,eAAe,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiI9B,CAAC;AAEW,QAAA,gBAAgB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyE/B,CAAC;AAEW,QAAA,kBAAkB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoDjC,CAAC;AAEW,QAAA,qBAAqB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiIpC,CAAC;AAEW,QAAA,6BAA6B,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4G5C,CAAC;AAEW,QAAA,8BAA8B,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2O7C,CAAC;AAEW,QAAA,wBAAwB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsMvC,CAAC;AAEF,+EAA+E;AAC/E,uEAAuE;AAC1D,QAAA,cAAc,GAAqC;IAC9D,QAAQ,EAAE,QAAA,eAAe;IACzB,QAAQ,EAAE,QAAA,eAAe;IACzB,QAAQ,EAAE,QAAA,eAAe;IACzB,SAAS,EAAE,QAAA,gBAAgB;IAC3B,WAAW,EAAE,QAAA,kBAAkB;IAC/B,cAAc,EAAE,QAAA,qBAAqB;IACrC,sBAAsB,EAAE,QAAA,6BAA6B;IACrD,uBAAuB,EAAE,QAAA,8BAA8B;IACvD,iBAAiB,EAAE,QAAA,wBAAwB;CACnC,CAAC","sourcesContent":["// @generated by scripts/build-shaders.ts from shaders/. DO NOT EDIT.\n// Run `bun run build:shaders` to regenerate.\n\nexport const PASSTHROUGH_VERT_SRC = `#version 300 es\nprecision highp float;\nout highp vec2 vUv;\nvoid main() {\n  vec2 p = vec2(float((gl_VertexID & 1) << 1), float(gl_VertexID & 2));\n  vUv = p * 0.5;\n  gl_Position = vec4(p - 1.0, 0.0, 1.0);\n}\n`;\n\nexport const COMPOSITE_CAMERA_FRAG_SRC = `#version 300 es\nprecision highp float;\nuniform sampler2D uCamera;\nin highp vec2 vUv;\nout vec4 oColor;\nvoid main() {\n  oColor = vec4(texture(uCamera, vUv).rgb, 1.0);\n}\n`;\n\nexport const COMPOSITE_BLUR_FRAG_SRC = `#version 300 es\nprecision highp float;\nuniform sampler2D uTex;\nuniform vec2 uDir;\nuniform float uSigma;\nin highp vec2 vUv;\nout vec4 oColor;\nvoid main() {\n  float s2 = 2.0 * uSigma * uSigma;\n  float w[7];\n  float sum = 0.0;\n  for (int i = 0; i < 7; i++) {\n    w[i] = exp(-(float(i) * float(i)) / s2);\n    sum += (i == 0) ? w[i] : 2.0 * w[i];\n  }\n  float spread = uSigma * 0.25;\n  vec4 acc = texture(uTex, vUv) * (w[0] / sum);\n  for (int i = 1; i < 7; i++) {\n    vec2 off = uDir * float(i) * spread;\n    acc += texture(uTex, vUv + off) * (w[i] / sum);\n    acc += texture(uTex, vUv - off) * (w[i] / sum);\n  }\n  oColor = acc;\n}\n`;\n\nexport const COMPOSITE_IMAGE_FRAG_SRC = `#version 300 es\nprecision highp float;\nuniform sampler2D uTex;\nuniform vec2 uCoverScale;\nin highp vec2 vUv;\nout vec4 oColor;\nvoid main() {\n  vec2 uv = (vUv - 0.5) * uCoverScale + 0.5;\n  vec4 c = texture(uTex, uv);\n  oColor = vec4(c.rgb * c.a, c.a);\n}\n`;\n\nexport const COMPOSITE_SUBJECT_FRAG_SRC = `#version 300 es\nprecision highp float;\nuniform sampler2D uCamera;\nuniform sampler2D uMask;\nuniform vec2 uMaskUvScale;\nuniform vec2 uMaskUvOffset;\nuniform float uMaskLo;\nuniform float uMaskHi;\nin highp vec2 vUv;\nout vec4 oColor;\nvoid main() {\n  vec3 cam = texture(uCamera, vUv).rgb;\n  float raw = texture(uMask, vUv * uMaskUvScale + uMaskUvOffset).r;\n  float safeHi = max(uMaskHi, uMaskLo + 0.001);\n  float a = clamp(smoothstep(uMaskLo, safeHi, raw), 0.0, 1.0);\n  oColor = vec4(cam * a, a);\n}\n`;\n\nexport const COMPOSITE_MASKED_FRAG_SRC = `#version 300 es\nprecision highp float;\nuniform sampler2D uTex;\nuniform sampler2D uMask;\nuniform vec2 uMaskUvScale;\nuniform vec2 uMaskUvOffset;\nuniform float uMaskLo;\nuniform float uMaskHi;\nin highp vec2 vUv;\nout vec4 oColor;\nvoid main() {\n  vec4 c = texture(uTex, vUv);\n  float raw = texture(uMask, vUv * uMaskUvScale + uMaskUvOffset).r;\n  float safeHi = max(uMaskHi, uMaskLo + 0.001);\n  float a = clamp(smoothstep(uMaskLo, safeHi, raw), 0.0, 1.0);\n  oColor = c * a;\n}\n`;\n\nexport const PLASMA_FRAG_SRC = `#version 300 es\nprecision highp float;\n\nuniform float uTime;       // seconds, monotonically increasing; range [0, inf)\nuniform vec2 uResolution;  // framebuffer size in pixels; both components > 0\nuniform vec3 uColorA;      // first palette color, linear-ish RGB in [0, 1]\nuniform vec3 uColorB;      // second palette color, linear-ish RGB in [0, 1]\nuniform float uSpeed;      // animation rate multiplier; 0 freezes the field\nuniform float uScale;      // spatial frequency; higher = more, tighter cells\n\nin highp vec2 vUv;\nout vec4 oColor;\n\nvoid main() {\n  // Aspect-correct, screen-centered coordinates (matches nebula.frag): divide\n  // by the height so uScale reads the same regardless of aspect ratio.\n  vec2 fragCoord = vUv * uResolution;\n  vec2 uv = (fragCoord - 0.5 * uResolution) / uResolution.y;\n\n  float t = uTime * uSpeed;\n\n  // Classic demoscene plasma: a few sines of position and time. The radial\n  // term (length(uv)) gives the field an organic, non-grid-aligned drift.\n  float v = sin(uv.x * uScale + t);\n  v += sin(uv.y * uScale + t * 0.8);\n  v += sin((uv.x + uv.y) * uScale * 0.7 + t * 1.3);\n  v += sin(length(uv) * uScale * 1.2 - t);\n\n  // v ranges roughly [-4, 4]; fold through sin to a smooth [0, 1] mix factor.\n  float mixT = 0.5 + 0.5 * sin(v);\n\n  // Opaque procedural background; the person is composited over it downstream.\n  oColor = vec4(mix(uColorA, uColorB, mixT), 1.0);\n}\n`;\n\nexport const CLOUDS_FRAG_SRC = `#version 300 es\nprecision highp float;\n\nuniform float uTime;\nuniform vec2 uResolution;\nuniform vec3 uSkyLowColor;\nuniform vec3 uSkyHighColor;\nuniform vec3 uCloudLightColor;\nuniform vec3 uCloudDarkColor;\nuniform float uExposure;\nuniform float uStepSize;\nuniform float uCloudSpeed;\nuniform float uCloudScale;\nuniform float uDensity;\nuniform float uCoverage;\nuniform float uSoftness;\n\nin highp vec2 vUv;\nout vec4 oColor;\n\n// STEPS must stay a compile-time constant (GLSL ES loop bound).\n#define STEPS 48\n\nfloat hash(vec3 p) {\n    p = fract(p * 0.3183099 + 0.1);\n    p *= 17.0;\n    return fract(p.x * p.y * p.z * (p.x + p.y + p.z));\n}\n\nfloat rand(vec2 p) {\n    return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453123);\n}\n\nfloat noise(vec3 p) {\n    vec3 i = floor(p);\n    vec3 f = fract(p);\n    f = f * f * (3.0 - 2.0 * f);\n    return mix(\n        mix(\n            mix(hash(i + vec3(0,0,0)), hash(i + vec3(1,0,0)), f.x),\n            mix(hash(i + vec3(0,1,0)), hash(i + vec3(1,1,0)), f.x),\n            f.y),\n        mix(\n            mix(hash(i + vec3(0,0,1)), hash(i + vec3(1,0,1)), f.x),\n            mix(hash(i + vec3(0,1,1)), hash(i + vec3(1,1,1)), f.x),\n            f.y),\n        f.z);\n}\n\nfloat fbm(vec3 p) {\n    float v = 0.0;\n    float a = 0.5;\n    for (int i = 0; i < 5; i++) {\n        v += a * noise(p);\n        p *= 2.03;\n        a *= 0.5;\n    }\n    return v;\n}\n\nfloat cloudDensity(vec3 p) {\n    p += vec3(uTime * uCloudSpeed, 0.0, uTime * uCloudSpeed * 0.35);\n    // Outside the slab the height mask is 0, so the sample is 0; bail before fbm.\n    if (p.y <= 0.0 || p.y >= 3.0) return 0.0;\n    float n = fbm(p * uCloudScale);\n    float bottom = smoothstep(0.0, 0.7, p.y);\n    float top = smoothstep(3.0, 1.2, p.y);\n    float heightMask = bottom * top;\n    float cloud = smoothstep(uCoverage, uCoverage + uSoftness, n);\n    return cloud * heightMask;\n}\n\nvoid main() {\n    vec2 fragCoord = vUv * uResolution;\n    vec2 uv = (fragCoord - 0.5 * uResolution) / uResolution.y;\n    vec3 ro = vec3(0.0, 1.2, -4.0);\n    vec3 rd = normalize(vec3(uv, 1.5));\n    float skyGradient = clamp(rd.y * 0.5 + 0.5, 0.0, 1.0);\n    vec3 skyColor = mix(uSkyLowColor, uSkyHighColor, skyGradient);\n    vec3 accum = vec3(0.0);\n    float alpha = 0.0;\n    float t = rand(fragCoord) * uStepSize;\n    for (int i = 0; i < STEPS; i++) {\n        vec3 p = ro + rd * t;\n        // The slab is crossed monotonically in t; once past it, all samples are 0.\n        if (rd.y > 0.0 && p.y >= 3.0) break;\n        if (rd.y < 0.0 && p.y <= 0.0) break;\n        float d = cloudDensity(p);\n        if (d > 0.01) {\n            float light = smoothstep(0.4, 2.8, p.y);\n            vec3 sampleColor = mix(uCloudDarkColor, uCloudLightColor, light);\n            float a = d * uDensity;\n            accum += (1.0 - alpha) * sampleColor * a;\n            alpha += (1.0 - alpha) * a;\n        }\n        t += uStepSize;\n        if (alpha > 0.95) break;\n    }\n    vec3 color = mix(skyColor, accum, alpha);\n    color *= uExposure;\n    color = pow(color, vec3(0.9));\n    oColor = vec4(color, 1.0);\n}\n`;\n\nexport const NEBULA_FRAG_SRC = `#version 300 es\nprecision highp float;\n\nuniform float uTime;          // seconds, monotonically increasing; range [0, inf)\nuniform vec2 uResolution;     // framebuffer size in pixels; both components > 0\nuniform vec3 uColor;          // overall tint / color grade; [1,1,1] = untinted\nuniform float uBrightness;    // final glow multiplier; 1.0 = stock\nuniform float uSpeed;         // drift + rotation rate; 1.0 = stock, 0 freezes\nuniform float uTwinkleSpeed;  // star color-cycle rate; 1.0 = stock\nuniform float uScale;         // starfield zoom / density; >1 = more, smaller stars\nuniform float uStarGlow;      // star-core size; 1.0 = stock\n\nin highp vec2 vUv;\nout vec4 oColor;\n\nconst float PI = 3.14159265;\nconst float MIN_DIVIDE = 64.0;\nconst float MAX_DIVIDE = 0.01;\n// Number of stacked starfield layers. Compile-time constant so the layer\n// loop has a fixed integer bound (cross-compile-safe; no float loop counter).\nconst int STARFIELD_LAYERS_COUNT = 12;\n\nmat2 Rotate(float angle) {\n  float s = sin(angle);\n  float c = cos(angle);\n  return mat2(c, -s, s, c);\n}\n\nfloat Star(vec2 uv, float flaresize, float rotAngle, float randomN) {\n  float d = length(uv);\n  // Star core. Guard the division: length(uv) can be exactly 0 at a cell\n  // center, which yields inf/NaN under Metal. max(d, 1e-4) caps the core\n  // brightness without visibly changing the look (the concentric\n  // smoothstep fade below already clamps it).\n  float starcore = 0.05 * uStarGlow / max(d, 1e-4);\n  uv *= Rotate(-2.0 * PI * rotAngle);\n  float flareMax = 1.0;\n\n  // flares\n  float starflares = max(0.0, flareMax - abs(uv.x * uv.y * 3000.0));\n  starcore += starflares * flaresize;\n  uv *= Rotate(PI * 0.25);\n  starflares = max(0.0, flareMax - abs(uv.x * uv.y * 3000.0));\n  starcore += starflares * 0.3 * flaresize;\n  // light can't go forever, fade it concentrically.\n  starcore *= smoothstep(1.0, 0.05, d);\n  return starcore;\n}\n\nfloat PseudoRandomizer(vec2 p) {\n  // not really random, but it looks random.\n  p = fract(p * vec2(123.45, 345.67));\n  p += dot(p, p + 45.32);\n  return fract(p.x * p.y);\n}\n\nvec3 StarFieldLayer(vec2 uv, float rotAngle) {\n  vec3 col = vec3(0.0);\n\n  vec2 gv = fract(uv) - 0.5;\n  vec2 id = floor(uv);\n\n  float deltaTimeTwinkle = uTime * 0.35 * uTwinkleSpeed;\n\n  // sweep the 8 neighbors plus the home cell so stars are not clipped at\n  // cell borders. Constant 3x3 bounds.\n  for (int y = -1; y <= 1; y++) {\n    for (int x = -1; x <= 1; x++) {\n      vec2 offset = vec2(float(x), float(y));\n\n      float randomN = PseudoRandomizer(id + offset); // 0..1\n      float randoX = randomN - 0.5;\n      float randoY = fract(randomN * 45.0) - 0.5;\n      vec2 randomPosition = gv - offset - vec2(randoX, randoY);\n      // fract trick: random sizes\n      float size = fract(randomN * 1356.33);\n      float flareSwitch = smoothstep(0.9, 1.0, size);\n      float star = Star(randomPosition, flareSwitch, rotAngle, randomN);\n\n      // fract trick: random colors\n      float randomStarColorSeed = fract(randomN * 2150.0) * (3.0 * PI) * deltaTimeTwinkle;\n      vec3 color = sin(vec3(0.7, 0.3, 0.9) * randomStarColorSeed);\n\n      // compress\n      color = color * (0.4 * sin(deltaTimeTwinkle)) + 0.6;\n      // filter\n      color = color * vec3(1.0, 0.1, 0.9 + size);\n      float dimByDensity = 15.0 / float(STARFIELD_LAYERS_COUNT);\n      col += star * size * color * dimByDensity;\n    }\n  }\n\n  return col;\n}\n\nvoid main() {\n  // ShaderToy fragCoord, reconstructed from vUv (see header).\n  vec2 fragCoord = vUv * uResolution;\n\n  // Normalized pixel coordinates centered at screen middle.\n  vec2 uv = (fragCoord - 0.5 * uResolution.xy) / uResolution.y;\n\n  float deltaTime = uTime * 0.01 * uSpeed;\n\n  vec3 col = vec3(0.0);\n\n  float rotAngle = deltaTime * 0.09;\n\n  // Layer accumulation. Integer-counted loop replacing the original\n  // \\`for (float i = 0.0; i < 1.0; i += 1.0/COUNT)\\`. With n in [0, COUNT),\n  // i = n/COUNT reproduces the exact same {0, 1/N, 2/N, ...} sequence and\n  // the same iteration count, so visual output is unchanged; only the loop\n  // form is cross-compile-safe.\n  for (int n = 0; n < STARFIELD_LAYERS_COUNT; n++) {\n    float i = float(n) / float(STARFIELD_LAYERS_COUNT);\n    float layerDepth = fract(i + deltaTime);\n    float layerScale = mix(MIN_DIVIDE, MAX_DIVIDE, layerDepth);\n    float layerFader = layerDepth * smoothstep(0.1, 1.1, layerDepth);\n    float layerOffset = i * (3430.0 + fract(i));\n    mat2 layerRot = Rotate(rotAngle * i * -10.0);\n    uv *= layerRot;\n    vec2 starfieldUv = uv * layerScale * uScale + layerOffset;\n    col += StarFieldLayer(starfieldUv, rotAngle) * layerFader;\n  }\n\n  // Glow + color grade, then opaque procedural background.\n  col *= uBrightness * uColor;\n  oColor = vec4(col, 1.0);\n}\n`;\n\nexport const GODRAYS_FRAG_SRC = `#version 300 es\nprecision highp float;\n\nuniform float uTime;          // seconds, monotonically increasing\nuniform vec2 uResolution;     // framebuffer size in pixels\nuniform vec3 uLightColor;     // ray tint (linear-ish RGB, 0..1)\nuniform float uRayCount;      // number of ray bands\nuniform float uRaySpeed;      // drift speed\nuniform float uRayIntensity;  // overall brightness / additive strength\nuniform float uRaySoftness;   // edge falloff exponent (higher = crisper shafts)\nuniform float uTopGlow;       // extra glow concentrated near the top\nuniform float uFadeDistance;  // vertical falloff from the top\nuniform float uWobbleAmount;  // horizontal wobble magnitude\nuniform float uWobbleSpeed;   // wobble animation speed\n\nin highp vec2 vUv;\nout vec4 oColor;\n\nfloat hash(float n) {\n    return fract(sin(n) * 43758.5453123);\n}\n\nfloat noise(vec2 p) {\n    vec2 i = floor(p);\n    vec2 f = fract(p);\n\n    f = f * f * (3.0 - 2.0 * f);\n\n    float a = hash(i.x + i.y * 57.0);\n    float b = hash(i.x + 1.0 + i.y * 57.0);\n    float c = hash(i.x + (i.y + 1.0) * 57.0);\n    float d = hash(i.x + 1.0 + (i.y + 1.0) * 57.0);\n\n    return mix(mix(a, b, f.x), mix(c, d, f.x), f.y);\n}\n\nvoid main() {\n    // vUv is already 0..1 with bottom-left origin; this is the Shadertoy \\`uv\\`.\n    vec2 uv = vUv;\n\n    float aspect = uResolution.x / uResolution.y;\n    vec2 p = uv;\n    p.x = (p.x - 0.5) * aspect + 0.5;\n\n    float t = uTime;\n    float fromTop = 1.0 - uv.y;\n\n    float verticalFade = exp(-fromTop * uFadeDistance);\n    float topGlow = exp(-fromTop * 8.0) * uTopGlow;\n\n    float wobble =\n        (noise(vec2(uv.y * 3.0, t * uWobbleSpeed)) - 0.5) * uWobbleAmount;\n\n    float rayCoord = (p.x + wobble) * uRayCount;\n\n    float raysA = sin(rayCoord + t * uRaySpeed);\n    float raysB = sin(rayCoord * 1.73 - t * uRaySpeed * 0.7);\n\n    float rays = raysA * 0.65 + raysB * 0.35;\n    rays = rays * 0.5 + 0.5;\n    rays = pow(rays, uRaySoftness);\n\n    float shimmer = noise(vec2(uv.x * 10.0, uv.y * 4.0 - t * 0.3));\n    rays *= mix(0.75, 1.25, shimmer);\n\n    float alpha = rays * verticalFade * uRayIntensity;\n    alpha += topGlow * uRayIntensity;\n    alpha = clamp(alpha, 0.0, 1.0);\n\n    // Premultiplied additive output: rgb already scaled by alpha.\n    vec3 rayColor = uLightColor * alpha;\n    oColor = vec4(rayColor, alpha);\n}\n`;\n\nexport const FIREFLIES_FRAG_SRC = `#version 300 es\nprecision highp float;\n\nuniform float uTime;\nuniform vec2 uResolution;\nuniform float uGlowSize;\nuniform float uDotSize;\nuniform float uSpeed;\nuniform float uTwinkle;\nuniform vec3 uColor;\n\nin highp vec2 vUv;\nout vec4 oColor;\n\n#define FIREFLY_COUNT 36\n\nfloat hash(float n) {\n    return fract(sin(n) * 43758.5453123);\n}\n\nvec2 fireflyPos(float id, float t) {\n    vec2 base = vec2(hash(id * 12.7), hash(id * 31.3));\n    float a = hash(id * 5.1) * 6.28318;\n    float b = hash(id * 9.7) * 6.28318;\n    vec2 drift = vec2(sin(t * uSpeed + a), cos(t * uSpeed * 0.73 + b)) * 0.12;\n    return fract(base + drift);\n}\n\nvoid main() {\n    vec2 uv = vUv;\n    vec2 p = uv;\n    p.x *= uResolution.x / uResolution.y;\n    vec3 color = vec3(0.0);\n    float alpha = 0.0;\n    for (int i = 0; i < FIREFLY_COUNT; i++) {\n        float id = float(i);\n        vec2 pos = fireflyPos(id, uTime);\n        pos.x *= uResolution.x / uResolution.y;\n        float d = length(p - pos);\n        float phase = hash(id * 17.1) * 6.28318;\n        float pulse = 0.5 + 0.5 * sin(uTime * uTwinkle + phase);\n        pulse = pulse * pulse * sqrt(pulse);  // pow(pulse, 2.5): a non-integer pow is ~2 transcendentals on mobile; this is 1 sqrt + 2 muls\n        float glow = exp(-d * d / (uGlowSize * uGlowSize));\n        float core = smoothstep(uDotSize, 0.0, d);\n        float intensity = pulse * (glow * 0.55 + core * 1.4);\n        color += uColor * intensity;\n        alpha += intensity * 0.55;\n    }\n    alpha = clamp(alpha, 0.0, 1.0);\n    color = clamp(color, 0.0, 1.0);\n    oColor = vec4(color, alpha);\n}\n`;\n\nexport const SIMIANLIGHTS_FRAG_SRC = `#version 300 es\nprecision highp float;\n\nuniform float uTime;          // seconds, monotonically increasing; range [0, inf)\nuniform vec2 uResolution;     // framebuffer size in pixels; both components > 0\nuniform vec3 uColor;          // overall tint / color grade; [1,1,1] = untinted\nuniform float uBrightness;    // final glow multiplier; 1.0 = stock\nuniform float uSpeed;         // drift + rotation rate; 1.0 = stock, 0 freezes\nuniform float uTwinkleSpeed;  // star color-cycle rate; 1.0 = stock\nuniform float uScale;         // starfield zoom / density; >1 = more, smaller stars\nuniform float uStarGlow;      // star-core size; 1.0 = stock\n\nin highp vec2 vUv;\nout vec4 oColor;\n\nconst float PI = 3.14159265;\nconst float MIN_DIVIDE = 3.0;\nconst float MAX_DIVIDE = 0.01;\n// Number of stacked starfield layers. Compile-time constant so the layer\n// loop has a fixed integer bound (cross-compile-safe; no float loop counter).\nconst int STARFIELD_LAYERS_COUNT = 4;\n\nmat2 Rotate(float angle) {\n  float s = sin(angle);\n  float c = cos(angle);\n  return mat2(c, -s, s, c);\n}\n\nfloat Star(vec2 uv, float flaresize, float rotAngle, float randomN) {\n  float d = length(uv);\n  // Star core. Guard the division: length(uv) can be exactly 0 at a cell\n  // center, which yields inf/NaN under Metal. max(d, 1e-4) caps the core\n  // brightness without visibly changing the look (the concentric\n  // smoothstep fade below already clamps it).\n  float starcore = 0.09 * uStarGlow / max(d, 1e-4);\n  uv *= Rotate(-2.0 * PI * rotAngle);\n  float flareMax = 1.0;\n\n  // flares\n  float starflares = max(0.0, flareMax - abs(uv.x * uv.y * 3000.0));\n  starcore += starflares * flaresize;\n  uv *= Rotate(PI * 0.25);\n  starflares = max(0.0, flareMax - abs(uv.x * uv.y * 3000.0));\n  starcore += starflares * 0.3 * flaresize;\n  // light can't go forever, fade it concentrically.\n  starcore *= smoothstep(1.0, 0.05, d);\n  return starcore;\n}\n\nfloat PseudoRandomizer(vec2 p) {\n  // not really random, but it looks random.\n  p = fract(p * vec2(123.45, 345.67));\n  p += dot(p, p + 45.32);\n  return fract(p.x * p.y);\n}\n\nvec3 StarFieldLayer(vec2 uv, float rotAngle) {\n  vec3 col = vec3(0.0);\n\n  vec2 gv = fract(uv) - 0.5;\n  vec2 id = floor(uv);\n\n  float deltaTimeTwinkle = uTime * 0.35 * uTwinkleSpeed;\n\n  // sweep the 8 neighbors plus the home cell so stars are not clipped at\n  // cell borders. Constant 3x3 bounds.\n  for (int y = -1; y <= 1; y++) {\n    for (int x = -1; x <= 1; x++) {\n      vec2 offset = vec2(float(x), float(y));\n\n      float randomN = PseudoRandomizer(id + offset); // 0..1\n      float randoX = randomN - 0.5;\n      float randoY = fract(randomN * 45.0) - 0.5;\n      vec2 randomPosition = gv - offset - vec2(randoX, randoY);\n      // fract trick: random sizes\n      float size = fract(randomN * 1356.33);\n      float flareSwitch = smoothstep(0.9, 1.0, size);\n      float star = Star(randomPosition, flareSwitch, rotAngle, randomN);\n\n      // fract trick: random colors\n      float randomStarColorSeed = fract(randomN * 2150.0) * (3.0 * PI) * deltaTimeTwinkle;\n      vec3 color = sin(vec3(0.7, 0.3, 0.9) * randomStarColorSeed);\n\n      // compress\n      color = color * (0.4 * sin(deltaTimeTwinkle)) + 0.6;\n      // filter\n      color = color * vec3(1.0, 0.1, 0.9 + size);\n      float dimByDensity = 15.0 / float(STARFIELD_LAYERS_COUNT);\n      col += star * size * color * dimByDensity;\n    }\n  }\n\n  return col;\n}\n\nvoid main() {\n  // ShaderToy fragCoord, reconstructed from vUv (see header).\n  vec2 fragCoord = vUv * uResolution;\n\n  // Normalized pixel coordinates centered at screen middle.\n  vec2 uv = (fragCoord - 0.5 * uResolution.xy) / uResolution.y;\n\n  float deltaTime = uTime * 0.01 * uSpeed;\n\n  vec3 col = vec3(0.0);\n\n  float rotAngle = deltaTime * 0.09;\n\n  // Layer accumulation. Integer-counted loop replacing the original\n  // \\`for (float i = 0.0; i < 1.0; i += 1.0/COUNT)\\`. With n in [0, COUNT),\n  // i = n/COUNT reproduces the exact same {0, 1/N, 2/N, ...} sequence and\n  // the same iteration count, so visual output is unchanged; only the loop\n  // form is cross-compile-safe.\n  for (int n = 0; n < STARFIELD_LAYERS_COUNT; n++) {\n    float i = float(n) / float(STARFIELD_LAYERS_COUNT);\n    float layerDepth = fract(i + deltaTime);\n    float layerScale = mix(MIN_DIVIDE, MAX_DIVIDE, layerDepth);\n    float layerFader = layerDepth * smoothstep(0.1, 1.1, layerDepth);\n    float layerOffset = i * (3430.0 + fract(i));\n    mat2 layerRot = Rotate(rotAngle * i * -10.0);\n    uv *= layerRot;\n    vec2 starfieldUv = uv * layerScale * uScale + layerOffset;\n    col += StarFieldLayer(starfieldUv, rotAngle) * layerFader;\n  }\n\n  // Glow + color grade, then opaque procedural background.\n  col *= uBrightness * uColor;\n  oColor = vec4(col, 1.0);\n}\n`;\n\nexport const ANAMORPHIC_LENSFLARE_FRAG_SRC = `#version 300 es\nprecision highp float;\n\nuniform float uTime;          // seconds, monotonically increasing; range [0, inf)\nuniform float uFlareX;        // flare X position, 0..1 (drifts slowly around this)\nuniform float uFlareY;        // flare Y position, 0..1 (0 = bottom)\nuniform float uIntensity;     // overall brightness multiplier\nuniform float uStreakLength;  // horizontal streak reach; higher = longer\nuniform float uStreakWidth;   // main streak vertical tightness; higher = thinner\nuniform float uGhostStrength; // optical-ghost strength along the flare axis\nuniform vec3 uWarmColor;      // core / warm streak tint\nuniform vec3 uBlueColor;      // halo / wide-streak tint\nuniform vec3 uPinkColor;      // secondary streak / ghost tint\n\nin highp vec2 vUv;\nout vec4 oColor;\n\nfloat softOrb(vec2 uv, vec2 center, float radius) {\n  float d = length(uv - center);\n  float q = d / radius;  // pow(q, 2.0) -> q*q; spirv-opt does not strength-reduce it\n  return exp(-q * q);\n}\n\nfloat softStreak(vec2 uv, vec2 center, float width, float length) {\n  float yFalloff = exp(-abs(uv.y - center.y) * width);\n  float xFalloff = exp(-abs(uv.x - center.x) * length);\n  return yFalloff * xFalloff;\n}\n\nvoid main() {\n  // ShaderToy uv = fragCoord / iResolution; identical to vUv here.\n  vec2 uv = vUv;\n\n  // Slow horizontal drift.\n  float horizontalDrift = sin(uTime * 0.18) * 0.10;\n  vec2 flarePos = vec2(uFlareX + horizontalDrift, uFlareY);\n\n  vec3 col = vec3(0.0);\n  float alpha = 0.0;\n\n  // Main source.\n  float core = softOrb(uv, flarePos, 0.022);\n  float bloom = softOrb(uv, flarePos, 0.095);\n  float outerHalo = softOrb(uv, flarePos, 0.28);\n\n  col += vec3(1.0) * core * 1.8;\n  col += uWarmColor * bloom * 0.95;\n  col += uBlueColor * outerHalo * 0.16;\n\n  alpha += core * 0.45;\n  alpha += bloom * 0.22;\n  alpha += outerHalo * 0.045;\n\n  // Moving streak intensity.\n  float sweepGlow = 0.85 + 0.15 * sin(uTime * 0.7 + uv.x * 8.0);\n\n  // Main + wide anamorphic streaks.\n  float mainStreak = softStreak(uv, flarePos, uStreakWidth, uStreakLength);\n  float wideStreak = softStreak(uv, flarePos, 70.0, uStreakLength * 0.65);\n\n  col += uWarmColor * mainStreak * 1.15 * sweepGlow;\n  col += uBlueColor * wideStreak * 0.26 * sweepGlow;\n\n  alpha += mainStreak * 0.18;\n  alpha += wideStreak * 0.055;\n\n  // Secondary colored streaks.\n  float upperLine = softStreak(uv, flarePos + vec2(0.0, 0.012), 260.0, uStreakLength * 0.7);\n  float lowerLine = softStreak(uv, flarePos - vec2(0.0, 0.010), 240.0, uStreakLength * 0.8);\n\n  col += uBlueColor * upperLine * 0.22;\n  col += uPinkColor * lowerLine * 0.16;\n\n  alpha += (upperLine + lowerLine) * 0.035;\n\n  // Optical ghosts along the line from the flare through screen center.\n  vec2 center = vec2(0.5);\n  vec2 axis = center - flarePos;\n\n  vec2 ghost1 = flarePos + axis * 0.45;\n  vec2 ghost2 = flarePos + axis * 0.85;\n  vec2 ghost3 = flarePos + axis * 1.28;\n  vec2 ghost4 = flarePos - axis * 0.35;\n\n  float g1 = softOrb(uv, ghost1, 0.070);\n  float g2 = softOrb(uv, ghost2, 0.115);\n  float g3 = softOrb(uv, ghost3, 0.055);\n  float g4 = softOrb(uv, ghost4, 0.095);\n\n  col += uPinkColor * g1 * 0.18 * uGhostStrength;\n  col += uBlueColor * g2 * 0.15 * uGhostStrength;\n  col += uWarmColor * g3 * 0.22 * uGhostStrength;\n  col += uBlueColor * g4 * 0.10 * uGhostStrength;\n\n  alpha += g1 * 0.040 * uGhostStrength;\n  alpha += g2 * 0.035 * uGhostStrength;\n  alpha += g3 * 0.050 * uGhostStrength;\n  alpha += g4 * 0.030 * uGhostStrength;\n\n  // Tiny shimmer to keep it alive.\n  float shimmer = 0.97 + 0.03 * sin(uTime * 2.1);\n\n  col *= uIntensity * shimmer;\n  alpha *= uIntensity * shimmer;\n\n  alpha = clamp(alpha, 0.0, 1.0);\n  oColor = vec4(col, alpha);\n}\n`;\n\nexport const LIGHT_BEAMS_AND_MOTES_FRAG_SRC = `#version 300 es\nprecision highp float;\n\nuniform float uTime;          // seconds, monotonically increasing; range [0, inf)\nuniform float uSpeed;         // animation rate; 1.0 = stock, 0 freezes the field\nuniform float uBeamSoftness;  // beam polygon edge softness\nuniform float uOverlayAlpha;  // overall overlay opacity, applied to final alpha\n\n// Per-beam: a row-major quad (TL, TR, BL, BR; y-up), a color, a fill strength\n// (absolute), and an on/off flag. A disabled beam's quadMask + sins do not execute\n// at all (the flag is uniform, so the branch is coherent across every fragment) --\n// that is how you stop paying for beams you are not using.\nuniform vec2 uBeam1Poly[4];\nuniform vec3 uBeam1Color;\nuniform float uBeam1Alpha;\nuniform float uBeam1On;\nuniform vec2 uBeam2Poly[4];\nuniform vec3 uBeam2Color;\nuniform float uBeam2Alpha;\nuniform float uBeam2On;\nuniform vec2 uBeam3Poly[4];\nuniform vec3 uBeam3Color;\nuniform float uBeam3Alpha;\nuniform float uBeam3On;\n\nuniform float uMoteAlpha;     // mote brightness (absolute)\nuniform float uGlowSize;      // mote glow radius, in mote-size multiples\nuniform float uMoteCount;     // active motes (<= MOTE_COUNT); a coherent break trims the loop\n\nin highp vec2 vUv;\nout vec4 oColor;\n\n// ---------- Mote controls (internal constants) ----------\n#define MOTE_COUNT        128   // loop bound: compile-time constant, not a uniform\n#define DRIFT_SPEED       0.060\n#define FALL_SPEED        0.012\n#define SWIRL_AMOUNT      0.065\n#define TURBULENCE        0.030\n#define MOTE_SIZE_MIN     0.0013\n#define MOTE_SIZE_MAX     0.0048\n\nfloat hash1(float n) {\n    return fract(sin(n) * 43758.5453123);\n}\n\nvec2 hash2(float n) {\n    return vec2(hash1(n + 11.17), hash1(n + 47.83));\n}\n\nfloat softMote(vec2 uv, vec2 center, float radius) {\n    float d = length(uv - center);\n    float q = d / radius;  // pow(q, 2.0) -> q*q; spirv-opt does not strength-reduce it\n    return exp(-q * q);\n}\n\n// Soft convex quad mask, winding-AGNOSTIC: the corners are user-draggable, so the\n// perimeter can wind either way. A point is inside when it is on the same side of\n// all four edges, whichever side that is; product the positive-side smoothsteps and\n// the negative-side ones and keep the larger.\nfloat quadMask(vec2 p, vec2 a, vec2 b, vec2 c, vec2 d, float softness) {\n    vec2 e0 = b - a;\n    vec2 e1 = c - b;\n    vec2 e2 = d - c;\n    vec2 e3 = a - d;\n    float s0 = e0.x * (p.y - a.y) - e0.y * (p.x - a.x);\n    float s1 = e1.x * (p.y - b.y) - e1.y * (p.x - b.x);\n    float s2 = e2.x * (p.y - c.y) - e2.y * (p.x - c.x);\n    float s3 = e3.x * (p.y - d.y) - e3.y * (p.x - d.x);\n    float inNeg =\n        smoothstep(-softness, softness, -s0) *\n        smoothstep(-softness, softness, -s1) *\n        smoothstep(-softness, softness, -s2) *\n        smoothstep(-softness, softness, -s3);\n    float inPos =\n        smoothstep(-softness, softness, s0) *\n        smoothstep(-softness, softness, s1) *\n        smoothstep(-softness, softness, s2) *\n        smoothstep(-softness, softness, s3);\n    return max(inNeg, inPos);\n}\n\n// Subtle animated variation inside each beam.\nfloat beamTexture(vec2 uv, float seed) {\n    float t = uTime * uSpeed;\n    float broadBands = 0.55 + 0.45 * sin(uv.x * 7.0 + uv.y * 4.0 + t * 0.06 + seed);\n    float fineBands = 0.75 + 0.25 * sin(uv.x * 23.0 - uv.y * 11.0 + t * 0.11 + seed * 2.7);\n    return mix(0.65, 1.0, broadBands * fineBands);\n}\n\n// Geometric coverage of one row-major beam quad at uv (mask * texture, 0..~1), with\n// the row-major -> perimeter reorder folded in. Independent of the beam's alpha.\nfloat beamShape(vec2 uv, vec2 poly[4], float seed) {\n    return quadMask(uv, poly[0], poly[1], poly[3], poly[2], uBeamSoftness) * beamTexture(uv, seed);\n}\n\n// Evaluate the three beams once. Returns the GEOMETRIC coverage sum (used to gate +\n// brighten motes and to drive the haze, so per-beam alpha never dims the motes);\n// writes \\`color\\` (the geometry-weighted beam hue, for fill and motes) and \\`litSum\\`\n// (the alpha-weighted amount, the actual fill brightness/opacity).\nfloat evalBeams(vec2 uv, out vec3 color, out float litSum) {\n    float a1 = 0.0;\n    float a2 = 0.0;\n    float a3 = 0.0;\n    if (uBeam1On > 0.5) a1 = beamShape(uv, uBeam1Poly, 1.0);\n    if (uBeam2On > 0.5) a2 = beamShape(uv, uBeam2Poly, 8.0);\n    if (uBeam3On > 0.5) a3 = beamShape(uv, uBeam3Poly, 14.0);\n\n    float geomSum = a1 + a2 + a3;\n    color = (uBeam1Color * a1 + uBeam2Color * a2 + uBeam3Color * a3) / max(geomSum, 0.0001);\n    litSum = a1 * uBeam1Alpha + a2 * uBeam2Alpha + a3 * uBeam3Alpha;\n    return geomSum;\n}\n\n// Accumulate the dust motes for ALL on beams in ONE loop. Each mote is round-\n// robined to an on beam (mote n -> the (n mod nActive)-th on beam) and spawned in\n// THAT beam's (u,v) space: every mote lands in a beam, takes the beam's color, and\n// gets a cheap (u,v) edge falloff -- no screen-space scatter to cull, no per-mote\n// quadMask. n and nActive are uniform across fragments, so the beam pick is\n// COHERENT (same for every pixel), not a divergent per-pixel branch. Motes drift\n// ALONG the beam (fall in v, swirl in u) and wrap, fading at the boundaries so the\n// wrap is never a visible pop. Total mote count is uMoteCount regardless of how\n// many beams are on -- the on beams share the budget.\nvoid addMotes(vec2 uv, inout vec3 col, inout float alpha) {\n    float nActive = uBeam1On + uBeam2On + uBeam3On;  // on-flags are 0/1\n    if (nActive < 0.5) return;                        // no beams -> no motes\n\n    // Motes may spill past the polygon edge by ~softness so the soft fringe is\n    // populated; the (u,v) falloff dims them there.\n    float fuzz = clamp(uBeamSoftness * 2.0, 0.03, 0.35);\n    float slot = 0.0;  // round-robin cursor over the on beams (a wrapped counter, no per-mote mod)\n\n    for (int n = 0; n < MOTE_COUNT; n++) {\n        if (float(n) >= uMoteCount) break;  // runtime-tunable mote count (coherent break)\n        float seed = float(n) * 91.73;\n\n        // Round-robin: this mote goes to the slot-th on beam. Walk the beams,\n        // counting on ones; the slot-th match wins.\n        float picked = 0.0;\n        vec2 tl = vec2(0.0);\n        vec2 tr = vec2(0.0);\n        vec2 bl = vec2(0.0);\n        vec2 br = vec2(0.0);\n        vec3 color = vec3(0.0);\n        if (uBeam1On > 0.5) {\n            if (abs(picked - slot) < 0.5) {\n                tl = uBeam1Poly[0]; tr = uBeam1Poly[1]; bl = uBeam1Poly[2]; br = uBeam1Poly[3];\n                color = uBeam1Color;\n            }\n            picked += 1.0;\n        }\n        if (uBeam2On > 0.5) {\n            if (abs(picked - slot) < 0.5) {\n                tl = uBeam2Poly[0]; tr = uBeam2Poly[1]; bl = uBeam2Poly[2]; br = uBeam2Poly[3];\n                color = uBeam2Color;\n            }\n            picked += 1.0;\n        }\n        if (uBeam3On > 0.5) {\n            if (abs(picked - slot) < 0.5) {\n                tl = uBeam3Poly[0]; tr = uBeam3Poly[1]; bl = uBeam3Poly[2]; br = uBeam3Poly[3];\n                color = uBeam3Color;\n            }\n            picked += 1.0;\n        }\n\n        float depth = hash1(seed + 3.0);\n        float size = mix(MOTE_SIZE_MIN, MOTE_SIZE_MAX, depth);\n        float speed = mix(0.45, 1.35, hash1(seed + 5.0));\n        float t = uTime * uSpeed * speed;\n\n        // (u,v) in beam space; drift = swirl in u, fall in v. fract wraps within\n        // the beam, so a mote that falls out the spread end reappears at the source.\n        vec2 g = hash2(seed);\n        g.x += sin(t * DRIFT_SPEED * 1.7 + seed) * SWIRL_AMOUNT;\n        g.x += sin(t * DRIFT_SPEED * 3.9 + seed * 0.41) * TURBULENCE;\n        g.y += uTime * uSpeed * FALL_SPEED * speed * 6.0;\n        g.y += sin(t * DRIFT_SPEED * 2.4 + seed * 0.37) * SWIRL_AMOUNT * 0.55;\n        g = fract(g);\n\n        // Expand to [-fuzz, 1+fuzz] so motes populate the soft fringe, then map\n        // bilinearly onto the quad.\n        vec2 q = g * (1.0 + 2.0 * fuzz) - fuzz;\n        vec2 pos = mix(mix(tl, tr, q.x), mix(bl, br, q.x), q.y);\n\n        // Cheap soft-edge falloff in (u,v), replacing the per-mote quadMask.\n        float edge =\n            smoothstep(0.0, fuzz, q.x) * smoothstep(0.0, fuzz, 1.0 - q.x) *\n            smoothstep(0.0, fuzz, q.y) * smoothstep(0.0, fuzz, 1.0 - q.y);\n\n        float mote = softMote(uv, pos, size);\n        float core = softMote(uv, pos, size * 0.42);\n        float glow = softMote(uv, pos, size * uGlowSize);\n\n        float shimmer =\n            0.72 + 0.28 * sin(uTime * uSpeed * mix(0.22, 0.95, hash1(seed + 9.0)) + seed);\n        float strength = mix(0.15, 1.0, depth) * shimmer * edge * uMoteAlpha;\n\n        col += color * glow * strength * 0.12;\n        col += color * mote * strength * 0.36;\n        col += vec3(1.0) * core * strength * 0.10;\n\n        alpha += glow * strength * 0.030;\n        alpha += mote * strength * 0.105;\n        alpha += core * strength * 0.110;\n\n        slot += 1.0;\n        if (slot >= nActive) slot = 0.0;  // wrap the round-robin cursor\n    }\n}\n\nvoid main() {\n    // vUv is already 0..1 with bottom-left origin; this is the Shadertoy uv.\n    vec2 uv = vUv;\n\n    vec3 col = vec3(0.0);\n    float alpha = 0.0;\n\n    vec3 beamColor;\n    float litSum;\n    float cover = evalBeams(uv, beamColor, litSum);\n\n    col += beamColor * litSum;       // litSum carries each beam's per-beam alpha\n    alpha += litSum * 0.45;\n\n    // One loop; each mote is round-robined into an on beam and spawned there.\n    addMotes(uv, col, alpha);\n\n    float haze =\n        cover * cover * (0.6 + 0.4 * sin(uv.x * 8.0 + uv.y * 5.0 + uTime * uSpeed * 0.08));\n    col += beamColor * haze * 0.018;\n    alpha += haze * 0.010;\n\n    alpha = clamp(alpha * uOverlayAlpha, 0.0, 1.0);\n    oColor = vec4(col, alpha);\n}\n`;\n\nexport const CORPORATE_BLOBS_FRAG_SRC = `#version 300 es\nprecision highp float;\n\nuniform float uTime;          // seconds, monotonically increasing; range [0, inf)\nuniform vec2 uResolution;     // framebuffer size in pixels; both components > 0\nuniform vec3 uColor;          // overall tint / color grade; [1,1,1] = stock colors\nuniform float uGlobalAlpha;   // overall blob opacity; stock 0.58\nuniform float uScale;         // global blob size multiplier; stock 2.55\nuniform float uEdgePull;      // pushes blobs outward from center; stock 0.32\nuniform float uCenterClear;   // radius around center that repels blobs; stock 0.42\nuniform float uMotionAmount;  // positional drift magnitude; 1.0 = stock, 0 = still\nuniform float uMotionSpeed;   // drift + morph rate; 1.0 = stock, 0 freezes motion\nuniform float uEdgeSoftness;  // blob edge falloff; stock 0.024\n// Per-blob base colors, multiplied by uColor at output. Defaults (the stock\n// brand palette) live in CORPORATE_BLOBS_CONTROLS.\nuniform vec3 uBlobColor1;     // stock: light blue\nuniform vec3 uBlobColor2;     // stock: dark green\nuniform vec3 uBlobColor3;     // stock: yellow\nuniform vec3 uBlobColor4;     // stock: orange\nuniform vec3 uBlobColor5;     // stock: light green\nuniform vec3 uBlobColor6;     // stock: magenta\nuniform vec3 uBlobColor7;     // stock: brown\nuniform vec3 uBlobColor8;     // stock: dark blue\n\nin highp vec2 vUv;\nout vec4 oColor;\n\n// BLOB_COUNT must stay a compile-time constant (GLSL ES loop bound).\n#define BLOB_COUNT            8\n\n// Internal animation constants (not tunable; keep the look coherent).\n#define CENTER_CLEAR_PUSH     0.34\n#define SCALE_PULSE_AMOUNT    0.10\n#define SCALE_PULSE_SPEED     0.42\n#define ROTATION_SWAY_AMOUNT  0.12\n#define ROTATION_SWAY_SPEED   0.11\n#define SHAPE_MORPH_SPEED     1.00\n\nstruct Blob {\n    vec2 pos;\n    float scale;\n    float opacity;\n    float speed;\n    float drift;\n    float rotation;\n    float variant;\n    vec3 color;\n};\n\nBlob getBlob(float i) {\n    if (i < 0.5) return Blob(vec2(-1.18, -0.55), 0.62, 0.48, 0.22, 0.14, 0.10, 0.0, uBlobColor1);\n    if (i < 1.5) return Blob(vec2( 1.12, -0.35), 0.66, 0.40, 0.18, 0.13, 1.00, 1.0, uBlobColor2);\n    if (i < 2.5) return Blob(vec2( 0.95,  0.88), 0.58, 0.44, 0.20, 0.14, 2.20, 2.0, uBlobColor3);\n    if (i < 3.5) return Blob(vec2(-0.98,  0.82), 0.56, 0.38, 0.16, 0.12, 0.70, 3.0, uBlobColor4);\n    if (i < 4.5) return Blob(vec2( 1.28,  0.28), 0.50, 0.34, 0.24, 0.11, 1.80, 4.0, uBlobColor5);\n    if (i < 5.5) return Blob(vec2(-0.25, -1.12), 0.54, 0.36, 0.19, 0.11, 2.60, 5.0, uBlobColor6);\n    if (i < 6.5) return Blob(vec2(-1.30,  0.10), 0.48, 0.30, 0.17, 0.12, 0.40, 6.0, uBlobColor7);\n    return             Blob(vec2( 0.28,  1.18), 0.52, 0.30, 0.14, 0.10, 0.90, 7.0, uBlobColor8);\n}\n\nmat2 rotate2d(float a) {\n    float s = sin(a);\n    float c = cos(a);\n    return mat2(c, -s, s, c);\n}\n\nfloat variantRadius(float angle, float variant, float phase) {\n    float r = 1.0;\n\n    if (variant < 0.5) {\n        r += 0.115 * sin(angle * 2.0 + 0.20 + phase * 0.20);\n        r += 0.075 * sin(angle * 3.0 - 1.10 - phase * 0.13);\n        r += 0.035 * sin(angle * 5.0 + 2.00 + phase * 0.09);\n    } else if (variant < 1.5) {\n        r += 0.090 * sin(angle * 2.0 - 0.80 + phase * 0.18);\n        r += 0.105 * sin(angle * 3.0 + 0.70 - phase * 0.10);\n        r += 0.030 * sin(angle * 6.0 - 1.50 + phase * 0.08);\n    } else if (variant < 2.5) {\n        r += 0.130 * sin(angle * 2.0 + 1.10 + phase * 0.16);\n        r += 0.060 * sin(angle * 4.0 - 0.30 - phase * 0.12);\n        r += 0.045 * sin(angle * 5.0 + 2.80 + phase * 0.07);\n    } else if (variant < 3.5) {\n        r += 0.080 * sin(angle * 2.0 + 2.30 + phase * 0.14);\n        r += 0.120 * sin(angle * 3.0 - 0.40 - phase * 0.11);\n        r += 0.040 * sin(angle * 7.0 + 1.10 + phase * 0.06);\n    } else if (variant < 4.5) {\n        r += 0.035 * sin(angle * 2.0 + 0.10 + phase * 0.12);\n        r += 0.030 * sin(angle * 3.0 + 1.80 - phase * 0.09);\n        r += 0.020 * sin(angle * 5.0 - 0.90 + phase * 0.05);\n    } else if (variant < 5.5) {\n        r += 0.145 * sin(angle * 2.0 - 1.30 + phase * 0.17);\n        r += 0.070 * sin(angle * 3.0 + 2.40 - phase * 0.11);\n        r += 0.035 * sin(angle * 5.0 + 0.20 + phase * 0.08);\n    } else if (variant < 6.5) {\n        r += 0.045 * sin(angle * 2.0 + 1.70 + phase * 0.10);\n        r += 0.035 * sin(angle * 4.0 - 2.10 - phase * 0.08);\n        r += 0.025 * sin(angle * 6.0 + 0.50 + phase * 0.05);\n    } else {\n        r += 0.170 * sin(angle * 2.0 + 2.80 + phase * 0.20);\n        r += 0.090 * sin(angle * 3.0 - 1.90 - phase * 0.15);\n        r += 0.055 * sin(angle * 5.0 + 0.80 + phase * 0.09);\n    }\n\n    return r;\n}\n\nvec2 applyCenterRepulsor(vec2 center) {\n    float d = length(center);\n    vec2 dir = normalize(center + vec2(0.0001, 0.0001));\n\n    center += dir * uEdgePull;\n\n    float centerInfluence = 1.0 - smoothstep(uCenterClear, uCenterClear + 0.35, d);\n    center += dir * centerInfluence * CENTER_CLEAR_PUSH;\n\n    return center;\n}\n\nfloat animatedScale(float baseScale, float blobIndex, float blobSpeed) {\n    float localPhase =\n        uTime * SCALE_PULSE_SPEED * (0.65 + blobSpeed * 1.35) +\n        blobIndex * 2.731;\n\n    float pulseA = sin(localPhase);\n    float pulseB = sin(localPhase * 0.47 + blobIndex * 5.13) * 0.45;\n\n    float scaleMultiplier = 1.0 + (pulseA + pulseB) * SCALE_PULSE_AMOUNT;\n\n    return baseScale * max(0.05, scaleMultiplier);\n}\n\nfloat blobMask(vec2 p, vec2 center, Blob b, float phase, float liveScale) {\n    vec2 q = p - center;\n\n    vec2 squash = vec2(\n        1.0 + 0.14 * sin(b.variant * 1.91),\n        1.0 + 0.14 * cos(b.variant * 2.37)\n    );\n\n    float rotationSway =\n        sin(uTime * ROTATION_SWAY_SPEED * (0.6 + b.speed) + b.variant * 3.0) *\n        ROTATION_SWAY_AMOUNT;\n\n    q = rotate2d(b.rotation + rotationSway) * q;\n    q /= squash;\n\n    float angle = atan(q.y, q.x);\n    float dist = length(q);\n\n    float r = liveScale * uScale * 0.5 * variantRadius(angle, b.variant, phase);\n\n    return 1.0 - smoothstep(r, r + uEdgeSoftness, dist);\n}\n\nvoid main() {\n    vec2 uv = vUv;\n\n    vec2 p = uv * 2.0 - 1.0;\n    p.x *= uResolution.x / uResolution.y;\n\n    vec3 blobCol = vec3(0.0);\n    float blobAlpha = 0.0;\n\n    // Integer-counted loop over a compile-time bound; i is reconstructed as\n    // float(n), so the per-blob lookups and phases match the prototype.\n    for (int n = 0; n < BLOB_COUNT; n++) {\n        float i = float(n);\n        Blob b = getBlob(i);\n\n        float phase =\n            uTime * b.speed * uMotionSpeed * SHAPE_MORPH_SPEED +\n            i * 4.137;\n\n        vec2 center = b.pos;\n\n        center.x += sin(phase * 0.41 + i * 1.70) * b.drift * uMotionAmount;\n        center.x += sin(phase * 0.19 + i * 3.10) * b.drift * uMotionAmount * 0.45;\n        center.y += cos(phase * 0.33 + i * 2.30) * b.drift * uMotionAmount * 0.75;\n        center.y += sin(phase * 0.17 + i * 4.40) * b.drift * uMotionAmount * 0.35;\n\n        center = applyCenterRepulsor(center);\n\n        float liveScale = animatedScale(b.scale, i, b.speed);\n        float mask = blobMask(p, center, b, phase, liveScale);\n\n        float inner = pow(mask, 1.35);\n        float rim = mask * (1.0 - smoothstep(0.45, 1.0, mask));\n\n        vec3 gelColor = b.color * inner + b.color * rim * 0.18;\n        float a = mask * b.opacity * uGlobalAlpha;\n\n        blobCol += gelColor * a * (1.0 - blobAlpha);\n        blobAlpha += a * (1.0 - blobAlpha);\n    }\n\n    // Premultiplied output; tint grades the (premultiplied) color, not alpha.\n    oColor = vec4(blobCol * uColor, blobAlpha);\n}\n`;\n\n// Generative background shaders, by name. The generic shader processor and the\n// dispatch iterate this; adding a generative .frag adds an entry here.\nexport const SHADER_SOURCES: Readonly<Record<string, string>> = {\n  'plasma': PLASMA_FRAG_SRC,\n  'clouds': CLOUDS_FRAG_SRC,\n  'nebula': NEBULA_FRAG_SRC,\n  'godrays': GODRAYS_FRAG_SRC,\n  'fireflies': FIREFLIES_FRAG_SRC,\n  'simianlights': SIMIANLIGHTS_FRAG_SRC,\n  'anamorphic-lensflare': ANAMORPHIC_LENSFLARE_FRAG_SRC,\n  'light-beams-and-motes': LIGHT_BEAMS_AND_MOTES_FRAG_SRC,\n  'corporate-blobs': CORPORATE_BLOBS_FRAG_SRC,\n} as const;\n"]}

package/dist/web-driver/shaders.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PASSTHROUGH_VERT_SRC = exports.COMPOSITE_SUBJECT_FRAG_SRC = exports.COMPOSITE_MASKED_FRAG_SRC = exports.COMPOSITE_IMAGE_FRAG_SRC = exports.COMPOSITE_CAMERA_FRAG_SRC = exports.COMPOSITE_BLUR_FRAG_SRC = void 0;
+// Web GLSL entry point. The shader source is generated from the canonical
+// `shaders/*.frag` / `*.vert` by `bun run build:shaders` into
+// `./shaders.generated`; this module re-exports it so web effect code imports
+// from one stable path. Do not hand-edit the generated file.
+//
+// The compositor folds every effect into one layered stage (see
+// web-driver/effects/composite.ts). The shared sources the runtime imports from here:
+//   - PASSTHROUGH_VERT_SRC: full-screen quad via gl_VertexID (no VAO/VBO);
+//     caller does gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4).
+//   - COMPOSITE_CAMERA_FRAG_SRC: the camera/direct layer (canonical
+//     shaders/_shared/composite-camera.frag).
+//   - COMPOSITE_BLUR_FRAG_SRC: the camera-sampling blur layer (canonical
+//     shaders/blur/composite-blur.frag).
+//   - COMPOSITE_IMAGE_FRAG_SRC: cover-fit image layer, also the scratch blit
+//     (canonical shaders/_shared/composite-image.frag).
+//   - COMPOSITE_SUBJECT_FRAG_SRC / COMPOSITE_MASKED_FRAG_SRC: the masked person
+//     and the masked-scratch stencil (canonical shaders/_shared/composite-*.frag).
+var shaders_generated_1 = require("./shaders.generated");
+Object.defineProperty(exports, "COMPOSITE_BLUR_FRAG_SRC", { enumerable: true, get: function () { return shaders_generated_1.COMPOSITE_BLUR_FRAG_SRC; } });
+Object.defineProperty(exports, "COMPOSITE_CAMERA_FRAG_SRC", { enumerable: true, get: function () { return shaders_generated_1.COMPOSITE_CAMERA_FRAG_SRC; } });
+Object.defineProperty(exports, "COMPOSITE_IMAGE_FRAG_SRC", { enumerable: true, get: function () { return shaders_generated_1.COMPOSITE_IMAGE_FRAG_SRC; } });
+Object.defineProperty(exports, "COMPOSITE_MASKED_FRAG_SRC", { enumerable: true, get: function () { return shaders_generated_1.COMPOSITE_MASKED_FRAG_SRC; } });
+Object.defineProperty(exports, "COMPOSITE_SUBJECT_FRAG_SRC", { enumerable: true, get: function () { return shaders_generated_1.COMPOSITE_SUBJECT_FRAG_SRC; } });
+Object.defineProperty(exports, "PASSTHROUGH_VERT_SRC", { enumerable: true, get: function () { return shaders_generated_1.PASSTHROUGH_VERT_SRC; } });
+//# sourceMappingURL=shaders.js.map

package/dist/web-driver/shaders.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shaders.js","sourceRoot":"","sources":["../../web-driver/shaders.ts"],"names":[],"mappings":";;;AAAA,0EAA0E;AAC1E,8DAA8D;AAC9D,8EAA8E;AAC9E,6DAA6D;AAC7D,EAAE;AACF,gEAAgE;AAChE,sFAAsF;AACtF,2EAA2E;AAC3E,0DAA0D;AAC1D,oEAAoE;AACpE,8CAA8C;AAC9C,yEAAyE;AACzE,yCAAyC;AACzC,6EAA6E;AAC7E,wDAAwD;AACxD,gFAAgF;AAChF,mFAAmF;AACnF,yDAO6B;AAN3B,4HAAA,uBAAuB,OAAA;AACvB,8HAAA,yBAAyB,OAAA;AACzB,6HAAA,wBAAwB,OAAA;AACxB,8HAAA,yBAAyB,OAAA;AACzB,+HAAA,0BAA0B,OAAA;AAC1B,yHAAA,oBAAoB,OAAA","sourcesContent":["// Web GLSL entry point. The shader source is generated from the canonical\n// `shaders/*.frag` / `*.vert` by `bun run build:shaders` into\n// `./shaders.generated`; this module re-exports it so web effect code imports\n// from one stable path. Do not hand-edit the generated file.\n//\n// The compositor folds every effect into one layered stage (see\n// web-driver/effects/composite.ts). The shared sources the runtime imports from here:\n//   - PASSTHROUGH_VERT_SRC: full-screen quad via gl_VertexID (no VAO/VBO);\n//     caller does gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4).\n//   - COMPOSITE_CAMERA_FRAG_SRC: the camera/direct layer (canonical\n//     shaders/_shared/composite-camera.frag).\n//   - COMPOSITE_BLUR_FRAG_SRC: the camera-sampling blur layer (canonical\n//     shaders/blur/composite-blur.frag).\n//   - COMPOSITE_IMAGE_FRAG_SRC: cover-fit image layer, also the scratch blit\n//     (canonical shaders/_shared/composite-image.frag).\n//   - COMPOSITE_SUBJECT_FRAG_SRC / COMPOSITE_MASKED_FRAG_SRC: the masked person\n//     and the masked-scratch stencil (canonical shaders/_shared/composite-*.frag).\nexport {\n  COMPOSITE_BLUR_FRAG_SRC,\n  COMPOSITE_CAMERA_FRAG_SRC,\n  COMPOSITE_IMAGE_FRAG_SRC,\n  COMPOSITE_MASKED_FRAG_SRC,\n  COMPOSITE_SUBJECT_FRAG_SRC,\n  PASSTHROUGH_VERT_SRC,\n} from './shaders.generated';\n"]}

package/dist/web-driver/tuning.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tuning.d.ts","sourceRoot":"","sources":["../../web-driver/tuning.ts"],"names":[],"mappings":"AAWA,cAAM,iBAAiB;IACrB,SAAS,SAAK;IACd,YAAY,SAAO;IACnB,aAAa,SAAO;IAGpB,2BAA2B,SAAO;IAClC,WAAW,UAAS;IAEpB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAEhC;IAED,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAEnC;IAED,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAEpC;IAED,8BAA8B,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAElD;IAED,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAEnC;IAED,KAAK,IAAI,IAAI,CAMZ;CACF;AAED,eAAO,MAAM,MAAM,mBAA0B,CAAC;AAE9C;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB,aACpB,MAAM,aACL,MAAM,KAChB,SAAS,CAAC,MAAM,EAAE,MAAM,CAK1B,CAAC","sourcesContent":["// Mutable runtime state for the web GLSL effects. Mirrors\n// android/.../EffectTuning.kt and ios/.../EffectTuning.swift.\n//\n// There are no global set* exports anymore; the mask edge (hardness/threshold)\n// is written here through the setMask closure that `bindKaleidoscope`\n// (src/index.web.ts) wires up, and the composite compositor in\n// `web-driver/effects/*.ts` reads it when uploading uniforms. Writes take effect on\n// the next frame.\n\nconst clamp = (value: number, lo: number, hi: number): number => Math.min(Math.max(value, lo), hi);\n\nclass EffectTuningState {\n  blurSigma = 5;\n  maskHardness = 0.5;\n  maskThreshold = 0.5;\n  // Native-only knobs stored here for cross-platform API parity; the web\n  // MediaPipe pipeline does not currently consume them.\n  segmentationTargetShortSide = 384;\n  debugTiming = false;\n\n  setBlurSigma(value: number): void {\n    this.blurSigma = clamp(value, 0.5, 7);\n  }\n\n  setMaskHardness(value: number): void {\n    this.maskHardness = clamp(value, 0, 1);\n  }\n\n  setMaskThreshold(value: number): void {\n    this.maskThreshold = clamp(value, 0.05, 0.95);\n  }\n\n  setSegmentationTargetShortSide(value: number): void {\n    this.segmentationTargetShortSide = clamp(value, 128, 1080);\n  }\n\n  setDebugTiming(value: boolean): void {\n    this.debugTiming = value;\n  }\n\n  reset(): void {\n    this.blurSigma = 5;\n    this.maskHardness = 0.5;\n    this.maskThreshold = 0.5;\n    this.segmentationTargetShortSide = 384;\n    this.debugTiming = false;\n  }\n}\n\nexport const tuning = new EffectTuningState();\n\n/**\n * Derive a smoothstep (lo, hi) range from a hardness factor in [0, 1] and\n * a threshold in [0.05, 0.95]. Matches `MaskTuning.smoothstepRange` on the\n * Android side; keep in sync.\n *\n * hardness controls width: 0 = soft halo (wide transition), 1 = near-step.\n * threshold controls the center: 0.5 = neutral, higher = reject low-\n * confidence pixels (rejects chair-edge regions), lower = more inclusive.\n */\nexport const maskSmoothstepRange = (\n  hardness: number,\n  threshold: number,\n): readonly [number, number] => {\n  const clampedHardness = clamp(hardness, 0, 1);\n  const clampedThreshold = clamp(threshold, 0.05, 0.95);\n  const width = 0.6 * (1 - clampedHardness) + 0.02;\n  return [clampedThreshold - width * 0.5, clampedThreshold + width * 0.5] as const;\n};\n"]}

package/dist/web-driver/tuning.js

@@ -0,0 +1,61 @@
+"use strict";
+// Mutable runtime state for the web GLSL effects. Mirrors
+// android/.../EffectTuning.kt and ios/.../EffectTuning.swift.
+//
+// There are no global set* exports anymore; the mask edge (hardness/threshold)
+// is written here through the setMask closure that `bindKaleidoscope`
+// (src/index.web.ts) wires up, and the composite compositor in
+// `web-driver/effects/*.ts` reads it when uploading uniforms. Writes take effect on
+// the next frame.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maskSmoothstepRange = exports.tuning = void 0;
+const clamp = (value, lo, hi) => Math.min(Math.max(value, lo), hi);
+class EffectTuningState {
+    blurSigma = 5;
+    maskHardness = 0.5;
+    maskThreshold = 0.5;
+    // Native-only knobs stored here for cross-platform API parity; the web
+    // MediaPipe pipeline does not currently consume them.
+    segmentationTargetShortSide = 384;
+    debugTiming = false;
+    setBlurSigma(value) {
+        this.blurSigma = clamp(value, 0.5, 7);
+    }
+    setMaskHardness(value) {
+        this.maskHardness = clamp(value, 0, 1);
+    }
+    setMaskThreshold(value) {
+        this.maskThreshold = clamp(value, 0.05, 0.95);
+    }
+    setSegmentationTargetShortSide(value) {
+        this.segmentationTargetShortSide = clamp(value, 128, 1080);
+    }
+    setDebugTiming(value) {
+        this.debugTiming = value;
+    }
+    reset() {
+        this.blurSigma = 5;
+        this.maskHardness = 0.5;
+        this.maskThreshold = 0.5;
+        this.segmentationTargetShortSide = 384;
+        this.debugTiming = false;
+    }
+}
+exports.tuning = new EffectTuningState();
+/**
+ * Derive a smoothstep (lo, hi) range from a hardness factor in [0, 1] and
+ * a threshold in [0.05, 0.95]. Matches `MaskTuning.smoothstepRange` on the
+ * Android side; keep in sync.
+ *
+ * hardness controls width: 0 = soft halo (wide transition), 1 = near-step.
+ * threshold controls the center: 0.5 = neutral, higher = reject low-
+ * confidence pixels (rejects chair-edge regions), lower = more inclusive.
+ */
+const maskSmoothstepRange = (hardness, threshold) => {
+    const clampedHardness = clamp(hardness, 0, 1);
+    const clampedThreshold = clamp(threshold, 0.05, 0.95);
+    const width = 0.6 * (1 - clampedHardness) + 0.02;
+    return [clampedThreshold - width * 0.5, clampedThreshold + width * 0.5];
+};
+exports.maskSmoothstepRange = maskSmoothstepRange;
+//# sourceMappingURL=tuning.js.map

package/dist/web-driver/tuning.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tuning.js","sourceRoot":"","sources":["../../web-driver/tuning.ts"],"names":[],"mappings":";AAAA,0DAA0D;AAC1D,8DAA8D;AAC9D,EAAE;AACF,+EAA+E;AAC/E,sEAAsE;AACtE,+DAA+D;AAC/D,oFAAoF;AACpF,kBAAkB;;;AAElB,MAAM,KAAK,GAAG,CAAC,KAAa,EAAE,EAAU,EAAE,EAAU,EAAU,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC;AAEnG,MAAM,iBAAiB;IACrB,SAAS,GAAG,CAAC,CAAC;IACd,YAAY,GAAG,GAAG,CAAC;IACnB,aAAa,GAAG,GAAG,CAAC;IACpB,uEAAuE;IACvE,sDAAsD;IACtD,2BAA2B,GAAG,GAAG,CAAC;IAClC,WAAW,GAAG,KAAK,CAAC;IAEpB,YAAY,CAAC,KAAa;QACxB,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC,KAAK,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;IACxC,CAAC;IAED,eAAe,CAAC,KAAa;QAC3B,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IACzC,CAAC;IAED,gBAAgB,CAAC,KAAa;QAC5B,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;IAChD,CAAC;IAED,8BAA8B,CAAC,KAAa;QAC1C,IAAI,CAAC,2BAA2B,GAAG,KAAK,CAAC,KAAK,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;IAC7D,CAAC;IAED,cAAc,CAAC,KAAc;QAC3B,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;IAC3B,CAAC;IAED,KAAK;QACH,IAAI,CAAC,SAAS,GAAG,CAAC,CAAC;QACnB,IAAI,CAAC,YAAY,GAAG,GAAG,CAAC;QACxB,IAAI,CAAC,aAAa,GAAG,GAAG,CAAC;QACzB,IAAI,CAAC,2BAA2B,GAAG,GAAG,CAAC;QACvC,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;IAC3B,CAAC;CACF;AAEY,QAAA,MAAM,GAAG,IAAI,iBAAiB,EAAE,CAAC;AAE9C;;;;;;;;GAQG;AACI,MAAM,mBAAmB,GAAG,CACjC,QAAgB,EAChB,SAAiB,EACU,EAAE;IAC7B,MAAM,eAAe,GAAG,KAAK,CAAC,QAAQ,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAC9C,MAAM,gBAAgB,GAAG,KAAK,CAAC,SAAS,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;IACtD,MAAM,KAAK,GAAG,GAAG,GAAG,CAAC,CAAC,GAAG,eAAe,CAAC,GAAG,IAAI,CAAC;IACjD,OAAO,CAAC,gBAAgB,GAAG,KAAK,GAAG,GAAG,EAAE,gBAAgB,GAAG,KAAK,GAAG,GAAG,CAAU,CAAC;AACnF,CAAC,CAAC;AARW,QAAA,mBAAmB,GAAnB,mBAAmB,CAQ9B","sourcesContent":["// Mutable runtime state for the web GLSL effects. Mirrors\n// android/.../EffectTuning.kt and ios/.../EffectTuning.swift.\n//\n// There are no global set* exports anymore; the mask edge (hardness/threshold)\n// is written here through the setMask closure that `bindKaleidoscope`\n// (src/index.web.ts) wires up, and the composite compositor in\n// `web-driver/effects/*.ts` reads it when uploading uniforms. Writes take effect on\n// the next frame.\n\nconst clamp = (value: number, lo: number, hi: number): number => Math.min(Math.max(value, lo), hi);\n\nclass EffectTuningState {\n  blurSigma = 5;\n  maskHardness = 0.5;\n  maskThreshold = 0.5;\n  // Native-only knobs stored here for cross-platform API parity; the web\n  // MediaPipe pipeline does not currently consume them.\n  segmentationTargetShortSide = 384;\n  debugTiming = false;\n\n  setBlurSigma(value: number): void {\n    this.blurSigma = clamp(value, 0.5, 7);\n  }\n\n  setMaskHardness(value: number): void {\n    this.maskHardness = clamp(value, 0, 1);\n  }\n\n  setMaskThreshold(value: number): void {\n    this.maskThreshold = clamp(value, 0.05, 0.95);\n  }\n\n  setSegmentationTargetShortSide(value: number): void {\n    this.segmentationTargetShortSide = clamp(value, 128, 1080);\n  }\n\n  setDebugTiming(value: boolean): void {\n    this.debugTiming = value;\n  }\n\n  reset(): void {\n    this.blurSigma = 5;\n    this.maskHardness = 0.5;\n    this.maskThreshold = 0.5;\n    this.segmentationTargetShortSide = 384;\n    this.debugTiming = false;\n  }\n}\n\nexport const tuning = new EffectTuningState();\n\n/**\n * Derive a smoothstep (lo, hi) range from a hardness factor in [0, 1] and\n * a threshold in [0.05, 0.95]. Matches `MaskTuning.smoothstepRange` on the\n * Android side; keep in sync.\n *\n * hardness controls width: 0 = soft halo (wide transition), 1 = near-step.\n * threshold controls the center: 0.5 = neutral, higher = reject low-\n * confidence pixels (rejects chair-edge regions), lower = more inclusive.\n */\nexport const maskSmoothstepRange = (\n  hardness: number,\n  threshold: number,\n): readonly [number, number] => {\n  const clampedHardness = clamp(hardness, 0, 1);\n  const clampedThreshold = clamp(threshold, 0.05, 0.95);\n  const width = 0.6 * (1 - clampedHardness) + 0.02;\n  return [clampedThreshold - width * 0.5, clampedThreshold + width * 0.5] as const;\n};\n"]}

package/ios/Kaleidoscope.podspec

@@ -17,9 +17,9 @@ Pod::Spec.new do |s|
   # source_files, AND they use a custom `.metalsrc` extension instead of
   # `.metal`. Both halves of that constraint are load-bearing:
   #
-  #   (a) All three transpiled shaders (passthrough, blur, composite) export
-  #       the entry point `main0` because spirv-cross emits `main0` for every
-  #       stage. Three identical symbols cannot coexist in one metallib.
+  #   (a) Every transpiled shader exports the entry point `main0` because
+  #       spirv-cross emits `main0` for every stage. Identical symbols cannot
+  #       coexist in one metallib.
   #   (b) Excluding them from source_files prevents the main target's default
   #       metallib from compiling and colliding on `main0`.
   #   (c) Renaming the extension from `.metal` to `.metalsrc` prevents Xcode's
@@ -34,12 +34,13 @@ Pod::Spec.new do |s|
   #       so each `main0` stays in its own namespace.
   s.source_files   = 'KaleidoscopeModule/**/*.{h,m,swift}'
 
-  # Bundled background-image presets (mirrors android/src/main/assets/
-  # backgrounds/) plus the transpiled Metal shader SOURCE. Both are loaded at
-  # runtime from the Kaleidoscope.bundle:
-  #   - BackgroundImageProcessor resolves "dark-office" -> dark-office.webp.
-  #   - ShaderLibrary reads passthrough/blur/composite.metalsrc as TEXT and
-  #     compiles each into its own MTLLibrary via makeLibrary(source:). The
+  # Bundled images (mirrors android/src/main/assets/images/) plus the
+  # transpiled Metal shader SOURCE. Both are loaded at runtime from the
+  # Kaleidoscope.bundle:
+  #   - BundledImage resolves "dark-office" -> dark-office.webp (shared by
+  #     resolveImageUri and the composite's image layers).
+  #   - ShaderLibrary reads each `.metalsrc` as TEXT and compiles it into its
+  #     own MTLLibrary via makeLibrary(source:). The
   #     `.metalsrc` extension (not `.metal`) is required so Xcode's
   #     MetalCompile build phase does not auto-compile them into a
   #     `default.metallib` inside the bundle and hit the same `main0`
@@ -50,18 +51,24 @@ Pod::Spec.new do |s|
     'Kaleidoscope' => [
       'KaleidoscopeModule/resources/**/*',
       'KaleidoscopeModule/shaders/*.metalsrc',
+      # The generative-shader name list (codegen) so registration is data-driven.
+      'KaleidoscopeModule/shaders/GENERATIVE.txt',
     ]
   }
 
   s.dependency 'ExpoModulesCore'
 
   # Person segmentation via MediaPipe Tasks ImageSegmenter, replacing Apple
-  # Vision. Pinned to the 0.10 line to track Android's
+  # Vision. Pinned to EXACTLY 0.10.14 to match Android's
   # com.google.mediapipe:tasks-vision:0.10.14 (same model family, same
   # confidence-mask API shape) so all three platforms run identical
-  # segmentation. The selfie_segmenter.tflite model ships in the
-  # Kaleidoscope.bundle resource_bundles glob below (resources/**/*).
-  s.dependency 'MediaPipeTasksVision', '~> 0.10'
+  # segmentation. The exact pin (not `~> 0.10`) is deliberate: the pessimistic
+  # range floats to the newest 0.10.x, and MediaPipeTasksVision 0.10.33+ ships
+  # an XCFramework structure with known CocoaPods linking problems; 0.10.14 is
+  # the known-good version the RN ecosystem standardizes on. The
+  # selfie_segmenter.tflite model ships in the Kaleidoscope.bundle
+  # resource_bundles glob below (resources/**/*).
+  s.dependency 'MediaPipeTasksVision', '0.10.14'
 
   # Fork-resolving dependency on react-native-webrtc. The Kaleidoscope target
   # needs FRAMEWORK_SEARCH_PATHS pointing at WebRTC.framework so the Swift
@@ -79,7 +86,7 @@ Pod::Spec.new do |s|
   # `#if canImport(livekit_react_native_webrtc)` chains in Registration.swift
   # and the three Processor files. Android's build.gradle is upstream-first
   # (pre-existing inconsistency, tracked separately); do NOT mirror Android
-  # here — the iOS Swift code unconditionally imports the LiveKit module first
+  # here; the iOS Swift code unconditionally imports the LiveKit module first
   # when present, and the chosen dependency must match what Swift imports.
   #
   # The plugin's `pod ... :modular_headers => true` Podfile patch
@@ -90,7 +97,7 @@ Pod::Spec.new do |s|
   #
   # `__dir__` here is `<consumer>/node_modules/react-native-webrtc-kaleidoscope/
   # ios/` at pod-install time, so `../../@livekit/react-native-webrtc`
-  # resolves to `<consumer>/node_modules/@livekit/react-native-webrtc` —
+  # resolves to `<consumer>/node_modules/@livekit/react-native-webrtc`;
   # the same probe app.plugin.js performs at `:117`.
   livekit_fork_path = File.expand_path('../../@livekit/react-native-webrtc', __dir__)
   if File.directory?(livekit_fork_path)

package/ios/KaleidoscopeModule/BundledImage.swift

@@ -0,0 +1,39 @@
+// Bundled-image URL resolution, kept after the per-effect art processors were
+// folded into the composite compositor (Phase C of the effect-unification plan).
+//
+// The standalone BackgroundImageProcessor / ShaderProcessor / BlurProcessor are
+// gone; their work now lives in CompositeProcessor (the one "composite" compositor).
+// Two small responsibilities those files used to host outlived them and live
+// here so nothing else has to reach into a deleted type:
+//
+//   - bundledURL(for:): resolve a bundled background `<id>.webp` for the picker's
+//     native thumbnail (the Expo `resolveImageUri` function in
+//     KaleidoscopeModule). Same lookup the old BackgroundImageProcessor used, so
+//     the thumbnail still resolves to the exact file the compositor would load.
+//   - the `Bundle(for:)` anchor: a stable class whose framework/app bundle the
+//     ShaderLibrary / GENERATIVE.txt lookups resolve relative to (was
+//     `Bundle(for: BackgroundImageProcessor.self)`).
+//
+// `BundleAnchor` is an empty NSObject solely so `Bundle(for:)` has a type that
+// lives in this module's binary; an enum cannot be passed to `Bundle(for:)`.
+
+import Foundation
+
+/// Stable type whose containing bundle anchors the Kaleidoscope resource-bundle
+/// lookups (ShaderLibrary, GENERATIVE.txt, background thumbnails). Empty by design.
+final class BundleAnchor: NSObject {}
+
+enum BundledImage {
+    /// Resolve a bundled image `<id>.webp`, searching the app bundle first
+    /// (the prebuild plugin copies every referenced image into the app target, so
+    /// they land flattened in `Bundle.main`) or, as a fallback, the Kaleidoscope
+    /// resource bundle and its `images/` subdir. The compositor loads the
+    /// same images; shared by the JS thumbnail resolver (`resolveImageUri`).
+    static func bundledURL(for id: String) -> URL? {
+        let containing = Bundle(for: BundleAnchor.self)
+        let resourceBundle = Bundle.kaleidoscopeResources(relativeTo: containing) ?? containing
+        return Bundle.main.url(forResource: id, withExtension: "webp")
+            ?? resourceBundle.url(forResource: id, withExtension: "webp", subdirectory: "images")
+            ?? resourceBundle.url(forResource: id, withExtension: "webp")
+    }
+}

package/ios/KaleidoscopeModule/CompositeLayers.swift

@@ -0,0 +1,142 @@
+// Composite-layer spec side-channel for the iOS composite compositor. Direct port of
+// android/.../CompositeLayers.kt.
+//
+// The Expo Module's setCompositeLayers(json) JS function writes here; CompositeProcessor
+// reads the current layer stack each frame and composites it. This delivers the
+// spec without re-registering, and carries the
+// whole ordered layer stack (the compositor is one registered effect name,
+// "composite", whose contents JS swaps as the active composite changes).
+//
+// The wire shape is a JSON array of layer objects (see parse()). JS sends it as a
+// String across the Expo bridge; we parse it once at set() time into immutable
+// value-type models the capture thread can read under a cheap lock. set() runs
+// on the JS/Expo thread; get() on the capture thread. An os_unfair_lock around
+// the snapshot reference is the memory barrier (the Swift analogue of Android's
+// @Volatile + immutable List), matching EffectTuning on iOS.
+//
+// A malformed layer is skipped with a log rather than crashing the render thread;
+// an unparseable whole payload leaves the previous composite in place.
+
+import Foundation
+import os.log
+
+/// One parsed composite layer. The `shader` discriminant decides which fields matter.
+/// A value type, so a `CompositeLayers.get()` snapshot the capture thread reads is an
+/// immutable copy that a concurrent set() cannot mutate underneath it.
+struct CompositeLayer {
+    let id: String // unique within a composite; the live-tuning / patch address
+    let shader: String
+    let target: String // "background" | "subject"
+    let blend: String? // "normal" | "additive" | nil (base = opaque)
+    let source: String? // image id for an `image` layer; nil otherwise
+    let uniforms: [String: [Float]] // generative-layer uniforms, by name
+}
+
+enum CompositeLayers {
+    private static let log = OSLog(subsystem: "com.simiancraft.kaleidoscope", category: "CompositeLayers")
+
+    private static var unsafeLock = os_unfair_lock_s()
+    private static var layers: [CompositeLayer] = []
+
+    /// The current parsed layer stack; a stable snapshot safe to read on the
+    /// capture thread. Returns a value-type array copy.
+    static func get() -> [CompositeLayer] {
+        os_unfair_lock_lock(&unsafeLock)
+        defer { os_unfair_lock_unlock(&unsafeLock) }
+        return layers
+    }
+
+    /// Parse and store the composite layer stack from the JS-supplied JSON string.
+    /// Called on the Expo module thread (JS-driven), not the capture thread.
+    /// Leaves the previous composite in place on a whole-payload parse failure.
+    static func set(_ json: String) {
+        guard let parsed = parse(json) else {
+            os_log("failed to parse composite layers; keeping previous composite",
+                   log: log, type: .error)
+            return
+        }
+        os_unfair_lock_lock(&unsafeLock)
+        layers = parsed
+        os_unfair_lock_unlock(&unsafeLock)
+        os_log("composite layers set: %d layer(s) [%{public}@]",
+               log: log, type: .info,
+               parsed.count, parsed.map(\.shader).joined(separator: ","))
+    }
+
+    /// Clear the active composite (used when a non-composite effect takes over).
+    static func clear() {
+        os_unfair_lock_lock(&unsafeLock)
+        layers = []
+        os_unfair_lock_unlock(&unsafeLock)
+    }
+
+    /// Parse the JSON array into value-type models. Returns nil on a whole-payload
+    /// failure (not an array, not valid JSON); a single malformed layer is skipped
+    /// with a log, mirroring CompositeLayers.kt.
+    private static func parse(_ json: String) -> [CompositeLayer]? {
+        guard let data = json.data(using: .utf8) else { return nil }
+        let root: Any
+        do {
+            root = try JSONSerialization.jsonObject(with: data)
+        } catch {
+            return nil
+        }
+        guard let array = root as? [Any] else { return nil }
+        var out = [CompositeLayer]()
+        out.reserveCapacity(array.count)
+        for (index, element) in array.enumerated() {
+            guard let obj = element as? [String: Any] else { continue }
+            guard let shader = obj["shader"] as? String, !shader.isEmpty else {
+                os_log("layer %d has no shader; skipping", log: log, type: .info, index)
+                continue
+            }
+            // `id` is always present on the wire now (serializeCompositeLayers emits it);
+            // fall back to the array index so a malformed payload missing it still
+            // yields a stable, unique-per-stack address rather than a collision.
+            // Mirrors CompositeLayers.kt's id fallback.
+            let id = (obj["id"] as? String) ?? String(index)
+            let target = (obj["target"] as? String) ?? "background"
+            let blend = obj["blend"] as? String
+            let source = obj["source"] as? String
+            let uniforms = parseUniforms(obj["uniforms"])
+            out.append(CompositeLayer(id: id, shader: shader, target: target, blend: blend,
+                                      source: source, uniforms: uniforms))
+        }
+        return out
+    }
+
+    /// name -> [Float]. A JSON number -> [f]; a JSON array of numbers -> [Float].
+    /// A non-numeric or malformed value is skipped with a log (the shader keeps its
+    /// MSL default for that name). NSNumber covers JSON's number type across the
+    /// Foundation deserializer; bool-typed NSNumbers are accepted as 0/1 (harmless
+    /// for a uniform channel). Mirrors CompositeLayers.parseUniforms.
+    private static func parseUniforms(_ value: Any?) -> [String: [Float]] {
+        guard let obj = value as? [String: Any] else { return [:] }
+        var out = [String: [Float]]()
+        out.reserveCapacity(obj.count)
+        for (key, raw) in obj {
+            if let floats = normalize(raw) {
+                out[key] = floats
+            } else {
+                os_log("skipping uniform %{public}@: unsupported type", log: log, type: .info, key)
+            }
+        }
+        return out
+    }
+
+    private static func normalize(_ value: Any) -> [Float]? {
+        if let number = value as? NSNumber {
+            return [number.floatValue]
+        }
+        if let array = value as? [Any] {
+            var out = [Float]()
+            out.reserveCapacity(array.count)
+            for element in array {
+                guard let number = element as? NSNumber else { return nil }
+                out.append(number.floatValue)
+            }
+            return out
+        }
+        return nil
+    }
+}