{"version":3,"file":"RB_Orb.Ca-RccnI.mjs","names":["useRef","useState","_Fragment"],"sources":["https:/framerusercontent.com/modules/INzRpVv9hRS261zL5mms/1YoVQKqqawK35OK5RArN/orbkit_core.js","https:/framerusercontent.com/modules/fvj2BEIV2uFaBWKCLQqE/vtvMJke66PBsM3klDRIO/orbkit_shdr16.js","https:/framerusercontent.com/modules/W1zgH9YhIO4H3hmIsbVu/hvseuPgF6ieJiKeJXQK9/orbkit_shdr17.js","https:/framerusercontent.com/modules/Wl7GTkVaa5gOu3RdW8A8/HczAIhIiIqTqd6TBuMti/orbkit_shdr13.js","https:/framerusercontent.com/modules/JOXgAEMRL2LsqxrL36Ca/1SLghn6nRFl4b9pLAwUO/orbkit_shdr21.js","https:/framerusercontent.com/modules/Hz8fwvv3zuIgqP0SKK5b/GehQ5EjgLnCNFh6eE7EB/orbkit_shdr25.js","https:/framerusercontent.com/modules/gtmx87kVWa3J3rfWnLIk/d0tTO0R1wOif43lbMv2g/RB_Orb.js"],"sourcesContent":["/*\n * Orbkit runtime by zzzzshawn — https://github.com/zzzzshawn/orbkit\n * MIT License, Copyright (c) 2026 zzzzshawn. Unmodified apart from this header and one type cast on the wrapper <style> tag.\n */\"use client\";import{jsx as _jsx,jsxs as _jsxs,Fragment as _Fragment}from\"react/jsx-runtime\";import{useEffect,useRef,useState}from\"react\";export const ORB_STATES=[\"idle\",\"thinking\",\"speaking\"];function clamp01(n){return Math.min(1,Math.max(0,n));}/** Per-state [input, output] volume synthesis. *//**\n * Transition rate shared by params, colours and the flow-speed multiplier.\n * They must move together: if the rate multiplier eases faster than the look,\n * a state change spins the orb up before it has finished cross-fading, which\n * reads as a lurch.\n *\n * This drives a critically damped spring rather than the exponential ease it\n * used to. An exponential's velocity is highest at the instant the target\n * changes, so every state change began with a jolt — and for params that are\n * spatial frequencies (Corona's warpFreq travels 5.25 -> 19.5 between states)\n * that jolt sweeps the field through its intermediate frequencies at maximum\n * rate, which is what read as the transition \"scrambling\".\n *\n * A spring starts at rest and accelerates, so the sweep is spread across the\n * transition instead of front-loaded. Measured on that warpFreq move it is a\n * 20% lower peak rate of change (20.3/s vs 25.3/s) AND it arrives sooner —\n * 1.50s to within 2% against the exponential's 2.18s, since an exponential\n * only ever asymptotes toward its target.\n */const PARAM_EASE=4;/*\n  One step of a critically damped spring, implicit (semi-implicit Euler would\n  blow up at the frame times a backgrounded tab produces). Returns nothing and\n  writes through the scratch pair so the hot loop allocates nothing.\n*/const springOut={x:0,v:0};function springStep(x,v,target,dt,omega){const f=1+2*dt*omega;const oo=omega*omega;const hoo=dt*oo;const hhoo=dt*hoo;const detInv=1/(f+hhoo);springOut.x=(f*x+dt*v+hhoo*target)*detInv;springOut.v=(v+hoo*(target-x))*detInv;}function targetVolumes(state,t){switch(state){case\"idle\":return[0,.3];case\"speaking\":return[clamp01(.65+Math.sin(t*4.8)*.22),clamp01(.75+Math.sin(t*3.6)*.22)];case\"thinking\":{const base=.38+.07*Math.sin(t*.7);const wander=.05*Math.sin(t*2.1)*Math.sin(t*.37+1.2);return[clamp01(base+wander),clamp01(.48+.12*Math.sin(t*1.05+.6))];}}}/** Every param and color at its schema default. */export function defaultValuesFor(variant){return{params:Object.fromEntries(variant.params.map(p=>[p.key,p.default])),colors:Object.fromEntries(variant.colors.map(c=>[c.key,c.default]))};}export function hexToRgb(hex){let h=hex.replace(\"#\",\"\").trim();if(h.length===3)h=h[0]+h[0]+h[1]+h[1]+h[2]+h[2];const n=parseInt(h,16);if(h.length!==6||Number.isNaN(n))return[1,1,1];return[(n>>16&255)/255,(n>>8&255)/255,(n&255)/255];}/* ------------------------------- GLSL shared ------------------------------- */const VERT=`\nattribute vec2 aPos;\nvoid main() { gl_Position = vec4(aPos, 0.0, 1.0); }\n`;/**\n * Prelude prepended to every orb fragment shader: uniforms, value noise, fbm,\n * and the centered aspect-corrected UV helper.\n */export const ORB_GLSL_HELPERS=`\nprecision highp float;\nuniform vec2 uRes;\nuniform float uTime;   // slow ambient clock (half real-time)\nuniform float uAnim;   // flow clock — its speed follows the output volume\nuniform float uInput;  // input volume 0..1: user speech energy\nuniform float uOutput; // output volume 0..1: agent speech energy\n\nfloat hash(vec2 p) { return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453123); }\nfloat noise(vec2 p) {\n  vec2 i = floor(p);\n  vec2 f = fract(p);\n  f = f * f * (3.0 - 2.0 * f);\n  return mix(\n    mix(hash(i), hash(i + vec2(1.0, 0.0)), f.x),\n    mix(hash(i + vec2(0.0, 1.0)), hash(i + vec2(1.0, 1.0)), f.x),\n    f.y\n  );\n}\nfloat fbm(vec2 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 = p * 2.03 + vec2(11.7, 7.3);\n    a *= 0.5;\n  }\n  return v;\n}\nvec2 orbUV() { return (2.0 * gl_FragCoord.xy - uRes) / min(uRes.x, uRes.y); }\n\n// GLSL ES 1.0 has no tanh() — it arrived in ES 3.0. Shader-golf listings lean\n// on it as a tone-mapper, so it ships here. Clamped against exp() overflow;\n// accurate for the non-negative accumulators those shaders produce.\nvec3 tanh3(vec3 x) {\n  x = clamp(x, -10.0, 10.0);\n  vec3 e = exp(2.0 * x);\n  return (e - 1.0) / (e + 1.0);\n}\n\n`;function paramUniformDecls(variant){return[...variant.params.map(p=>`uniform float uP_${p.key};`),...variant.colors.map(c=>`uniform vec3 uC_${c.key};`)].join(\"\\n\");}const canvasControllers=new WeakMap;function compile(gl,type,src){const shader=gl.createShader(type);if(!shader)return null;gl.shaderSource(shader,src);gl.compileShader(shader);if(!gl.getShaderParameter(shader,gl.COMPILE_STATUS)){console.error(\"[orbkit] shader compile error:\",gl.getShaderInfoLog(shader));gl.deleteShader(shader);return null;}return shader;}/* ----------------------------------------------------------------------------\n   Wrappers — optional decoration drawn around, under and over the orb.\n\n   A wrapper is pure CSS/SVG, never a shader: the orb keeps its own canvas and\n   the decoration is composited on top of it by the browser. That keeps the\n   whole set free for any orb (no per-variant shader work), costs nothing on\n   the GPU budget the shaders are already spending, and means swapping one\n   wrapper for another at runtime never touches the WebGL context. Turning a\n   wrapper on or off does, since that is what moves the canvas into or out of\n   the wrapper element — see the effect's `wrapped` dependency.\n\n   Layout: a wrapped orb becomes a square box, and the canvas is absolutely\n   positioned inside it with the spec's `inset`. The FOOTPRINT is unchanged —\n   `size` is still the outer diameter — so dropping a wrapper onto an existing\n   orb reflows nothing; the orb itself just shrinks to leave the ring room.\n\n   Colour: every layer that isn't physically light or shadow paints in\n   `currentColor`, so a wrapper picks up the surrounding text colour and reads\n   correctly on light and dark pages with no configuration. `wrapperColor`\n   sets that colour when you want something other than the inherited one.\n---------------------------------------------------------------------------- */export const ORB_WRAPPERS=[\"none\",\"glass\",\"ring\",\"dotted\",\"ticks\",\"reticle\",\"grid\",\"halftone\",\"scanlines\"];/*\n  Keyframes for the animated wrappers, shipped inside the component so an orb\n  stays a single self-contained file with nothing to add to a global\n  stylesheet. React 19 hoists a <style href precedence> into <head> and\n  de-duplicates it, so a page full of wrapped orbs emits this exactly once;\n  older React renders it inline, which is redundant but harmless.\n\n  Reduced motion parks all of it. The shader runtime already honours the same\n  preference for the orb itself (see the reduce-motion branch in the render\n  loop), and a ring that keeps spinning around a frozen orb would be the worse\n  half of the two still moving.\n*/const WRAPPER_STYLE_HREF=\"orbkit-wrapper\";const WRAPPER_CSS=`\n@keyframes orbkit-w-spin { to { transform: rotate(360deg); } }\n@keyframes orbkit-w-roll { from { transform: translateY(-110%); } to { transform: translateY(360%); } }\n@media (prefers-reduced-motion: reduce) {\n  .orbkit-w-anim { animation: none !important; }\n}\n`;const DISC={borderRadius:\"50%\"};/** One absolutely-positioned decoration layer, filling the wrapper box. */function Layer({inset=0,style,className}){return /*#__PURE__*/_jsx(\"span\",{\"aria-hidden\":\"true\",className:className,style:{position:\"absolute\",inset,pointerEvents:\"none\",...style}});}/**\n * A free-floating highlight — glass's specular and its bounce. These do not go\n * through `Layer` because they are placed with `left`/`top`/`width`, and a\n * style object that sets those on top of `Layer`'s `inset` shorthand is mixing\n * shorthand and longhand for the same property: React warns about it, and the\n * result depends on key order rather than on anything you would want to rely\n * on.\n */function Highlight({style}){return /*#__PURE__*/_jsx(\"span\",{\"aria-hidden\":\"true\",style:{position:\"absolute\",borderRadius:\"50%\",pointerEvents:\"none\",...style}});}/**\n * The mask that makes a wrapper HOLD the orb: cuts the canvas back to the\n * bubble and stops a hairline short of the rim, so the orb never quite touches\n * the glass.\n *\n * The percentage has to be derived rather than written down. `closest-side`\n * measures the CANVAS, and a wrapper with a negative inset draws its canvas\n * LARGER than the bubble — at -7 the canvas is 114% of the box, so the rim\n * sits at 100/1.14 = 87.7% of the canvas's own radius, not at 100%.\n *\n * The gap is real pixels rather than a share of the size: it reads as the same\n * band at 120px and at 900px, which a percentage would not.\n */const RIM_GAP_PX=4;function rimMask(inset){const rim=(100/(1-2*inset/100)).toFixed(2);// Feathered over the final pixel, so the cut is not a razor edge.\nconst solid=RIM_GAP_PX+.5;const clear=RIM_GAP_PX-.5;return`radial-gradient(circle closest-side, #000 calc(${rim}% - ${solid}px), rgba(0,0,0,0) calc(${rim}% - ${clear}px))`;}/** Both spellings, since Safari still wants the prefix for mask-image. */function masked(image){return{WebkitMaskImage:image,maskImage:image};}const svgLayer={position:\"absolute\",inset:0,width:\"100%\",height:\"100%\",pointerEvents:\"none\",overflow:\"visible\"};/** Glass's overfill, shared by its inset and the mask derived from it. */const GLASS_INSET=-4;const WRAPPER_SPECS={/*\n    glass — a blown bubble with the orb suspended inside it.\n\n    Five layers in the order light actually arrives: the body brightening\n    toward the key light, the Fresnel ring where a sphere's edge turns almost\n    edge-on and reflects nearly everything, the rim itself, the window\n    reflection, and the bounce coming back up off whatever the bubble is\n    sitting on. All of it is white and black rather than `currentColor` —\n    glass has no colour of its own, only the light it moves around.\n  */glass:{/*\n      Negative on purpose. An orb's shader does not necessarily paint to the\n      edge of its canvas — most draw a sphere with transparent margin around\n      it — so a canvas sized to the bubble leaves a dead ring between the orb\n      and the rim, which is not what a thing suspended in glass looks like.\n      Oversizing the canvas by 14% pushes the sphere out to the rim, and\n      `rimMask` cuts whatever overflows — a few pixels short of the glass, so\n      the orb sits just inside it rather than welded to it. Orbs that already fill\n      their canvas lose a few percent off the limb, which is the same crop the\n      reference bubble makes.\n    */inset:GLASS_INSET,mask:rimMask(GLASS_INSET),shadow:\"0 24px 48px -26px rgba(0,0,0,0.55)\",over:/*#__PURE__*/_jsxs(_Fragment,{children:[/*#__PURE__*/_jsx(Layer,{style:{...DISC,background:\"radial-gradient(ellipse 80% 70% at 28% 20%, rgba(255,255,255,0.16), rgba(255,255,255,0.03) 45%, rgba(255,255,255,0) 72%)\"}}),/*#__PURE__*/_jsx(Layer,{style:{...DISC,background:\"radial-gradient(circle closest-side, rgba(255,255,255,0) 0%, rgba(255,255,255,0.0) 55%, rgba(255,255,255,0.05) 99.5%, rgba(255,255,255,0) 100%)\",overflow:\"hidden\"}}),/*#__PURE__*/_jsx(Layer,{style:{...DISC,boxShadow:\"3px 6px 10px #ffffff20 inset\"}}),/*#__PURE__*/_jsx(Layer,{style:{...DISC,background:\"radial-gradient(circle closest-side, rgba(0,0,0,0) 78%, rgba(0,0,0,0.05) 93%, rgba(0,0,0,0.02) 100%)\"}}),/*#__PURE__*/_jsx(Layer,{style:{...DISC,boxShadow:\"inset 0 6px 12px -7px rgba(255,255,255,0.05), inset 0 -9px 16px -9px rgba(255,255,255,0.1), 0 0 0 1px rgba(0,0,0,0.07)\"}}),/*#__PURE__*/_jsx(Highlight,{style:{left:\"15%\",top:\"10%\",width:\"38%\",height:\"22%\",transform:\"rotate(-25deg)\",background:\"radial-gradient(closest-side, rgba(255,255,255,0.9), rgba(255,255,255,0.3) 55%, rgba(255,255,255,0) 100%)\",filter:\"blur(10px)\"}})]})},/* ring — two hairlines and nothing else. The restrained one. */ring:{inset:9,over:/*#__PURE__*/_jsxs(_Fragment,{children:[/*#__PURE__*/_jsx(Layer,{style:{...DISC,border:\"1px solid currentColor\",opacity:.22}}),/*#__PURE__*/_jsx(Layer,{inset:\"5%\",style:{...DISC,border:\"1px solid currentColor\",opacity:.1}})]})},/*\n    dotted — evenly spaced dots around the circumference, turning slowly.\n\n    Drawn as one dashed circle with round caps and a near-zero dash length, so\n    each dash collapses to a dot. `pathLength=\"64\"` renormalizes the path to 64\n    units first, which is what makes the count exact: the dash period is\n    literally 1/64th of the circle, so the pattern closes on itself with no\n    seam where the last gap would otherwise be short.\n  */dotted:{inset:10,animated:true,over:/*#__PURE__*/_jsx(\"svg\",{\"aria-hidden\":\"true\",viewBox:\"0 0 100 100\",className:\"orbkit-w-anim\",style:{...svgLayer,animation:\"orbkit-w-spin 48s linear infinite\"},children:/*#__PURE__*/_jsx(\"circle\",{cx:\"50\",cy:\"50\",r:\"47\",fill:\"none\",stroke:\"currentColor\",strokeWidth:\"1.7\",strokeLinecap:\"round\",pathLength:64,strokeDasharray:\"0.0001 0.9999\",opacity:.45})})},/*\n    ticks — an instrument bezel: a fine minor scale every 6 degrees with a\n    longer major tick every 30. Both are one repeating conic gradient masked\n    down to an annulus, so the tick count is set by the gradient's period and\n    the tick LENGTH by how far in the mask reaches.\n  */ticks:{inset:12,over:/*#__PURE__*/_jsxs(_Fragment,{children:[/*#__PURE__*/_jsx(Layer,{style:{...DISC,opacity:.32,background:\"repeating-conic-gradient(from -0.5deg, transparent 0deg 0.2deg, currentColor 0.4deg 0.6deg, transparent 0.8deg 6deg)\",...masked(\"radial-gradient(circle closest-side, transparent 88%, #000 90%, #000 97%, transparent 99%)\")}}),/*#__PURE__*/_jsx(Layer,{style:{...DISC,opacity:.6,background:\"repeating-conic-gradient(from -0.75deg, transparent 0deg 0.25deg, currentColor 0.5deg 1deg, transparent 1.25deg 30deg)\",...masked(\"radial-gradient(circle closest-side, transparent 80%, #000 82%, #000 97%, transparent 99%)\")}}),/*#__PURE__*/_jsx(Layer,{style:{...DISC,border:\"1px solid currentColor\",opacity:.12}})]})},/* reticle — viewfinder furniture: corner brackets, cardinal ticks, a track. */reticle:{inset:13,over:/*#__PURE__*/_jsxs(\"svg\",{\"aria-hidden\":\"true\",viewBox:\"0 0 100 100\",style:svgLayer,children:[/*#__PURE__*/_jsxs(\"g\",{fill:\"none\",stroke:\"currentColor\",strokeWidth:\"1.2\",opacity:\"0.5\",children:[/*#__PURE__*/_jsx(\"path\",{d:\"M1 13 L1 1 L13 1\"}),/*#__PURE__*/_jsx(\"path\",{d:\"M87 1 L99 1 L99 13\"}),/*#__PURE__*/_jsx(\"path\",{d:\"M99 87 L99 99 L87 99\"}),/*#__PURE__*/_jsx(\"path\",{d:\"M13 99 L1 99 L1 87\"})]}),/*#__PURE__*/_jsxs(\"g\",{fill:\"none\",stroke:\"currentColor\",strokeWidth:\"1\",opacity:\"0.38\",children:[/*#__PURE__*/_jsx(\"path\",{d:\"M50 1 L50 9\"}),/*#__PURE__*/_jsx(\"path\",{d:\"M50 91 L50 99\"}),/*#__PURE__*/_jsx(\"path\",{d:\"M1 50 L9 50\"}),/*#__PURE__*/_jsx(\"path\",{d:\"M91 50 L99 50\"})]}),/*#__PURE__*/_jsx(\"circle\",{cx:\"50\",cy:\"50\",r:\"46\",fill:\"none\",stroke:\"currentColor\",strokeWidth:\"0.7\",opacity:\"0.22\"})]})},/*\n    grid — a graticule laid over the orb and masked back to the disc, so the\n    mesh appears to be etched on the glass in front of it rather than drawn on\n    the page behind. The lines are 1px whatever the size; the SPACING is a\n    percentage, so the cell count holds from a gallery thumbnail to a\n    full-bleed hero.\n  */grid:{inset:8,/*\n      The ruling sits UNDER the canvas: graph paper the orb rests on, not a\n      mesh laid over its face. Drawn on top it crosshatched the shader — the\n      one thing the wrapper is meant to frame. The ring stays over, since it\n      only ever meets the transparent margin at the canvas edge.\n    */under:/*#__PURE__*/_jsx(Layer,{style:{...DISC,opacity:.18,backgroundImage:\"repeating-linear-gradient(to right, currentColor 0 1px, transparent 1px 12.5%), repeating-linear-gradient(to bottom, currentColor 0 1px, transparent 1px 12.5%)\",...masked(\"radial-gradient(circle closest-side, #000 86%, rgba(0,0,0,0) 99%)\")}}),over:/*#__PURE__*/_jsx(Layer,{style:{...DISC,border:\"1px solid currentColor\",opacity:.2}})},/*\n    halftone — a print screen over the outer band of the orb. The mask keeps\n    the middle clear, so the dots read as the image breaking up toward its\n    edge instead of a texture pasted across the whole face.\n  */halftone:{inset:6,over:/*#__PURE__*/_jsx(Layer,{style:{...DISC,opacity:.5,backgroundImage:\"radial-gradient(currentColor 22%, transparent 24%)\",backgroundSize:\"7px 7px\",...masked(\"radial-gradient(circle closest-side, transparent 40%, #000 80%, #000 94%, rgba(0,0,0,0) 100%)\")}})},/*\n    scanlines — a phosphor tube. Black lines rather than `currentColor`,\n    because scanlines are the UNLIT gaps between rows and stay dark whatever\n    the page is; the slow bright band rolling down is the vertical hold\n    drifting, which is the part that reads as a CRT rather than as stripes.\n  */scanlines:{inset:0,animated:true,over:/*#__PURE__*/_jsxs(_Fragment,{children:[/*#__PURE__*/_jsx(Layer,{style:{...DISC,backgroundImage:\"repeating-linear-gradient(to bottom, rgba(0,0,0,0.45) 0 1px, rgba(0,0,0,0) 1px 3px)\",...masked(\"radial-gradient(circle closest-side, #000 84%, rgba(0,0,0,0) 100%)\")}}),/*#__PURE__*/_jsx(\"span\",{\"aria-hidden\":\"true\",style:{position:\"absolute\",inset:0,borderRadius:\"50%\",overflow:\"hidden\",pointerEvents:\"none\"},children:/*#__PURE__*/_jsx(\"span\",{className:\"orbkit-w-anim\",style:{position:\"absolute\",left:0,right:0,top:0,height:\"30%\",background:\"linear-gradient(to bottom, rgba(255,255,255,0) 0%, rgba(255,255,255,0.07) 50%, rgba(255,255,255,0) 100%)\",animation:\"orbkit-w-roll 7s linear infinite\"}})}),/*#__PURE__*/_jsx(Layer,{style:{...DISC,boxShadow:\"inset 0 0 40px -8px rgba(0,0,0,0.5)\"}})]})}};export function ShaderOrb({variant,state=\"idle\",size,params,colors,statePresets,stateColors,stateVolumes,volumes,paused=false,pauseOffscreen=true,maxDpr=2,wrapper=\"none\",wrapperColor,className,style,ariaLabel}){const canvasRef=useRef(null);const spec=wrapper===\"none\"?undefined:WRAPPER_SPECS[wrapper];const wrapped=spec!==undefined;// Live refs: the render loop reads these every frame, so changing a param\n// never re-runs the GL setup effect (which would drop the context). Synced in\n// an effect rather than during render — a ref write during render is unsafe\n// under concurrent rendering, and the loop picks the new value up on the very\n// next frame anyway.\n/*\n    Whether the canvas has drawn a frame yet, tracked per variant because a\n    variant swap mounts a brand new canvas (see the `key` below).\n\n    A mounted-but-never-drawn canvas is at the browser's mercy: rather than\n    the transparent rectangle you would expect, a page that mounts a dozen at\n    once gets white boxes — and in some browsers a broken-image placeholder —\n    for as long as the compositor has nothing to raster. That window is not\n    small here: every orb compiles a full fragment shader synchronously in its\n    own mount effect, so on the gallery grid the first canvases sit empty\n    while the last ones are still compiling. Holding each canvas invisible\n    until its own first frame lands is what makes the grid fade in cleanly\n    instead of flashing. One state change per orb, once, on mount.\n  */const[paintedKey,setPaintedKey]=useState(null);const painted=paintedKey===variant.key;const stateRef=useRef(state);const paramsRef=useRef(params);const colorsRef=useRef(colors);const statePresetsRef=useRef(statePresets);const stateColorsRef=useRef(stateColors);const stateVolumesRef=useRef(stateVolumes);const volumesRef=useRef(volumes);const pausedRef=useRef(paused);useEffect(()=>{stateRef.current=state;paramsRef.current=params;colorsRef.current=colors;statePresetsRef.current=statePresets;stateColorsRef.current=stateColors;stateVolumesRef.current=stateVolumes;volumesRef.current=volumes;pausedRef.current=paused;},[state,params,colors,statePresets,stateColors,stateVolumes,volumes,paused]);useEffect(()=>{const canvas=canvasRef.current;if(!canvas)return;const gl=canvas.getContext(\"webgl\",{alpha:true,// No MSAA: the geometry is a single full-screen triangle, so there are no\n// primitive edges to antialias — softness comes from the shaders. Leaving\n// it on costs the multisample buffers plus a resolve every frame.\nantialias:false,premultipliedAlpha:true});if(!gl)return;const loseExt=gl.getExtension(\"WEBGL_lose_context\");/*\n      A \"generation\" is everything tied to a live context: program, buffers,\n      observers, render loop. Browsers cap live WebGL contexts per page and\n      evict the oldest past the cap, and an evicted orb's canvas stays blank\n      forever unless the app rebuilds — so generations tear down and rebuild on\n      the lost/restored events instead of assuming the context is immortal.\n    */let announcedPaint=false;const startGeneration=()=>{if(gl.isContextLost())return()=>{};// Every generation announces its own first frame: a context that was\n// lost and restored has an empty drawing buffer and is hidden again\n// (below), so it has to earn its reveal back.\nannouncedPaint=false;const vs=compile(gl,gl.VERTEX_SHADER,VERT);const fs=compile(gl,gl.FRAGMENT_SHADER,ORB_GLSL_HELPERS+paramUniformDecls(variant)+variant.frag);const releaseShaders=()=>{if(vs)gl.deleteShader(vs);if(fs)gl.deleteShader(fs);};if(!vs||!fs)return releaseShaders;const prog=gl.createProgram();if(!prog)return releaseShaders;gl.attachShader(prog,vs);gl.attachShader(prog,fs);gl.linkProgram(prog);if(!gl.getProgramParameter(prog,gl.LINK_STATUS)){console.error(\"[orbkit] program link error:\",gl.getProgramInfoLog(prog));gl.deleteProgram(prog);return releaseShaders;}gl.useProgram(prog);const buf=gl.createBuffer();gl.bindBuffer(gl.ARRAY_BUFFER,buf);gl.bufferData(gl.ARRAY_BUFFER,new Float32Array([-1,-1,3,-1,-1,3]),gl.STATIC_DRAW);const aPos=gl.getAttribLocation(prog,\"aPos\");gl.enableVertexAttribArray(aPos);gl.vertexAttribPointer(aPos,2,gl.FLOAT,false,0,0);gl.enable(gl.BLEND);gl.blendFunc(gl.ONE,gl.ONE_MINUS_SRC_ALPHA);const uRes=gl.getUniformLocation(prog,\"uRes\");const uTime=gl.getUniformLocation(prog,\"uTime\");const uAnim=gl.getUniformLocation(prog,\"uAnim\");const uInput=gl.getUniformLocation(prog,\"uInput\");const uOutput=gl.getUniformLocation(prog,\"uOutput\");const paramLocs=variant.params.map(p=>({def:p,loc:gl.getUniformLocation(prog,`uP_${p.key}`)}));const colorLocs=variant.colors.map(c=>({def:c,loc:gl.getUniformLocation(prog,`uC_${c.key}`)}));/* --- sizing: track the element box, not a one-shot measurement ------- */// Backing-store scale, stepped down by the adaptive-resolution logic in\n// the loop when the GPU can't hold frame rate. CSS size never changes —\n// the browser upscales, which these soft shaders absorb gracefully.\nlet resScale=1;const resize=()=>{const dpr=Math.min(window.devicePixelRatio||1,maxDpr)*resScale;const w=Math.max(1,Math.round(canvas.clientWidth*dpr));const h=Math.max(1,Math.round(canvas.clientHeight*dpr));if(canvas.width!==w||canvas.height!==h){canvas.width=w;canvas.height=h;gl.viewport(0,0,w,h);}/*\n          Uploaded UNCONDITIONALLY, outside the size guard. A rebuilt\n          generation (React strict-mode remount, a restored context) links a\n          fresh program whose uRes starts at zero — and the canvas usually\n          already holds the right backing size, so an upload gated behind\n          the resize never ran. With uRes = 0, orbUV() divides by zero and\n          every fragment lands transparent: a healthy context, a bound\n          program, and a permanently blank orb.\n        */gl.uniform2f(uRes,w,h);};resize();const resizeObserver=typeof ResizeObserver!==\"undefined\"?new ResizeObserver(resize):null;resizeObserver?.observe(canvas);/* --- visibility: don't burn a render loop on an offscreen orb -------- */let visible=!pauseOffscreen;const intersectionObserver=pauseOffscreen&&typeof IntersectionObserver!==\"undefined\"?new IntersectionObserver(entries=>{visible=Boolean(entries[0]?.isIntersecting);if(visible){last=performance.now()/1e3;}},{rootMargin:\"150px 0px\",threshold:0}):null;if(intersectionObserver){intersectionObserver.observe(canvas);}else{visible=true;}const reduceMotion=typeof window.matchMedia===\"function\"&&window.matchMedia(\"(prefers-reduced-motion: reduce)\").matches;/* --- driver state ---------------------------------------------------- */let tSec=0;// random phase so two orbs on the same page never look synchronized\nlet anim=Math.random()*100;let speed=.1;const cur={in:0,out:.3};const presets=variant.statePresets;const paramCur={};const paramVel={};const paramClocks={};const colorCur={};const colorVel={};let speedVel=0;const[initialIn,initialOut]=targetVolumes(stateRef.current,0);cur.in=initialIn;cur.out=initialOut;let last=performance.now()/1e3;let raf=0;// smoothed frame time for the adaptive-resolution check\nlet frameEma=1/60;const uploadAndDraw=(dt,snap=false)=>{// Synthesized from the state, unless a channel is pinned via\n// `volumes`. Pinned values still glide on the same easing, so dialing\n// one in the playground cross-fades rather than jumping.\nconst[tin,tout]=targetVolumes(stateRef.current,tSec);// Same order as params and colours: direct prop, then the per-state\n// map, then the engine's own synthesis.\nconst liveVolumes=volumesRef.current;const stateVolume=stateVolumesRef.current?.[stateRef.current];const targetIn=liveVolumes?.input??stateVolume?.input??tin;const targetOut=liveVolumes?.output??stateVolume?.output??tout;const kVol=1-Math.exp(-dt*12);cur.in+=(targetIn-cur.in)*kVol;cur.out+=(targetOut-cur.out)*kVol;/*\n          Flow speed follows the output volume. It multiplies every integrated\n          clock's increment, so it is a RATE: easing it quickly makes the orb\n          visibly lurch — a state change would spin the orb up hard before the\n          params had finished gliding.\n\n          It is therefore eased on the same constant as the params below, so a\n          state change ramps its motion over the same half second that its look\n          takes to cross-fade. The steady-state values are unchanged, so a\n          speaking orb still flows faster than an idle one; only the transition\n          into that rate is gradual.\n        */const targetSpeed=.1+(1-Math.pow(cur.out-1,2))*.9;if(snap){speed=targetSpeed;speedVel=0;}else{springStep(speed,speedVel,targetSpeed,dt,PARAM_EASE);speed=springOut.x;speedVel=springOut.v;}anim+=dt*speed;gl.uniform1f(uTime,tSec*.5);gl.uniform1f(uAnim,anim);gl.uniform1f(uInput,cur.in);gl.uniform1f(uOutput,cur.out);// Resolution order per param: explicit `params` → `statePresets`\n// prop → the variant's own preset → schema default. The two middle\n// steps are per-key, so overriding one param of one state leaves the\n// rest of that state alone. Values glide rather than snap.\nconst liveParams=paramsRef.current;const statePreset=presets?.[stateRef.current];const overridePreset=statePresetsRef.current?.[stateRef.current];for(const{def,loc}of paramLocs){const explicit=liveParams?.[def.key];const target=typeof explicit===\"number\"?explicit:overridePreset?.[def.key]??statePreset?.[def.key]??def.default;const curVal=paramCur[def.key]??target;let next;if(snap){next=target;paramVel[def.key]=0;}else{springStep(curVal,paramVel[def.key]??0,target,dt,PARAM_EASE);next=springOut.x;paramVel[def.key]=springOut.v;}paramCur[def.key]=next;if(def.integrate){const clock=(paramClocks[def.key]??(paramClocks[def.key]=Math.random()*100))+dt*speed*next;paramClocks[def.key]=clock;gl.uniform1f(loc,clock);}else{gl.uniform1f(loc,next);}}// Same resolution order and same easing as params, so a state change\n// cross-fades the palette instead of cutting to it.\nconst liveColors=colorsRef.current;const stateColor=variant.stateColors?.[stateRef.current];const overrideColor=stateColorsRef.current?.[stateRef.current];for(const{def,loc}of colorLocs){const target=hexToRgb(liveColors?.[def.key]??overrideColor?.[def.key]??stateColor?.[def.key]??def.default);const curCol=colorCur[def.key]??=[...target];const velCol=colorVel[def.key]??=[0,0,0];for(let i=0;i<3;i++){if(snap){curCol[i]=target[i];velCol[i]=0;}else{springStep(curCol[i],velCol[i],target[i],dt,PARAM_EASE);curCol[i]=springOut.x;velCol[i]=springOut.v;}}gl.uniform3f(loc,curCol[0],curCol[1],curCol[2]);}gl.clearColor(0,0,0,0);gl.clear(gl.COLOR_BUFFER_BIT);gl.drawArrays(gl.TRIANGLES,0,3);// Deferred a microtask: the first of these draws runs synchronously\n// inside this effect, and a sync setState there trips the compiler\n// lint. A microtask still resolves before the browser paints, so the\n// reveal is not delayed by a frame.\nif(!announcedPaint){announcedPaint=true;queueMicrotask(()=>{/*\n              Re-check: the context can be evicted between this draw and the\n              microtask, and mounting one more orb anywhere on the page is\n              enough to do it — opening the details drawer over a full gallery\n              is exactly that. Revealing on the strength of a frame that has\n              already been thrown away puts a dead canvas on screen, which is\n              what the browser draws its broken-canvas placeholder over. The\n              generation that follows the restore announces again.\n            */if(gl.isContextLost())return;setPaintedKey(variant.key);});}};const releaseGL=()=>{resizeObserver?.disconnect();intersectionObserver?.disconnect();gl.deleteProgram(prog);gl.deleteShader(vs);gl.deleteShader(fs);gl.deleteBuffer(buf);};if(reduceMotion){// One representative frame, then stop — snapped straight onto the\n// state's targets, since a spring would only be part-way there.\ntSec=1;uploadAndDraw(1,true);return releaseGL;}const loop=()=>{raf=requestAnimationFrame(loop);const now=performance.now()/1e3;const dt=Math.min(now-last,.05);last=now;if(!visible||pausedRef.current)return;tSec+=dt;/*\n          Adaptive resolution. When the smoothed frame time sits above ~30fps,\n          the GPU is drowning in fragment work (these shaders are pure fill\n          cost), so step the backing store down 20% and re-measure. Steps only\n          go down — never back up — so the resolution can't oscillate. The\n          warm-up guard keeps page-load jank (hydration, first compiles) from\n          triggering a downgrade the GPU never asked for.\n        *//*\n          Only unstalled frames are evidence about GPU fill cost. `dt` above is\n          clamped at 0.05, so a frame that hits the clamp is the main thread\n          having been blocked — a slider drag re-rendering React, a GC pause, a\n          tab regaining focus — and feeding those in made UI jank look\n          identical to a drowning GPU.\n        */if(dt<.05)frameEma+=(dt-frameEma)*.08;if(tSec>1.5&&frameEma>1/34&&resScale>.5){resScale=Math.max(.5,resScale*.8);frameEma=1/60;// require fresh evidence before the next step\nresize();}else if(tSec>1.5&&frameEma<1/55&&resScale<1){/*\n            And step back up once frames are comfortably fast again. This used\n            to be one-way, on the reasoning that it could not then oscillate —\n            but that also meant one transient stall permanently halved the\n            orb's resolution, and at half resolution a high-frequency shader\n            aliases into shimmer that reads as the shader itself misbehaving.\n            The gap between the two thresholds (29ms down, 18ms up) is the\n            hysteresis that stops it hunting.\n          */resScale=Math.min(1,resScale/.8);frameEma=1/60;resize();}uploadAndDraw(dt);};/*\n        First frame synchronously, before entering the rAF loop. rAF does not\n        run at all in hidden documents (background tabs, embedded previews),\n        so a freshly mounted orb would otherwise sit fully transparent until\n        the page next becomes visible — a grid of mounted, healthy, blank\n        canvases. The sync frame guarantees every mount paints: background\n        documents get a static frame, visible ones start animating over it.\n        dt = 1 lands the param glide on its targets, as in the reduce-motion\n        frame above.\n      */uploadAndDraw(1);loop();return()=>{cancelAnimationFrame(raf);releaseGL();};};/*\n      Wire the canvas's lifecycle controller. The listeners are attached ONCE\n      per canvas element and never removed, deliberately: the lost event must\n      be canceled even while no orb is mounted on the canvas — an uncanceled\n      webglcontextlost marks the context permanently unrestorable, and the\n      router can show this exact canvas again later. Whether a loss leads to\n      a revival is decided by `desired`, not by listener presence.\n    *//*\n      A canvas whose context has gone is not simply blank: Chrome paints its\n      broken-image placeholder over the element's whole box — the white square\n      you see on a reloaded grid. Hide the canvas the moment the context is\n      lost, and let the generation that follows a restore reveal it again.\n    */const hideNow=()=>{/*\n        Both, deliberately. The style write lands in this tick — the browser\n        paints its placeholder over a dead canvas immediately, and a busy main\n        thread can hold a React update for several frames. The state change is\n        what keeps React's own view in sync, so the reveal that follows a\n        restore clears the inline value again rather than fighting it.\n      */canvas.style.opacity=\"0\";setPaintedKey(null);};const onContextLostHide=()=>hideNow();canvas.addEventListener(\"webglcontextlost\",onContextLostHide);/*\n      Hand the context back before the next document asks for one.\n\n      A hard reload never runs this effect's cleanup — the document is\n      discarded whole — so the outgoing page's contexts are still alive while\n      the incoming page allocates its own. On a grid of orbs that puts the\n      live count past the browser's ~16 cap, and the ones it evicts are\n      exactly the canvases that come back as placeholders until the restore\n      path catches them. `persisted` is a bfcache suspend, where the page is\n      shown again untouched and must keep everything it holds.\n    */const onPageHide=event=>{if(event.persisted)return;try{loseExt?.loseContext();}catch{// Already released — nothing to hand back.\n}};window.addEventListener(\"pagehide\",onPageHide);let ctl=canvasControllers.get(canvas);if(!ctl){const created={desired:false,start:null,stopGen:null};canvas.addEventListener(\"webglcontextlost\",event=>{event.preventDefault();// always cancel — keeps the context restorable\ncreated.stopGen?.();created.stopGen=null;if(created.desired){/*\n            Ask for the context back — but in a LATER task. The browser only\n            marks a loss as restorable once the lost event's dispatch has\n            completed and it has seen the canceled flag, so a restoreContext()\n            issued during dispatch (or before it, as the mount path may) is\n            silently refused. This is the path a synchronous cleanup+setup\n            pair hits — React re-running the effect on the same canvas loses\n            the context and wants it right back. For losses we didn't cause\n            (eviction, GPU reset) the call may refuse; the canceled event then\n            lets the browser restore on its own schedule.\n          */setTimeout(()=>{if(!created.desired)return;try{loseExt?.restoreContext();}catch{// Natural loss — restoration is the browser's call now.\n}},0);}});canvas.addEventListener(\"webglcontextrestored\",()=>{if(created.desired&&created.start){created.stopGen=created.start();}});canvasControllers.set(canvas,created);ctl=created;}const controller=ctl;controller.desired=true;controller.start=startGeneration;if(gl.isContextLost()){// A previous run on this canvas released the context (effect re-run, or\n// the router re-showing a kept-alive page). If the lost event already\n// dispatched this request is honored now; if it is still queued, the\n// lost handler above re-requests it on dispatch.\ntry{loseExt?.restoreContext();}catch{// No restore path — the orb stays blank rather than throwing.\n}}else{controller.stopGen=startGeneration();}return()=>{/*\n        Hide BEFORE tearing the context down.\n\n        This cleanup releases the context deliberately, and the lost event it\n        provokes is dispatched asynchronously — by which point the listener\n        below is unhooked and the replacement effect has not drawn yet. That\n        leaves a revealed canvas with a dead context, which is precisely what\n        the browser paints its broken-canvas placeholder over. The window is\n        not rare: any prop change in this effect's deps re-runs it, so it hits\n        every time the drawer switches preview example (maxDpr differs on the\n        layout one) or a wrapper is toggled.\n      */hideNow();canvas.removeEventListener(\"webglcontextlost\",onContextLostHide);window.removeEventListener(\"pagehide\",onPageHide);controller.desired=false;controller.start=null;controller.stopGen?.();controller.stopGen=null;/*\n        Release the context NOW instead of when the canvas is garbage\n        collected. Browsers cap live WebGL contexts per page (~8–16) and evict\n        the oldest when the cap is hit — client-side navigation that unmounts\n        and remounts a page of orbs otherwise piles up zombie contexts until\n        freshly mounted orbs get evicted and render blank.\n      */try{loseExt?.loseContext();}catch{// Context already lost — nothing to release.\n}};/*\n      `wrapped` is in here because turning a wrapper on or off moves the canvas\n      from being this component's root element to being a child of the wrapper\n      div — React drops the old element and mounts a new one, and the GL\n      context, its observers and its render loop all belong to the old one. Any\n      other prop leaves the element alone, INCLUDING a swap between two\n      wrappers: the canvas keeps its slot among the decoration layers, so\n      glass -> ring reuses the context instead of rebuilding it.\n    */},[variant,pauseOffscreen,maxDpr,wrapped]);const sizeStyle=size===undefined?{}:{width:size,height:size};/*\n    Spread ahead of the caller's `style`, so an orb that wants to own its own\n    opacity still can — it simply opts out of the reveal.\n\n    A hard flip, deliberately: no transition, no fade. A hidden document\n    (background tab, embedded preview) does not advance CSS transitions, so a\n    faded reveal left orbs pinned at zero in exactly the case the synchronous\n    first frame above exists to serve — mounted, healthy, and invisible. The\n    cut is not a pop either way, since it happens on the frame the orb first\n    has something to show.\n  */const revealStyle=painted?{}:{opacity:0};const canvas=/*#__PURE__*/_jsx(\"canvas\",{ref:canvasRef,className:spec?undefined:className,style:spec?{display:\"block\",position:\"absolute\",left:`${spec.inset}%`,top:`${spec.inset}%`,width:`${100-2*spec.inset}%`,height:`${100-2*spec.inset}%`,...revealStyle,...spec.mask?masked(spec.mask):{}}:{display:\"block\",...sizeStyle,...revealStyle,...style},role:!spec&&ariaLabel?\"img\":undefined,\"aria-label\":spec?undefined:ariaLabel,\"aria-hidden\":!spec&&ariaLabel?undefined:true},variant.key);if(!spec)return canvas;/*\n    Wrapped: the box becomes the orb's footprint and the canvas is absolutely\n    positioned inside it. `under`, the canvas and `over` are all positioned\n    with an auto z-index, so they paint in DOM order — decoration behind the\n    orb, then the orb, then decoration in front of it.\n\n    `aspectRatio` is the fallback for the sizeless case: `size` is optional\n    (callers may size the orb with a class instead), and an absolutely\n    positioned canvas contributes nothing to its parent's height, so without\n    it a class that only sets a width would collapse the box to zero.\n  */return /*#__PURE__*/_jsxs(\"div\",{className:className,style:{position:\"relative\",aspectRatio:\"1 / 1\",...spec.shadow?{borderRadius:\"50%\",boxShadow:spec.shadow}:{},...sizeStyle,...wrapperColor?{color:wrapperColor}:{},...style},role:ariaLabel?\"img\":undefined,\"aria-label\":ariaLabel,\"aria-hidden\":ariaLabel?undefined:true,children:[spec.animated?/*#__PURE__*/_jsx(\"style\",{...{href:WRAPPER_STYLE_HREF,precedence:\"default\"},dangerouslySetInnerHTML:{__html:WRAPPER_CSS}}):null,spec.under,canvas,spec.over]});}\nexport const __FramerMetadata__ = {\"exports\":{\"ShaderOrbProps\":{\"type\":\"tsType\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"OrbVariant\":{\"type\":\"tsType\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"OrbParamValues\":{\"type\":\"tsType\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"OrbWrapper\":{\"type\":\"tsType\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"ORB_STATES\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"OrbParamDef\":{\"type\":\"tsType\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"ShaderOrb\":{\"type\":\"reactComponent\",\"name\":\"ShaderOrb\",\"slots\":[],\"annotations\":{\"framerContractVersion\":\"1\"}},\"ORB_GLSL_HELPERS\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"OrbColorValues\":{\"type\":\"tsType\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"OrbState\":{\"type\":\"tsType\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"defaultValuesFor\":{\"type\":\"function\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"OrbColorDef\":{\"type\":\"tsType\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"ORB_WRAPPERS\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"hexToRgb\":{\"type\":\"function\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"__FramerMetadata__\":{\"type\":\"variable\"}}}\n//# sourceMappingURL=./orbkit_core.map","/* Orbkit SHDR-16 by zzzzshawn (MIT) — https://github.com/zzzzshawn/orbkit *//*\n * Deliberately not a `\"use client\"` module — see the note in `shdr-11.tsx`.\n *\n * Note for editors: the shader lives in a template literal, so its comments\n * must not contain backticks.\n *//* ----------------------------------------------------------------------------\n   SHDR-16 — sunlight through water: a caustic net crawling over the ball,\n   split into colour at its edges, surging with the agent's voice.\n\n   Not a port. Built from the README's own rule for surface detail — an\n   isoline through a warped field — pushed until it reads as the thing it\n   is imitating: the bright branching network a pool throws on its floor.\n\n   What it is:\n\n   - TWO FAMILIES OF LINES, CROSSED. 1 - abs(sin(q)) is one on a crest and\n     zero between, on each axis; raised to a power it is a thin line or a\n     broad wash, and the product of the two families is added back so the\n     crossings burn hotter than the lines. That product is what makes it\n     caustic rather than grid: real caustics are brightest where wavefronts\n     focus together, and the crossings are exactly those foci. The sum is\n     normalised to one at a crossing, on purpose: past the tone knee an\n     unbounded sum clips every channel and the sun colour goes white, so\n     gain would only ever buy you washout. Bounded, gold stays gold at the\n     hottest focus.\n   - THE WATER IS A FOLD. Before the lines are read, the plane is folded on\n     its own sines three times at rising frequency, each octave on its own\n     clock rate. That is refraction through a rippling surface, stated as a\n     domain warp: the grid does not scroll, it is bent, and the lines branch\n     and pinch where the bends pile up.\n   - CHROMATIC SPLIT ON TIME, NOT SPACE. The net is read three times, one\n     per channel, each at a slightly different moment of the fold. Where a\n     line is moving its three readings disagree; where it holds still they\n     agree. The light itself is the net's LUMINANCE under the sun colour,\n     and the disagreement is split off as a zero-mean residual added back\n     on its own amplitude — so the rainbow is a fringe on moving edges,\n     never a tint on the whole net, and the sun colour survives it. That is\n     how dispersion through water actually looks: white light, coloured\n     edges.\n   - THE SURGE is a round trip on an integrated clock through cos — it\n     eases through both ends and never wraps, the shdr-31 construction —\n     and it drives gain and ripple depth together, so the water brightens\n     as it deepens. Depth is one amplitude, so a state can have all of it,\n     none, or a flicker of it.\n\n   Design decisions, each one a rule in the README:\n\n   - THE ORB IS THE OBJECT. The net lives on the sphere's own surface\n     direction, not on a disc cut out of a plane. But the README's move for\n     flat fields — a stereographic projection of the dome — has a POLE, and\n     a ball that turns indefinitely carries whatever texture is behind it\n     through that pole, where the map stretches it toward infinity. The\n     aurora hid an atan seam by crossfading two wrappings; this uses\n     TRIPLANAR mapping instead, which has no seam and no pole: the plane\n     field is read on the three axis planes of the surface direction and\n     blended by how squarely each faces it. Three reads per channel, nine in\n     all — the field is a handful of sines, so it is cheap.\n   - EVERY INTERNAL FREQUENCY IS A LITERAL. The fold frequencies and the\n     per-octave clock rates are written into the shader, so the net's\n     spacing is ONE control — uP_scale — and it is the only spatial\n     frequency in the orb. It is never staged. Everything a state does\n     touch is an amplitude or an integrated clock, which is what lets all\n     three states cross-fade with nothing racing across the surface.\n   - pow() only ever sees a base in [0, 1] here — 1 - abs(sin) — so the\n     edge exponent is safe to sweep. The tone knee is applied after a max()\n     for the same reason.\n   - Surface-lit and mask-bounded, so alpha IS coverage: premultiplied\n     output, the opposite convention from the emissive orbs (see shdr-31).\n---------------------------------------------------------------------------- */const CAUSTIC_FRAG=`\n// Volume- and surge-reactive values, resolved once per fragment in main().\nfloat causticWarp;\n\n/*\n  The water. The plane is folded on its own sines three times, each octave\n  at a literal frequency and on its own share of the clock, so the ripples\n  refract the net rather than scroll it. Amplitude is the one control.\n*/\nvec2 fold(vec2 p, float t) {\n  p += causticWarp        * sin(p.yx * 1.31 + vec2( t * 0.90, -t * 0.70));\n  p += causticWarp * 0.60 * sin(p.yx * 2.17 + vec2(-t * 1.30,  t * 1.10));\n  p += causticWarp * 0.35 * sin(p.yx * 3.73 + vec2( t * 1.90,  t * 1.60));\n  return p;\n}\n\n/*\n  The light. Two crossed families of crest lines, sharpened by the edge\n  exponent — the base is 1 - abs(sin), always in [0, 1], so pow is defined —\n  with their product added back so the crossings, where wavefronts focus,\n  burn hotter than the lines between them.\n*/\nfloat net(vec2 p, float t) {\n  vec2 q = fold(p, t);\n  vec2 s = 1.0 - abs(sin(q));\n  vec2 l = pow(s, vec2(uP_edge));\n  // Normalised to [0, 1]: the sum peaks at four on a crossing, and left\n  // unbounded it drove the tone knee into clipping all three channels,\n  // which turns any sun colour white. Bounded, the sun colour survives\n  // the knee at the foci and gain is a real brightness rather than a\n  // race to white.\n  return (l.x + l.y + 2.0 * l.x * l.y) * 0.25;\n}\n\n/*\n  Triplanar: the plane field read on the three axis planes of the surface\n  direction and blended by the fourth power of each component, so each\n  plane only shows where it faces squarely. No pole and no seam — the ball\n  can turn forever.\n*/\nfloat netOn(vec3 sp, float t) {\n  vec3 w = sp * sp;\n  w *= w;\n  w /= (w.x + w.y + w.z);\n  float k = uP_scale;\n  return w.x * net(sp.yz * k, t) + w.y * net(sp.zx * k, t) + w.z * net(sp.xy * k, t);\n}\n\nvoid main() {\n  vec2 uv = orbUV();\n  float rd = length(uv);\n  float R = uP_radius;\n  float mask = smoothstep(0.012, -0.012, rd - R);\n  if (mask <= 0.0) {\n    gl_FragColor = vec4(0.0);\n    return;\n  }\n\n  vec2 pl = uv / R;\n  float z = sqrt(max(1.0 - dot(pl, pl), 0.0));\n  vec3 n = vec3(pl, z);\n\n  // the ball turns about Y on its own integrated clock\n  float cr = cos(uP_spin);\n  float sr = sin(uP_spin);\n  vec3 sp = vec3(n.x * cr - n.z * sr, n.y, n.x * sr + n.z * cr);\n\n  float t = uP_flow; // integrated clock: the water\n\n  /*\n    The surge: a round trip on an integrated clock through cos, so it eases\n    through both ends and never wraps. It lifts the gain and deepens the\n    ripple together — brighter as the water heaves — and uP_swell is how\n    much of that a state takes.\n\n    Volume coupling in the family language: the agent's voice brightens the\n    light, the user's deepens the water.\n  */\n  float surge = 0.5 - 0.5 * cos(uP_swellRate);\n  float gainNow = uP_gain * mix(1.0, 0.55 + 0.9 * surge, uP_swell) * (0.8 + 0.5 * uOutput);\n  causticWarp = uP_warp * mix(1.0, 0.8 + 0.4 * surge, uP_swell) * (1.0 + 0.35 * uInput);\n\n  /*\n    Three moments of the fold, one per channel. The LIGHT is the net's\n    luminance under the sun colour, so gold is gold at the foci; the\n    per-channel disagreement is split off as a zero-mean residual and added\n    back scaled by uP_split, so the rainbow is a fringe that rides on the\n    edges where they move and vanishes where they hold — never a tint on\n    the whole net. Read once with the offset baked in and once without\n    would cost the same three evaluations, so the offset is constant and\n    the split is a plain amplitude on the residual: safe to stage.\n  */\n  float ds = 0.09;\n  vec3 c = vec3(netOn(sp, t + ds), netOn(sp, t), netOn(sp, t - ds));\n  float cLum = dot(c, vec3(1.0 / 3.0));\n  vec3 fringe = (c - cLum) * uP_split;\n\n  float lambert = clamp(dot(n, normalize(vec3(-0.45, 0.55, 0.7))), 0.0, 1.0);\n  float fres = pow(1.0 - z, 2.5);\n\n  // the floor of the pool, then the light thrown on it — dimmer round the\n  // limb, where the floor tilts away from the sun\n  vec3 col = uC_deep * (0.35 + 0.65 * uP_light * lambert);\n  col += (uC_sun * cLum + fringe) * gainNow * (0.55 + 0.45 * lambert);\n  col += uC_sheen * uP_rim * fres;\n\n  col = pow(max(col, vec3(0.0)), vec3(uP_contrast));\n  col = tanh3(col);\n\n  // Surface orb bounded by a mask: alpha IS coverage, so premultiply — the\n  // opposite convention from the emissive orbs (see shdr-31).\n  float a = mask;\n  gl_FragColor = vec4(max(col, vec3(0.0)) * a, a);\n}\n`;export const shdr16Orb={key:\"shdr-16\",label:\"SHDR-16\",note:\"sunlight through water — a caustic net crawling over the ball, fringing into colour where it moves\",frag:CAUSTIC_FRAG,params:[{key:\"flow\",label:\"Water flow\",min:.015,max:10,step:.05,default:.9,integrate:true},{key:\"spin\",label:\"Turn\",min:0,max:5,step:.03,default:.08,integrate:true},{key:\"swellRate\",label:\"Surge rate\",min:0,max:8,step:.05,default:.6,integrate:true},{key:\"radius\",label:\"Radius\",min:.15,max:3,step:.015,default:.9},{key:\"scale\",label:\"Net scale\",min:3,max:30,step:.1,default:9},{key:\"warp\",label:\"Ripple depth\",min:0,max:3,step:.02,default:.8},{key:\"edge\",label:\"Line sharpness\",min:.5,max:10,step:.05,default:2.2},{key:\"split\",label:\"Colour fringe\",min:0,max:3,step:.02,default:.6},{key:\"swell\",label:\"Surge depth\",min:0,max:1,step:.01,default:.15},{key:\"gain\",label:\"Sun power\",min:.05,max:6,step:.05,default:1.6},{key:\"contrast\",label:\"Tone knee\",min:.15,max:6,step:.05,default:1.1},{key:\"light\",label:\"Floor light\",min:0,max:3,step:.015,default:.9},{key:\"rim\",label:\"Rim sheen\",min:0,max:3,step:.015,default:.6}],// the pool floor, the light thrown on it, and the wet gloss at the limb\ncolors:[{key:\"deep\",label:\"Water\",default:\"#0b2f6e\"},{key:\"sun\",label:\"Caustic light\",default:\"#7ff6ff\"},{key:\"sheen\",label:\"Sheen\",default:\"#bfe8ff\"}],/*\n    Staged on the three integrated clocks and on amplitudes only — nothing\n    a state touches is a spatial frequency, so every transition cross-fades\n    with nothing racing across the surface. NET SCALE is the one frequency\n    in the orb and it is never staged: it multiplies the surface direction\n    before the fold, so gliding it would sweep the whole net through every\n    spacing in between. Line sharpness is a power exponent on a base in\n    [0, 1], an amplitude, and safe at any span.\n\n    The read is in the water:\n\n      idle     a slow pool, lit HARD. Gentle ripple, moderate lines, the\n               faintest surge, the ball barely turning — but the sun at\n               full power on a firmer knee, so the caustics burn white\n               over dark red water.\n      thinking NERVOUS water. The flow runs at three and a half times\n               resting on a ripple nearly double rest's, and the lines\n               go broad under it — a coarse, fast, restless net. The\n               surge is shallow but quick, a flicker rather than a heave,\n               and the ball all but freezes so the motion is in the\n               light. The sun is dropped to half rest's power with the\n               key light and rim pulled down: white on a darker red,\n               dimmer than rest.\n      speaking the water HEAVES, fast. Full surge depth on a rate five\n               times rest's, so the light pumps in quick breaths, on the\n               deepest ripple and the broadest lines — sheets of light\n               rather than threads — with the colour split wide so every\n               edge fringes, and the ball plainly turning beneath it. The\n               rim is all but cut so the light is the sun alone. Warm:\n               gold on brick red.\n  */statePresets:{idle:{flow:.92,spin:.09,swellRate:.6,warp:.8,edge:3,split:.6,swell:.15,gain:6,contrast:1.3,light:.9,rim:.6},thinking:{flow:3.22,spin:.03,swellRate:2.4,warp:1.52,edge:2.8,split:.36,swell:.26,gain:3.35,contrast:1.15,light:.525,rim:.21},speaking:{flow:1.8,spin:.7,swellRate:5.4,warp:1.7,edge:1.7,split:1.1,swell:1,gain:3.6,contrast:.85,light:.96,rim:.18}},// aqua light on dark red water at rest, pure white on a darker red while\n// searching, gold on brick-red water while answering\nstateColors:{idle:{deep:\"#6f0b0b\",sun:\"#7ff6ff\",sheen:\"#bfe8ff\"},thinking:{deep:\"#3a0808\",sun:\"#ffffff\",sheen:\"#ffffff\"},speaking:{deep:\"#8d2525\",sun:\"#ffb914\",sheen:\"#ffb3c6\"}}};\nexport const __FramerMetadata__ = {\"exports\":{\"shdr16Orb\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"__FramerMetadata__\":{\"type\":\"variable\"}}}\n//# sourceMappingURL=./orbkit_shdr16.map","/* Orbkit SHDR-17 by zzzzshawn (MIT) — https://github.com/zzzzshawn/orbkit *//*\n * Deliberately not a `\"use client\"` module — see the note in `shdr-11.tsx`.\n *\n * Note for editors: the shader lives in a template literal, so its comments\n * must not contain backticks.\n *//* ----------------------------------------------------------------------------\n   SHDR-17 — a grainy, hyper-saturated storm raging on the ball.\n\n   The weather is the classic two-level DOMAIN WARP: the storm field is fbm\n   sampled where a previous fbm said to look, so the clouds tear and curl\n   instead of just scrolling. It lives on a stereographic wrap of a rotating\n   dome, with JOVIAN BAND SHEAR on top — latitude rings flowing past each\n   other at different speeds, banded like a gas giant, because sp.y is\n   invariant under the dome's Y-roll the bands stay horizontal while the\n   weather rolls beneath them.\n\n   Colour is where it goes loud: a four-stop gradient (deep → low → mid → hot)\n   climbs the storm field, and an iridescent cosine rainbow keyed to the same\n   field is multiplied over it, so every pressure level of the storm carries\n   its own hue and the whole ball cycles through many colours at once.\n\n   The GRAIN is the signature. Two taps of animated white noise, refreshed on\n   the ambient clock at about 24 fps — cinema rate: fast enough to read as\n   film flicker rather than stutter, and deliberately NOT the integrated\n   clock, because the flicker rate should not follow the agent state:\n\n     FIELD GRAIN  folded into the storm field BEFORE the gradient, so the\n                  colour stops dither into speckle instead of smooth bands —\n                  the risograph read.\n     FILM GRAIN   multiplied over the final colour, plain photographic noise.\n\n   Lightning: a hashed gate per flash interval with an exponential decay —\n   most intervals stay dark, some flash — and the gate opens wide with agent\n   output, so a speaking orb strobes its high-pressure cells.\n\n   Surface-lit and mask-bounded, so alpha IS coverage — premultiplied output,\n   as in shdr-14.\n---------------------------------------------------------------------------- */const TEMPEST_FRAG=`\nconst float PI = 3.14159265359;\n\n// Animated white noise, one tap per grain cell per grain frame. The seed\n// decorrelates the two taps so field grain and film grain never line up.\nfloat grainNoise(vec2 gpix, float frame, float seed) {\n  return hash(gpix + vec2(frame * 13.71 + seed, frame * 7.37 - seed));\n}\n\nvoid main() {\n  // Volume coupling: user input churns the warp harder, agent output\n  // brightens the field — the lightning gate opens separately below.\n  float warpNow = uP_warp * (1.0 + 0.55 * uInput);\n  float gainNow = uP_gain * (0.85 + 0.45 * uOutput);\n\n  vec2 uv = orbUV();\n  float rd = length(uv);\n  float R = uP_radius;\n  float mask = smoothstep(0.012, -0.012, rd - R);\n\n  // The storm below costs five fbm evaluations per fragment — skip all of it\n  // outside the silhouette instead of computing weather for transparent sky.\n  if (mask <= 0.0) {\n    gl_FragColor = vec4(0.0);\n    return;\n  }\n\n  vec2 pl = uv / R;\n  float r2 = dot(pl, pl);\n  float z = sqrt(max(1.0 - r2, 0.0));\n  vec3 n = vec3(pl, z);\n\n  // roll the dome about Y on its own integrated clock\n  float cr = cos(uP_spin);\n  float sr = sin(uP_spin);\n  vec3 sp = vec3(n.x * cr - n.z * sr, n.y, n.x * sr + n.z * cr);\n\n  float t = uP_speed; // integrated clock\n\n  // stereographic wrap: the weather travels around the ball and compresses\n  // toward the limb instead of sliding across a flat disc\n  vec2 st = sp.xy / (1.3 + sp.z) * uP_scale;\n\n  /*\n    Jovian band flow: a uniform stream plus a BOUNDED traveling wave of\n    shear, so latitude rings appear to slip past each other. The obvious\n    construction — t * sin(latitude) — accumulates the differential forever\n    and rakes the field into hairline streaks within seconds of the random\n    mount phase; the wave form keeps the shear amplitude fixed while its\n    phase travels. sp.y is untouched by the Y-roll, so the bands hold\n    horizontal while the dome turns underneath them.\n  */\n  st.x -= t * 0.3;\n  st.x += uP_shear * sin(sp.y * uP_bands - t * 0.45);\n\n  // two-level domain warp, the storm-cloud construction: q says where to\n  // look, w says where q said to look, the field reads there\n  vec2 q = vec2(\n    fbm(st + vec2(0.0, t * 0.35)),\n    fbm(st + vec2(5.2, 1.3) - vec2(t * 0.28, 0.0))\n  );\n  vec2 w = vec2(\n    fbm(st + warpNow * q + vec2(1.7, 9.2) + vec2(t * 0.12, 0.0)),\n    fbm(st + warpNow * q + vec2(8.3, 2.8) - vec2(0.0, t * 0.1))\n  );\n  float f = fbm(st + uP_churn * w);\n\n  /*\n    Grain tap 1: speckle folded into the FIELD itself, before the gradient,\n    so the colour stops below dither into grain instead of smooth bands.\n    Refreshed on the ambient clock — the flicker rate stays constant across\n    states on purpose (see the header note).\n  */\n  vec2 gpix = floor(gl_FragCoord.xy / max(uP_grainSize, 1.0));\n  float frame = floor(uTime * 48.0);\n  float g1 = grainNoise(gpix, frame, 3.1);\n  f += (g1 - 0.5) * uP_grain;\n\n  f = pow(clamp(f * gainNow, 0.0, 1.0), uP_contrast);\n\n  // four-stop palette climbing the storm field\n  vec3 col = mix(uC_deep, uC_low, smoothstep(0.05, 0.35, f));\n  col = mix(col, uC_mid, smoothstep(0.35, 0.62, f));\n  col = mix(col, uC_hot, smoothstep(0.62, 0.88, f));\n\n  // iridescent shimmer: a cosine rainbow keyed to the field AND to the warp\n  // vector — q varies at storm-cell scale, so the rainbow lands as coherent\n  // coloured weather cells instead of hue noise that optically averages to\n  // grey — multiplied in so it bends hues without erasing the palette\n  vec3 shimmer = 0.5 + 0.5 * cos(2.0 * PI * (f * 0.9 + q.x * 1.1 + t * 0.06 + vec3(0.0, 0.33, 0.67)));\n  col = mix(col, col * (0.35 + 1.9 * shimmer), uP_rainbow);\n\n  /*\n    Lightning: one hashed gate per flash interval with an exponential decay,\n    so most intervals stay dark and some strike. Agent output opens the gate\n    — an idle orb flickers occasionally, a speaking one strobes. The strike\n    lands hardest on the high-pressure cells of the field.\n  */\n  float ft = t * uP_flashRate;\n  float gate = step(1.0 - (0.1 + 0.5 * uOutput), hash(vec2(floor(ft), 7.7)));\n  float flashEnv = gate * exp(-fract(ft) * 6.0);\n  // squared so the strike stays inside the storm cells — a linear weight\n  // tints the whole ball and reads as the canvas strobing, not as weather\n  float high = smoothstep(0.55, 0.95, f);\n  col += uC_flash * (flashEnv * uP_flash) * (0.06 + 0.94 * high * high);\n\n  // dome shading keeps the ball a ball under the weather\n  float lambert = clamp(dot(n, normalize(vec3(-0.45, 0.55, 0.7))), 0.0, 1.0);\n  col *= 0.35 + uP_light * lambert;\n  float fres = pow(1.0 - z, 2.5);\n  col += uC_flash * uP_rim * fres * (0.4 + 0.35 * flashEnv);\n\n  // grain tap 2: plain film grain over the final colour\n  float g2 = grainNoise(gpix, frame, 27.9);\n  col *= 1.0 + (g2 - 0.5) * uP_filmGrain;\n\n  // Surface orb bounded by a mask: alpha IS coverage, so premultiply — the\n  // opposite convention from the emissive orbs (see shdr-31).\n  float a = mask;\n  gl_FragColor = vec4(max(col, vec3(0.0)) * a, a);\n}\n`;export const shdr17Orb={key:\"shdr-17\",label:\"SHDR-17\",note:\"a grainy many-coloured storm with band shear and lightning\",frag:TEMPEST_FRAG,params:[{key:\"speed\",label:\"Storm speed\",min:.015,max:10,step:.05,default:.9,integrate:true},{key:\"spin\",label:\"Roll\",min:0,max:5,step:.03,default:.12,integrate:true},{key:\"radius\",label:\"Radius\",min:.15,max:3,step:.015,default:.9},{key:\"scale\",label:\"Weather scale\",min:.3,max:12,step:.1,default:2.4},{key:\"bands\",label:\"Band count\",min:0,max:20,step:.1,default:6},{key:\"shear\",label:\"Band shear\",min:0,max:5,step:.03,default:1.1},{key:\"warp\",label:\"Warp\",min:0,max:8,step:.05,default:2.2},{key:\"churn\",label:\"Churn\",min:0,max:8,step:.05,default:1.4},{key:\"gain\",label:\"Brightness\",min:.05,max:5,step:.05,default:1.15},{key:\"contrast\",label:\"Contrast\",min:.15,max:10,step:.05,default:1.35},{key:\"grain\",label:\"Field grain\",min:0,max:2,step:.01,default:.4},{key:\"filmGrain\",label:\"Film grain\",min:0,max:2,step:.01,default:.35},{key:\"grainSize\",label:\"Grain size\",min:1,max:8,step:1,default:2},{key:\"rainbow\",label:\"Iridescence\",min:0,max:2,step:.01,default:.65},{key:\"flashRate\",label:\"Flash rate\",min:0,max:10,step:.05,default:1.6},{key:\"flash\",label:\"Flash power\",min:0,max:5,step:.03,default:1.2},{key:\"light\",label:\"Key light\",min:0,max:3,step:.015,default:.85},{key:\"rim\",label:\"Rim light\",min:0,max:3,step:.015,default:.5}],/*\n   * Five stops: four climbing the storm field plus the lightning colour.\n   * The iridescence param multiplies a rainbow over all of them, so the\n   * palette here sets the mood and the shimmer supplies the extra hues.\n   */colors:[{key:\"deep\",label:\"Deep\",default:\"#2a0f4e\"},{key:\"low\",label:\"Low pressure\",default:\"#0fd0c3\"},{key:\"mid\",label:\"Mid pressure\",default:\"#ff5e9d\"},{key:\"hot\",label:\"High pressure\",default:\"#ffd166\"},{key:\"flash\",label:\"Lightning\",default:\"#eaf4ff\"}],/*\n    Staged in the family language. Grain and grain size never move between\n    states — grain is a quantizer, and a gliding quantizer pops instead of\n    fading (same rule as the dither orb's cell grid).\n  */statePresets:{// brooding: bands drifting, the odd distant flicker\nidle:{speed:.9,shear:1.1,warp:2.2,churn:1.4,flash:.7,gain:1.15,contrast:1.35},// computing: the storm churns IN PLACE — clock at twice idle, deeper\n// warp, bands almost stalled, lightning held back\nthinking:{speed:2.2,shear:.6,warp:3.4,churn:2.1,flash:.6,gain:1.05,contrast:1.5},// answering: bands race, the field blooms bright, lightning strobes\nspeaking:{speed:1.6,shear:2.2,warp:2.6,churn:1.6,flash:2.6,gain:1.45,contrast:1.2}},// teal-magenta-amber carnival at rest, cold indigo-cyan while computing,\n// hot magma while answering\nstateColors:{idle:{deep:\"#2a0f4e\",low:\"#0fd0c3\",mid:\"#ff5e9d\",hot:\"#ffd166\",flash:\"#eaf4ff\"},thinking:{deep:\"#0d1440\",low:\"#4c4cf0\",mid:\"#9d4ce0\",hot:\"#4ce0ff\",flash:\"#d5e5ff\"},speaking:{deep:\"#3a0f1e\",low:\"#ff6a3d\",mid:\"#ff2e88\",hot:\"#ffd23f\",flash:\"#fff3e0\"}}};\nexport const __FramerMetadata__ = {\"exports\":{\"shdr17Orb\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"__FramerMetadata__\":{\"type\":\"variable\"}}}\n//# sourceMappingURL=./orbkit_shdr17.map","/* Orbkit SHDR-13 by zzzzshawn (MIT) — https://github.com/zzzzshawn/orbkit *//*\n * Deliberately not a `\"use client\"` module — see the note in `shdr-11.tsx`.\n *\n * Note for editors: the shader lives in a template literal, so its comments\n * must not contain backticks.\n *//* ----------------------------------------------------------------------------\n   SHDR-13 — a plasma globe: crawling lightning filaments inside a glass ball.\n\n   The reference is the physical object: a tesla ball with a hot nucleus,\n   pink-to-violet streamers writhing out to the glass, and bright flares\n   where a filament touches the shell.\n\n   How the filaments are built, and why they behave like the real thing:\n\n   - A curve in 3D is the intersection of two level surfaces. Two independent\n     trig fields are evaluated on the DIRECTION of each march point\n     (q = dir * fils, |dir| = 1), so their joint zero set is a set of\n     directions — extruded radially, those are filaments running from the\n     nucleus to the glass, never a floating blob. Filament count rides the\n     angular frequency uP_fils, so a state preset can literally grow more\n     streamers, and because the field morphs smoothly the new ones split off\n     from existing ones instead of popping in.\n   - Each field carries its own additive time phases, so the zero curves\n     drift, merge, and reconnect — the crawl of a real streamer hunting\n     across the glass. The whole array also precesses on an integrated spin\n     clock.\n   - A radial writhe term bends the direction before sampling, gated by\n     smoothstep from the centre so every filament stays ROOTED at the\n     nucleus while its far end wanders on the shell.\n   - Proximity to the curve is measured in field space (f1^2 + f2^2), and\n     brightness is its inverse — the same 1/d accumulation as the other\n     volumetric orbs, so thickness varies naturally along a filament with\n     the field gradient.\n   - The march is bounded to the exact ray/sphere chord (entry to exit), and\n     each step is weighted by its true length, so limb rays integrate short\n     chords and dim correctly; the tip flare (a smoothstep in r near the\n     shell) is what lights the glass from inside where streamers land.\n   - Colour is a radial mix: the inner colour near the nucleus, the arc\n     colour toward the glass, cores whitened by their own intensity — the\n     pink-core / violet-tip gradient of a real discharge.\n\n   House rules followed from the other orbs: per-step clamp before the\n   spikes own the frame, front-to-back transmittance, tanh tone map with an\n   exposure knee, alpha from the brightest channel, and the analytic\n   silhouette cut from each ray's closest approach — colour AND alpha.\n---------------------------------------------------------------------------- *//*\n * Step count is a `#define`: ES 1.0 requires constant loop bounds.\n */const ION_FRAG=`\n#define STEPS 64\n\n// Volume-reactive values, resolved once per fragment in main().\nfloat ionSharp;\nfloat ionWrithe;\nfloat ionCore;\nfloat ionExposure;\nfloat ionRadius;\n\nmat2 ionRot2(float a) {\n  float c = cos(a);\n  float s = sin(a);\n  return mat2(c, -s, s, c);\n}\n\nvec3 ionRender(vec2 fragCoord) {\n  float t = uP_speed;      // integrated clock: filament crawl\n  float spinAng = uP_spin; // integrated clock: array precession\n\n  vec2 uv = (2.0 * fragCoord - uRes) / min(uRes.x, uRes.y);\n  vec3 ro = vec3(0.0, 0.0, uP_camDist);\n  vec3 rd = normalize(vec3(uv, -uP_focal));\n\n  // exact ray/sphere chord — the march never leaves the globe, so no\n  // envelope fade is needed and every step length is meaningful\n  float proj = dot(-ro, rd);\n  float b2 = dot(ro, ro) - proj * proj;\n  float half_ = sqrt(max(ionRadius * ionRadius - b2, 0.0));\n  float zNear = proj - half_;\n  float stepLen = 2.0 * half_ / float(STEPS);\n  // per-pixel jitter of the march start: a filament grazed at a shallow\n  // angle is crossed periodically by the fixed step grid and renders as a\n  // dotted chain — the jitter decorrelates neighbouring rays and melts the\n  // dots into plasma grain\n  zNear += (hash(fragCoord) - 0.5) * stepLen;\n\n  vec3 acc = vec3(0.0);\n  float T = 1.0;\n\n  for (int i = 0; i < STEPS; i++) {\n    vec3 p = ro + rd * (zNear + (float(i) + 0.5) * stepLen);\n\n    // precess the whole filament array; a static tilt keeps the spin axis\n    // off-vertical so the motion reads in 3D\n    vec3 pr = p;\n    pr.xz = ionRot2(spinAng) * pr.xz;\n    pr.yz = ionRot2(uP_tilt) * pr.yz;\n\n    float r = length(pr);\n    vec3 dir = pr / max(r, 1e-4);\n    float rr = r / max(ionRadius, 1e-3);\n\n    // writhe: bend the sampling direction with radius and time, rooted at\n    // the nucleus by the smoothstep so filaments stay attached\n    float wr = ionWrithe * smoothstep(0.0, ionRadius * 0.35, r);\n    vec3 q = dir * uP_fils;\n    q += wr * vec3(\n      sin(r * uP_writheFreq        - t * 1.2 + q.y * 1.8),\n      sin(r * uP_writheFreq * 0.83 + t * 1.0 + q.z * 1.8),\n      sin(r * uP_writheFreq * 1.19 - t * 0.7 + q.x * 1.8));\n\n    // two independent fields over the direction sphere; their joint zero\n    // set is the filament curves. Time enters as additive phase only.\n    float f1 = sin(q.x + t * 0.70)\n             + sin(q.y * 1.31 - t * 0.50)\n             + sin(q.z * 1.13 + t * 0.90);\n    float f2 = sin(q.y * 1.21 + t * 0.60 + 1.7)\n             + sin(q.z * 1.43 - t * 0.80 + 3.1)\n             + sin(q.x * 0.87 + t * 0.40 + 5.0);\n    float d2 = f1 * f1 + f2 * f2;\n    float g = 1.0 / (d2 * ionSharp + uP_soft);\n\n    // flare where a streamer lands on the glass, and the hot nucleus\n    g *= 1.0 + uP_tipGain * smoothstep(0.55, 0.95, rr);\n    float core = ionCore / (r * r * 8.0 + 0.05);\n\n    // pink near the nucleus, violet-blue at the glass, cores whitened by\n    // their own intensity\n    vec3 fCol = mix(uC_inner, uC_arc, smoothstep(0.1, 0.75, rr));\n    vec3 w = (fCol + vec3(uP_whiten) * g) * g + uC_inner * core + vec3(uP_fill);\n    w = min(w, vec3(uP_stepClamp));\n    w *= stepLen; // length-fair: limb chords are short and dim correctly\n\n    acc += T * w;\n    T *= exp(-dot(w, vec3(0.299, 0.587, 0.114)) * uP_scatter);\n    if (T < 0.004) break;\n  }\n\n  return acc;\n}\n\nvoid main() {\n  // Louder agent output softens and thickens the arcs and quickens the\n  // writhe; user input flares the nucleus — the globe answers being spoken\n  // to the way the real toy answers a fingertip.\n  ionSharp = uP_sharp * (1.0 - 0.25 * uOutput);\n  ionWrithe = uP_writhe * (1.0 + 0.6 * uOutput);\n  ionCore = uP_coreGain * (1.0 + 1.6 * uInput + 0.4 * uOutput);\n  ionExposure = uP_exposure * (1.0 - 0.35 * uOutput);\n  ionRadius = uP_envRadius + uP_swell * uInput;\n\n  vec3 acc = ionRender(gl_FragCoord.xy);\n\n  // tanh tone map with a tunable knee, then the usual finishing chain\n  vec3 col = tanh3(acc / max(ionExposure, 0.01));\n  col = pow(clamp(col, 0.0, 1.0), vec3(uP_contrast));\n\n  float lum = dot(col, vec3(0.299, 0.587, 0.114));\n  col = mix(vec3(lum), col, uP_saturation);\n  col *= uC_tint;\n\n  // alpha from the brightest channel — a saturated violet streamer has low\n  // luminance but must not go transparent\n  float peak = max(col.r, max(col.g, col.b));\n  float a = clamp(peak * uP_alphaGain, 0.0, 1.0);\n\n  // analytic silhouette, identical construction to shdr-01: exact\n  // ray-to-centre distance against the radius, colour AND alpha\n  vec3 mrd = normalize(vec3(orbUV(), -uP_focal));\n  float closest = length(cross(vec3(0.0, 0.0, uP_camDist), mrd));\n  float band = mix(0.35, 0.012, clamp(uP_edge, 0.0, 1.0));\n  float mask = 1.0 - smoothstep(ionRadius * (1.0 - band), ionRadius * 1.005, closest);\n  col *= mask;\n  a *= mask;\n\n  // Emitted light, so rgb is already premultiplied — do NOT scale by alpha\n  // again (see the same note in shdr-31).\n  gl_FragColor = vec4(col, a);\n}\n`;export const shdr13Orb={key:\"shdr-13\",label:\"SHDR-13\",note:\"plasma globe: crawling lightning filaments\",frag:ION_FRAG,params:[{key:\"speed\",label:\"Anim speed\",min:.015,max:10,step:.05,default:1,integrate:true},{key:\"spin\",label:\"Spin rate\",min:0,max:5,step:.03,default:.2,integrate:true},{key:\"camDist\",label:\"Camera distance\",min:1,max:50,step:.3,default:7},{key:\"focal\",label:\"Lens\",min:.15,max:15,step:.1,default:2.25},{key:\"envRadius\",label:\"Globe radius\",min:.15,max:15,step:.1,default:2.6},{key:\"swell\",label:\"Input swell\",min:0,max:1,step:.01,default:.15},{key:\"tilt\",label:\"Axis tilt\",min:0,max:4,step:.02,default:.4},{key:\"fils\",label:\"Filament density\",min:.5,max:12,step:.1,default:6},{key:\"writhe\",label:\"Writhe\",min:0,max:3,step:.02,default:.9},{key:\"writheFreq\",label:\"Writhe frequency\",min:.2,max:8,step:.05,default:1.6},{key:\"sharp\",label:\"Arc sharpness\",min:.5,max:60,step:.5,default:4},{key:\"soft\",label:\"Arc core softness\",min:.002,max:.5,step:.002,default:.06},{key:\"whiten\",label:\"Core whitening\",min:0,max:.2,step:.002,default:.008},{key:\"coreGain\",label:\"Nucleus glow\",min:0,max:5,step:.05,default:1.6},{key:\"tipGain\",label:\"Glass flare\",min:0,max:6,step:.05,default:1.8},{key:\"fill\",label:\"Body haze\",min:0,max:2,step:.01,default:.02},{key:\"stepClamp\",label:\"Step clamp\",min:.3,max:300,step:1.5,default:40},{key:\"scatter\",label:\"Diffusion\",min:0,max:.5,step:.003,default:.012},{key:\"exposure\",label:\"Exposure\",min:.1,max:200,step:.5,default:11},{key:\"contrast\",label:\"Contrast\",min:.15,max:15,step:.1,default:1},{key:\"saturation\",label:\"Saturation\",min:0,max:4,step:.02,default:1.2},{key:\"alphaGain\",label:\"Alpha gain\",min:.05,max:15,step:.1,default:2.5},{key:\"edge\",label:\"Edge sharpness\",min:0,max:1,step:.01,default:1}],colors:[{key:\"inner\",label:\"Nucleus\",default:\"#ff70d8\"},{key:\"arc\",label:\"Arc\",default:\"#5a5cff\"},{key:\"tint\",label:\"Tint\",default:\"#ffffff\"}],statePresets:{// a full globe of swooping arcs around a hot nucleus\nidle:{speed:1,spin:.2,fils:6,writhe:.9,sharp:4,soft:.06,whiten:.008,tipGain:1.8,coreGain:1.6,exposure:11},// hunting: even more filaments, softer and more nebular, restless writhe\nthinking:{speed:1.8,spin:.45,fils:7,writhe:1.2,sharp:3,soft:.08,whiten:.012,tipGain:1.5,coreGain:1.2,exposure:10},// discharge: the densest, brightest state — spiky arcs flaring hard on\n// the glass around a blazing core\nspeaking:{speed:2.6,spin:.3,fils:8,writhe:1.3,sharp:3.5,soft:.05,whiten:.012,tipGain:2.4,coreGain:2,exposure:8.5}}};\nexport const __FramerMetadata__ = {\"exports\":{\"shdr13Orb\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"__FramerMetadata__\":{\"type\":\"variable\"}}}\n//# sourceMappingURL=./orbkit_shdr13.map","/* Orbkit SHDR-21 by zzzzshawn (MIT) — https://github.com/zzzzshawn/orbkit *//*\n * Deliberately not a `\"use client\"` module — see the note in `shdr-11.tsx`.\n *\n * Note for editors: the shader lives in a template literal, so its comments\n * must not contain backticks.\n *//* ----------------------------------------------------------------------------\n   SHDR-21 — light diffusing through a cloud.\n\n   A real volumetric integration rather than a surface. The march walks a\n   density field bounded by a sphere and, at every step, does three things:\n\n     TRANSMITTANCE  how much of the background still gets through, tracked as\n                    T *= exp(-density * dt * absorb). Beer-Lambert.\n     SHADOW         a short second march toward the light, so the far side of a\n                    dense clump is dimmer than the lit side. This is the whole\n                    reason the orb reads as volume and not as a flat glow.\n     IN-SCATTER     light added at this step, weighted by density, by the shadow\n                    term, and by a Henyey-Greenstein phase function.\n\n   The phase function is what makes it feel like light rather than paint. It\n   biases scattering forward, so the limb facing the light blooms and the rest\n   stays soft — the same reason a cloud is blinding when you look toward the sun\n   through it and merely bright otherwise.\n\n   Alpha is 1 - T, which is exactly what the volume occludes, so this one needs\n   no radial fade to hide the canvas edge: density falls to zero at the sphere\n   boundary and the alpha goes with it.\n---------------------------------------------------------------------------- *//*\n * Step counts are `#define`s: ES 1.0 requires constant loop bounds. The march\n * is STEPS * (1 + LIGHT_STEPS) density evaluations, so LIGHT_STEPS is the\n * expensive knob — 4 is enough for readable self-shadowing.\n */const NIMBUS_FRAG=`\n#define STEPS 56\n#define LIGHT_STEPS 4\n#define DENSITY_OCT 4\n#define AA 1\n\nconst float PI = 3.14159265359;\n\n// Volume-reactive values, resolved once per fragment in main().\nfloat nimbusPower;\nfloat nimbusDensity;\n\n/*\n  Density inside the sphere.\n\n  The radial term falls to zero at the boundary, which both bounds the volume\n  and gives the soft edge for free. The cos-warp folds the sample point a few\n  times — the same cheap turbulence the other orbs use — and the threshold\n  carves that into clumps rather than an even fog.\n*/\nfloat density(vec3 p, float animTime) {\n  float shell = 1.0 - length(p) / uP_radius;\n  if (shell <= 0.0) return 0.0;\n\n  vec3 q = p * uP_scale;\n  float f = 1.0;\n  for (int k = 0; k < DENSITY_OCT; k++) {\n    q += cos(q.yzx * f + animTime * uP_churn) / f;\n    f *= 1.8;\n  }\n\n  float n = (sin(q.x) + sin(q.y) + sin(q.z)) / 3.0 * 0.5 + 0.5;\n  // smoothstep against the threshold is the clump control: high threshold\n  // leaves sparse wisps, low fills the sphere with even fog\n  float clump = smoothstep(uP_threshold, 1.0, n);\n  return clump * pow(shell, uP_edgeSoft) * nimbusDensity;\n}\n\n/*\n  Henyey-Greenstein: g > 0 biases scattering forward, which is what gives the\n  bloom on the limb facing the light.\n\n  The physical form carries a 1/(4*PI) normalisation. It is dropped here and\n  folded into uP_power instead — kept in, the whole term sits around 0.02 and\n  the orb renders black unless power is pushed into the hundreds, which makes\n  the slider useless.\n*/\nfloat phaseHG(float c, float g) {\n  float g2 = g * g;\n  return (1.0 - g2) / pow(max(1.0 + g2 - 2.0 * g * c, 0.0001), 1.5);\n}\n\nvec4 nimbusRender(vec2 fragCoord) {\n  float animTime = uP_speed; // integrated clock\n\n  vec2 uv = (2.0 * fragCoord - uRes) / min(uRes.x, uRes.y);\n  vec3 ro = vec3(0.0, 0.0, -uP_camDist);\n  vec3 rd = normalize(vec3(uv, uP_focal));\n\n  /*\n    Light direction, slowly orbiting so the shading is never static.\n\n    The z term is kept POSITIVE — the camera looks along +z, so a light also\n    pointing along +z sits behind the cloud. That is the back-lit case, where\n    dot(rd, L) approaches 1 and the forward-scattering phase blooms. Put the\n    light on the camera's side instead and every ray samples the phase function\n    on its back-scatter tail, where it is roughly ten times smaller, and the orb\n    goes muddy.\n  */\n  vec3 L = normalize(vec3(\n    cos(animTime * uP_lightSpin) * 0.7,\n    0.45,\n    sin(animTime * uP_lightSpin) * 0.35 + 0.65\n  ));\n\n  float phase = phaseHG(dot(rd, L), uP_aniso);\n\n  // Start the march at the sphere's front face instead of the camera — every\n  // step before that contributes nothing, and at 56 steps they are expensive.\n  float toCentre = uP_camDist;\n  float tStart = max(toCentre - uP_radius, 0.0);\n  float span = 2.0 * uP_radius;\n  float dt = span / float(STEPS);\n\n  float T = 1.0;\n  vec3 scattered = vec3(0.0);\n\n  for (int i = 0; i < STEPS; i++) {\n    float t = tStart + (float(i) + 0.5) * dt;\n    vec3 p = ro + rd * t;\n\n    float dn = density(p, animTime);\n    if (dn > 0.001) {\n      // short march toward the light for self-shadowing\n      float shadow = 1.0;\n      float lstep = uP_radius / float(LIGHT_STEPS);\n      for (int k = 1; k <= LIGHT_STEPS; k++) {\n        vec3 lp = p + L * (float(k) - 0.5) * lstep;\n        shadow *= exp(-density(lp, animTime) * lstep * uP_shadowAbsorb);\n      }\n\n      /*\n        In-scattered light: warm where lit, cool where the volume shadows\n        itself.\n\n        The shadow term appears ONCE, inside the mix. Multiplying by it again\n        as a factor — the obvious-looking thing to write — scales the shadowed\n        end of the mix toward zero, so the cool colour is always multiplied\n        away and the cloud comes out monochrome beige however it is tinted.\n        uP_shadowLift is how much light still reaches the shadowed side.\n      */\n      vec3 lit = mix(uC_shadow * uP_shadowLift, uC_light, shadow);\n      scattered += T * dn * dt * lit * phase * nimbusPower;\n\n      T *= exp(-dn * dt * uP_absorb);\n      if (T < 0.01) break;\n    }\n  }\n\n  // a soft ambient body so the unlit side is not pure black\n  float body = 1.0 - T;\n  scattered += uC_shadow * body * uP_ambient;\n\n  return vec4(scattered, body);\n}\n\nvoid main() {\n  /*\n    Agent output turns the light up; user input thickens the cloud. Both are\n    AMPLITUDES. Churn is deliberately NOT volume-scaled: it multiplies the\n    accumulated clock into a phase (animTime * churn), so scaling it by the\n    live volume would turn every volume wobble into a phase jump the size of\n    the whole clock — the cloud scrambles chaotically on each state change\n    instead of gliding, and gets worse the longer the page is open.\n  */\n  nimbusPower = uP_power * (0.7 + 0.9 * uOutput);\n  nimbusDensity = uP_density * (1.0 + 0.35 * uInput);\n\n  vec4 acc = vec4(0.0);\n#if AA > 1\n  for (int mx = 0; mx < AA; mx++) {\n    for (int my = 0; my < AA; my++) {\n      vec2 offset = vec2(float(mx), float(my)) / float(AA) - 0.5;\n      acc += nimbusRender(gl_FragCoord.xy + offset);\n    }\n  }\n  acc /= float(AA * AA);\n#else\n  acc = nimbusRender(gl_FragCoord.xy);\n#endif\n\n  vec3 col = tanh3(acc.rgb * uP_exposure);\n  float a = clamp(acc.a * uP_alphaGain, 0.0, 1.0);\n\n  // Emitted/scattered light, so rgb is already premultiplied — do NOT multiply\n  // by alpha again (see the same note in shdr-31).\n  gl_FragColor = vec4(col, a);\n}\n`;export const shdr21Orb={key:\"shdr-21\",label:\"SHDR-21\",note:\"light diffusing through a cloud\",frag:NIMBUS_FRAG,params:[{key:\"speed\",label:\"Anim speed\",min:.015,max:10,step:.05,default:10,integrate:true},{key:\"camDist\",label:\"Camera distance\",min:.5,max:40,step:.2,default:4.4},{key:\"focal\",label:\"Lens\",min:.3,max:15,step:.1,default:1.8},{key:\"radius\",label:\"Cloud radius\",min:.15,max:10,step:.05,default:2},{key:\"scale\",label:\"Cloud scale\",min:.1,max:15,step:.1,default:.8},{key:\"churn\",label:\"Churn\",min:0,max:5,step:.03,default:.3},{key:\"threshold\",label:\"Clumping\",min:0,max:3,step:.015,default:.075},{key:\"edgeSoft\",label:\"Edge softness\",min:.1,max:10,step:.05,default:.8},{key:\"density\",label:\"Density\",min:.03,max:20,step:.1,default:3.2},{key:\"absorb\",label:\"Absorption\",min:.03,max:15,step:.1,default:1.4},{key:\"shadowAbsorb\",label:\"Shadow depth\",min:0,max:20,step:.1,default:2.4},{key:\"shadowLift\",label:\"Shadow lift\",min:0,max:5,step:.03,default:.55},{key:\"aniso\",label:\"Forward scatter\",min:-.9,max:.9,step:.01,default:.45},{key:\"lightSpin\",label:\"Light orbit\",min:0,max:3,step:.015,default:.12},{key:\"power\",label:\"Light power\",min:.03,max:40,step:.2,default:1.9},{key:\"ambient\",label:\"Ambient\",min:0,max:3,step:.015,default:.12},{key:\"exposure\",label:\"Exposure\",min:.03,max:10,step:.05,default:1},{key:\"alphaGain\",label:\"Alpha gain\",min:.05,max:10,step:.05,default:1.5}],/*\n   * The engine uploads these as uC_<key> vec3 uniforms. Warm light against a\n   * cool shadow is what reads as depth — a single-hue cloud looks flat however\n   * well it is shadowed.\n   */colors:[{key:\"light\",label:\"Light\",default:\"#ffd7a3\"},{key:\"shadow\",label:\"Shadow\",default:\"#3a4a8c\"}],statePresets:{/*\n      Every state shares the same speed, geometry and cloud shape — only the\n      AMBIENCE and the palette move, so switching state relights the cloud\n      instead of restaging it. The engine glides params and cross-fades\n      colours on one shared easing, so the change reads as a mood shift.\n    */idle:{ambient:.12,power:1.9,shadowLift:.55},thinking:{ambient:.22,power:2.15,shadowLift:.65},speaking:{ambient:.46,power:3.1,shadowLift:.95}},/*\n    The palette carries the rest of the state read: a warm lamp over cool\n    shadow at rest, shifting violet while it thinks, and burning hot while\n    speaking.\n  */stateColors:{idle:{light:\"#ffd7a3\",shadow:\"#3a4a8c\"},thinking:{light:\"#e6d4ff\",shadow:\"#3b3f96\"},speaking:{light:\"#ffb066\",shadow:\"#7a2f6e\"}}};\nexport const __FramerMetadata__ = {\"exports\":{\"shdr21Orb\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"__FramerMetadata__\":{\"type\":\"variable\"}}}\n//# sourceMappingURL=./orbkit_shdr21.map","/*\n * Shader by XorDev (https://x.com/XorDev), ported for Orbkit with the author's\n * permission. Non-commercial use only, with attribution to XorDev; keep this\n * notice with the file. Orbkit's runtime (orbkit-core.tsx) is MIT-licensed.\n *//*\n * Deliberately not a `\"use client\"` module — see the note in `shdr-11.tsx`.\n *\n * Note for editors: the shader lives in a template literal, so its comments\n * must not contain backticks.\n *//* ----------------------------------------------------------------------------\n   SHDR-25 — the folds of a warped field, drawn by their own steepness.\n\n   Ported from a one-line twigl listing:\n\n     vec2 p=FC.xy/r.y*2e1+t;\n     for(float i;i++<8.;)\n       p+=sin(p+t/.2+i)*.4,\n       p*=mat2(6,-8,8,6)/9.;\n     o=vec4(tanh(length(fwidth(sin(p*.3)/.1))),texture(b,FC.xy/r));\n\n   What it actually is, decoded:\n\n   - THE IMAGE IS A DERIVATIVE. Nothing here draws a shape; it measures how\n     fast a rippled field changes from one pixel to the next and paints\n     that. Where eight octaves of warp have folded the plane onto itself\n     the field races, and those folds come out as bright filigree. Where it\n     is stretched flat, nothing.\n   - mat2(6,-8,8,6)/9 IS AN EXACT SIMILARITY, and it is the neatest thing\n     in the listing. 6-8-10 is a Pythagorean triple, so that matrix is\n     precisely a rotation through the 3-4-5 angle — about 53.13 degrees —\n     times a scale of 10/9. Rotating between octaves is the standard way to\n     stop a warp from lining up with the axes; doing it with integers and\n     one divide is not.\n   - THE CLOCK RUNS TWICE. t translates the whole field once at the start,\n     and t/.2 — five times faster — drives the warp inside every octave, so\n     the pattern drifts slowly while its detail boils.\n   - vec4(scalar, texture(...)) puts the derivative in RED and takes green,\n     blue and alpha from the previous frame.\n\n   Port decisions, each one a documented trap or rule in the README:\n\n   - fwidth() CANNOT BE USED. It needs OES_standard_derivatives in WebGL 1,\n     and the #extension directive that enables it cannot legally follow the\n     prelude's declarations — the README says so, and shdr-28 works\n     around it by deriving its pixel footprint analytically. There is no\n     analytic footprint through eight octaves of feedback warp, so the\n     derivative is taken by FINITE DIFFERENCES instead: evaluate the whole\n     chain at the two neighbouring pixel centres and difference. Three\n     evaluations rather than one, and closer to the truth than fwidth,\n     which is constant across each 2x2 quad.\n   - THE FEEDBACK TERM IS NOT PORTED. One pass, one canvas, no\n     previous-frame texture (the same limit as shdr-09). Green and blue\n     arrive only from that line, so without a substitute this orb would be\n     red and nothing else — the derivative is instead run through a palette\n     keyed to the field itself.\n   - THE ORB IS THE OBJECT: a flat 2D field, so it is sampled through a\n     stereographic projection of the dome, and motion is projection-safe\n     2D as in shdr-08. That wrap pays for itself twice here — because the\n     measurement is a SCREEN-SPACE derivative, the projection's own\n     compression toward the limb steepens the field there, so the filigree\n     tightens at the rim exactly the way a texture on a real sphere would.\n   - The golfed listing relies on i starting at zero; uninitialised locals\n     are UNDEFINED in GLSL ES 1.0, explicit here.\n   - Surface-lit and mask-bounded, so alpha IS coverage — premultiplied\n     output, as in shdr-17.\n---------------------------------------------------------------------------- *//*\n * Step counts are `#define`s: ES 1.0 requires constant loop bounds. OCTAVES\n * is the listing's i++ < 8. The finite difference costs three passes of it\n * per sample, so this is 24 warp steps before supersampling.\n */const CREASE_FRAG=`\n#define OCTAVES 8\n#define AA 2\n\n// Volume-reactive values, resolved once per fragment in main().\nfloat creaseWarp;\nfloat creaseGain;\n\n// GLSL ES 1.0 has no scalar tanh; the prelude ships the vec3 form only.\nfloat tanh1(float x) {\n  x = clamp(x, -10.0, 10.0);\n  float e = exp(2.0 * x);\n  return (e - 1.0) / (e + 1.0);\n}\n\n/*\n  The whole chain for one pixel centre: dome, stereographic wrap, then the\n  eight-octave warp. Called three times per sample so the derivative below\n  can be differenced — see the header for why fwidth is unavailable.\n*/\nvec2 creaseField(vec2 fragCoord, float t, float drift, float sw) {\n  vec2 uv = (2.0 * fragCoord - uRes) / min(uRes.x, uRes.y);\n  vec2 pl = uv / max(uP_radius, 0.001);\n  float z = sqrt(max(1.0 - dot(pl, pl), 0.0));\n\n  vec2 p = pl / (z + 1.0 + uP_bulge) * uP_scale;\n  p = mat2(cos(sw), -sin(sw), sin(sw), cos(sw)) * p;\n  p += drift;\n\n  /*\n    The listing's matrix, decomposed. mat2(6,-8,8,6)/9 is exactly\n    (10/9) * mat2(.6,-.8,.8,.6), and that second factor is a true rotation\n    because 6-8-10 is a Pythagorean triple — so the octave transform is a\n    rotation through the 3-4-5 angle times a clean zoom, with the zoom\n    pulled out as a slider.\n  */\n  for (int i = 0; i < OCTAVES; i++) {\n    float fi = float(i) + 1.0;\n    p += sin(p + t + fi) * creaseWarp;\n    p = uP_zoom * (mat2(0.6, -0.8, 0.8, 0.6) * p);\n  }\n\n  return p;\n}\n\nvec3 creaseRender(vec2 fragCoord) {\n  float t = uP_speed;      // integrated clock: the boil\n  float drift = uP_drift;  // integrated clock: the slow travel\n  float sw = uP_swirl;     // integrated clock\n\n  /*\n    The three taps the difference needs. uP_blur is how far apart they sit:\n    at one pixel this is fwidth exactly, and wider is a deliberate blur —\n    the derivative of a folded field is a hairline, and a rim wants width.\n  */\n  vec2 p0 = creaseField(fragCoord, t, drift, sw);\n  vec2 px = creaseField(fragCoord + vec2(uP_blur, 0.0), t, drift, sw);\n  vec2 py = creaseField(fragCoord + vec2(0.0, uP_blur), t, drift, sw);\n\n  /*\n    fwidth, by hand and once per channel. The sum of the absolute\n    differences on each axis is exactly what the built-in returns — but\n    taking it three times at slightly offset ripple phases puts each\n    channel's rim in a slightly different place, which is where the warm\n    and cool fringes on the edges come from. One field evaluation still\n    serves all three.\n  */\n  vec3 e;\n  for (int c = 0; c < 3; c++) {\n    float ph = float(c) * uP_fringe;\n    vec2 v0 = sin(p0 * uP_ripple + ph);\n    vec2 d = abs(sin(px * uP_ripple + ph) - v0)\n           + abs(sin(py * uP_ripple + ph) - v0);\n    float m = tanh1(length(d) * creaseGain / max(uP_exposure, 0.001));\n    if (c == 0) e.r = m;\n    else if (c == 1) e.g = m;\n    else e.b = m;\n  }\n\n  e = pow(clamp(e, 0.0, 1.0), vec3(uP_contrast));\n\n  vec3 col = uC_tint * e;\n\n  // a dark body under the filigree, so the flat regions read as the ball\n  col += uC_body * uP_floorLevel;\n\n  float lum = dot(col, vec3(0.299, 0.587, 0.114));\n  col = mix(vec3(lum), col, uP_saturation);\n\n  // dome shading keeps the ball a ball under the folds\n  vec2 pl = ((2.0 * fragCoord - uRes) / min(uRes.x, uRes.y)) / max(uP_radius, 0.001);\n  float z = sqrt(max(1.0 - dot(pl, pl), 0.0));\n  vec3 n = vec3(pl, z);\n  float lambert = clamp(dot(n, normalize(vec3(-0.45, 0.55, 0.72))), 0.0, 1.0);\n  col *= 0.62 + uP_light * lambert;\n\n  float fres = 1.0 - z;\n  fres = fres * fres * fres;\n  col += uC_sheen * uP_rim * fres;\n\n  return col;\n}\n\nvoid main() {\n  // Volume coupling: the user's voice folds the field harder, the agent's\n  // steepens what counts as a crease.\n  creaseWarp = uP_warp * (1.0 + 0.4 * uInput);\n  creaseGain = uP_edgeGain * (1.0 + 0.5 * uOutput);\n\n  vec2 uv = orbUV();\n  float mask = smoothstep(0.012, -0.012, length(uv) - max(uP_radius, 0.001));\n\n  // Twenty-four warp steps per sample — none of them worth paying for\n  // outside the silhouette.\n  if (mask <= 0.0) {\n    gl_FragColor = vec4(0.0);\n    return;\n  }\n\n  vec3 col = vec3(0.0);\n#if AA > 1\n  for (int mx = 0; mx < AA; mx++) {\n    for (int my = 0; my < AA; my++) {\n      vec2 off = (vec2(float(mx), float(my)) + 0.5) / float(AA) - 0.5;\n      col += creaseRender(gl_FragCoord.xy + off);\n    }\n  }\n  col /= float(AA * AA);\n#else\n  col = creaseRender(gl_FragCoord.xy);\n#endif\n\n  // Surface orb bounded by a mask: alpha IS coverage, so premultiply — the\n  // opposite convention from the emissive orbs (see shdr-31).\n  float a = mask;\n  gl_FragColor = vec4(max(col, vec3(0.0)) * a, a);\n}\n`;export const shdr25Orb={key:\"shdr-25\",label:\"SHDR-25\",note:\"the folds of a warped field, drawn by their own steepness\",frag:CREASE_FRAG,params:[{key:\"speed\",label:\"Boil\",min:.015,max:20,step:.05,default:3,integrate:true},{key:\"drift\",label:\"Drift\",min:0,max:8,step:.02,default:.6,integrate:true},{key:\"swirl\",label:\"Swirl\",min:0,max:3,step:.015,default:.05,integrate:true},{key:\"radius\",label:\"Radius\",min:.15,max:3,step:.015,default:.9},{key:\"scale\",label:\"Cell scale\",min:.3,max:60,step:.1,default:7.5},{key:\"bulge\",label:\"Dome bulge\",min:0,max:4,step:.02,default:.3},{key:\"warp\",label:\"Fold\",min:0,max:2,step:.01,default:.4},{key:\"zoom\",label:\"Octave zoom\",min:.6,max:2,step:.005,default:1.111},{key:\"ripple\",label:\"Ripple\",min:.02,max:3,step:.01,default:.3},{key:\"edgeGain\",label:\"Edge gain\",min:.5,max:60,step:.5,default:10},{key:\"blur\",label:\"Rim width\",min:.5,max:12,step:.25,default:2.5},{key:\"fringe\",label:\"Chromatic fringe\",min:0,max:1.5,step:.005,default:.09},{key:\"exposure\",label:\"Exposure\",min:.05,max:40,step:.05,default:.8},{key:\"contrast\",label:\"Contrast\",min:.15,max:8,step:.05,default:1.15},{key:\"saturation\",label:\"Saturation\",min:0,max:4,step:.02,default:1.5},{key:\"floorLevel\",label:\"Body fill\",min:0,max:2,step:.01,default:.16},{key:\"light\",label:\"Key light\",min:0,max:3,step:.015,default:.35},{key:\"rim\",label:\"Rim sheen\",min:0,max:3,step:.015,default:.45}],colors:[{key:\"tint\",label:\"Rim\",default:\"#dbe8f7\"},{key:\"body\",label:\"Body\",default:\"#0d1118\"},{key:\"sheen\",label:\"Sheen\",default:\"#a8c8f0\"}],/*\n    Staged on the FOLD, which is what makes creases exist at all, and on\n    edge gain, which decides how steep a slope has to be to count as one.\n    Cell scale moves only for the answer — it sets how much pattern is on\n    the ball, and as it glides in the ball reads as inflating; that is the\n    answer's entrance.\n  */statePresets:{// at rest: a slow boil, folds moderate, rims clean — the octave zoom\n// pulled in a touch under the default and the edge gain a quarter up,\n// so slightly gentler slopes count as creases\nidle:{speed:3,drift:.6,swirl:.05,warp:.4,zoom:1.07,edgeGain:12.5,exposure:.8,contrast:1.15},/*\n      searching: the folds RELAX a touch below idle, but the edge gain\n      nearly triples so even the shallowest slope lights up as a crease,\n      on a boil half again idle's. The ripple tightens, the rim widens with\n      more than double the chromatic fringe, and the saturation, key light\n      and rim sheen all come up — every cell rims at once in colour, and\n      none of it settles.\n    */thinking:{speed:4.7,drift:.15,swirl:.02,bulge:.38,warp:.34,zoom:1.12,ripple:.18,edgeGain:33,blur:2.75,fringe:.2,exposure:.55,contrast:1.5,saturation:2,light:.525,rim:.69},/*\n      answering: the field FOLDS hardest of the three and the gain drops to\n      under a sixth of the thinking state, so the creases are deep but only\n      the steepest rims light. The cell scale is pushed past idle's and the\n      dome bulged to near a hemisphere, the swirl opened an order of\n      magnitude, the ripple widened — a slow, heavy, swirling boil, with\n      the exposure tripled so what does light, burns.\n    */speaking:{speed:1.4,drift:.8,swirl:.6,scale:11.5,bulge:2.22,warp:1.55,zoom:.945,ripple:1.18,edgeGain:5,blur:2,fringe:.23,exposure:2.35,contrast:1.35}},// cool steel at rest, cold indigo for both working states — the answer\n// is told apart by its fold and scale, not its colour\nstateColors:{idle:{tint:\"#dbe8f7\",body:\"#0d1118\",sheen:\"#a8c8f0\"},thinking:{tint:\"#c2d6f5\",body:\"#090d1c\",sheen:\"#8fb4f2\"},speaking:{tint:\"#c2d6f5\",body:\"#090d1c\",sheen:\"#8fb4f2\"}}};\nexport const __FramerMetadata__ = {\"exports\":{\"shdr25Orb\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"__FramerMetadata__\":{\"type\":\"variable\"}}}\n//# sourceMappingURL=./orbkit_shdr25.map","import{jsx as _jsx}from\"react/jsx-runtime\";import{addPropertyControls,ControlType}from\"framer\";import{ShaderOrb}from\"https://framerusercontent.com/modules/INzRpVv9hRS261zL5mms/1YoVQKqqawK35OK5RArN/orbkit_core.js\";import{shdr16Orb}from\"https://framerusercontent.com/modules/fvj2BEIV2uFaBWKCLQqE/vtvMJke66PBsM3klDRIO/orbkit_shdr16.js\";import{shdr17Orb}from\"https://framerusercontent.com/modules/W1zgH9YhIO4H3hmIsbVu/hvseuPgF6ieJiKeJXQK9/orbkit_shdr17.js\";import{shdr13Orb}from\"https://framerusercontent.com/modules/Wl7GTkVaa5gOu3RdW8A8/HczAIhIiIqTqd6TBuMti/orbkit_shdr13.js\";import{shdr21Orb}from\"https://framerusercontent.com/modules/JOXgAEMRL2LsqxrL36Ca/1SLghn6nRFl4b9pLAwUO/orbkit_shdr21.js\";import{shdr25Orb}from\"https://framerusercontent.com/modules/Hz8fwvv3zuIgqP0SKK5b/GehQ5EjgLnCNFh6eE7EB/orbkit_shdr25.js\";const ORBS={\"SHDR-25\":shdr25Orb,\"SHDR-16\":shdr16Orb,\"SHDR-17\":shdr17Orb,\"SHDR-13\":shdr13Orb,\"SHDR-21\":shdr21Orb};/**\n * RB Orb\n *\n * A WebGL shader orb from Orbkit (MIT, github.com/zzzzshawn/orbkit), sized\n * to its frame. SHDR-25 is a port of XorDev's shader, used with his\n * permission (credit kept in its file); the rest are Orbkit's own MIT orbs.\n * Don't add other XorDev ports without permission. It stops rendering while\n * scrolled out of view.\n *\n * @framerIntrinsicWidth 280\n * @framerIntrinsicHeight 280\n *\n * @framerSupportedLayoutWidth fixed\n * @framerSupportedLayoutHeight fixed\n */export default function RBOrb({orb=\"SHDR-16\",state=\"idle\",label=\"\"}){const variant=ORBS[orb]??ORBS[\"SHDR-16\"];return /*#__PURE__*/_jsx(ShaderOrb,{variant:variant,state:state,style:{width:\"100%\",height:\"100%\"},ariaLabel:label||undefined});}addPropertyControls(RBOrb,{orb:{type:ControlType.Enum,title:\"Orb\",options:Object.keys(ORBS),defaultValue:\"SHDR-16\"},state:{type:ControlType.Enum,title:\"State\",options:[\"idle\",\"thinking\",\"speaking\"],optionTitles:[\"Idle\",\"Thinking\",\"Speaking\"],defaultValue:\"idle\"},label:{type:ControlType.String,title:\"Label\",defaultValue:\"\"}});\nexport const __FramerMetadata__ = {\"exports\":{\"default\":{\"type\":\"reactComponent\",\"name\":\"RBOrb\",\"slots\":[],\"annotations\":{\"framerSupportedLayoutWidth\":\"fixed\",\"framerIntrinsicWidth\":\"280\",\"framerIntrinsicHeight\":\"280\",\"framerContractVersion\":\"1\",\"framerSupportedLayoutHeight\":\"fixed\"}},\"__FramerMetadata__\":{\"type\":\"variable\"}}}"],"mappings":"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"}