@mkbabb/glass-ui 2.1.0 → 3.1.0

package/dist/aurora.js

@@ -1,6 +1,6 @@
-import { t as e } from "./_plugin-vue_export-helper-n-_DRHWS.js";
-import { n as t, r as n, t as r } from "./presets-BMzCDrmR.js";
-import { t as i } from "./useIntersectionPause-CXYfYg_C.js";
+import { t as e } from "./_plugin-vue_export-helper-Dq1MygBL.js";
+import { n as t, r as n, t as r } from "./presets-a-D93K1S.js";
+import { t as i } from "./useIntersectionPause-IY2CwPQb.js";
 import { computed as a, createElementBlock as o, createElementVNode as s, defineComponent as c, normalizeClass as l, normalizeStyle as u, onBeforeUnmount as d, onMounted as f, openBlock as p, readonly as m, ref as h, unref as g, watch as _ } from "vue";
 //#region src/components/custom/aurora/shaders/aurora.vert.ts
 var v = "#version 300 es\nin vec2 aPos;\nout vec2 vUv;\nvoid main() {\n  vUv = aPos * 0.5 + 0.5;\n  gl_Position = vec4(aPos, 0.0, 1.0);\n}", y = "#version 300 es\nprecision highp float;\n\nin vec2 vUv;\nout vec4 fragColor;\n\n#define MAX_NUCLEI 6\n#define MAX_STOPS  8\n\n// ── Uniforms ───────────────────────────────────────────────────────────────\nuniform float uTime;\n\n// Palette baked CPU-side to linear-sRGB\nuniform vec3  uPalette[MAX_STOPS];\nuniform int   uStopCount;\n\n// Nuclei (parallel arrays)\nuniform int   uNucleiCount;\nuniform vec2  uNucleiPos[MAX_NUCLEI];\nuniform float uNucleiRadius[MAX_NUCLEI];\nuniform float uNucleiPaletteBias[MAX_NUCLEI];\nuniform float uNucleiValueBias[MAX_NUCLEI];\nuniform float uNucleiDriftRadius[MAX_NUCLEI];\nuniform float uNucleiDriftPhase[MAX_NUCLEI];\n// Anisotropy: per-nucleus elongation (1.0 = isotropic) and major-axis angle (radians).\n// Defaults (1.0 / 0.0) reduce to the original circular Gaussian.\nuniform float uNucleiElong[MAX_NUCLEI];\nuniform float uNucleiAngle[MAX_NUCLEI];\nuniform float uSoftmaxBeta;\nuniform float uValueVariance;\n\n// Warp\nuniform float uWarpAmount;\nuniform float uWarpScale;\nuniform float uWarpDrift;\nuniform int   uWarpMode;      // 0=fbm 1=cellular 2=hybrid\nuniform int   uNoiseOctaves;\n\n// Medium\n// 0 smooth, 1 pastel, 2 watercolor, 3 oil\nuniform int   uMedium;\nuniform int   uFlowPattern;   // 0 none, 1 radial, 2 swirl, 3 diagonal, 4 multi\nuniform vec2  uFlowFocal;\nuniform float uFlowAngle;\nuniform float uFlowCurl;\nuniform vec2  uCursor;          // in 0..1 screen space (matches pN)\nuniform float uCursorStrength;  // 0..1 attraction amount\nuniform float uCursorRadius;    // radius of influence (0.05..0.5)\nuniform float uStrokeAmount;\nuniform float uStrokeScale;\nuniform float uStrokeAnisotropy;\nuniform int   uStrokeLayers;  // 1 or 2 (crosshatch)\nuniform int   uStrokeMode;    // 0 oil (modern gestural), 1 palette-knife, 2 crayon/oil-pastel, 3 modern-chunky\nuniform float uWetEdge;\nuniform float uGranulation;\nuniform float uImpasto;\nuniform float uBrokenColor;\nuniform float uCanvasGrain;\n\n// Motion\nuniform float uNucleiDrift;\nuniform float uPaletteDrift;\nuniform float uBreathDepth;\nuniform float uBreathPeriod;\n\n// Output\nuniform float uSaturation;\nuniform float uPaperGrain;\nuniform float uAlpha;\n\n// ── Noise ──────────────────────────────────────────────────────────────────\nfloat hash21(vec2 p) {\n  p = fract(p * vec2(123.34, 456.21));\n  p += dot(p, p + 45.32);\n  return fract(p.x * p.y);\n}\n\nvec2 hash22(vec2 p) {\n  p = vec2(dot(p, vec2(127.1, 311.7)),\n           dot(p, vec2(269.5, 183.3)));\n  return fract(sin(p) * 43758.5453);\n}\n\nfloat vnoise(vec2 p) {\n  vec2 i = floor(p);\n  vec2 f = fract(p);\n  vec2 u = f * f * (3.0 - 2.0 * f);\n  float a = hash21(i);\n  float b = hash21(i + vec2(1.0, 0.0));\n  float c = hash21(i + vec2(0.0, 1.0));\n  float d = hash21(i + vec2(1.0, 1.0));\n  return mix(mix(a, b, u.x), mix(c, d, u.x), u.y);\n}\n\nfloat fbm(vec2 p) {\n  float v = 0.0;\n  float a = 0.5;\n  mat2 r = mat2(0.8, 0.6, -0.6, 0.8);\n  for (int i = 0; i < 5; i++) {\n    if (i >= uNoiseOctaves) break;\n    v += a * vnoise(p);\n    p = r * p * 2.02;\n    a *= 0.5;\n  }\n  return v;\n}\n\n// Cellular / Worley f1\nfloat cellular(vec2 p) {\n  vec2 i = floor(p);\n  vec2 f = fract(p);\n  float m = 1e9;\n  for (int y = -1; y <= 1; y++) {\n    for (int x = -1; x <= 1; x++) {\n      vec2 g = vec2(float(x), float(y));\n      vec2 o = hash22(i + g);\n      vec2 r = g + o - f;\n      m = min(m, dot(r, r));\n    }\n  }\n  return sqrt(m);\n}\n\n// ── Warp ──────────────────────────────────────────────────────────────────\nvec2 domainWarp(vec2 p, float t) {\n  // Quilez canonical double warp\n  vec2 q = vec2(fbm(p * uWarpScale + vec2(0.0, 0.0) + t * uWarpDrift),\n                fbm(p * uWarpScale + vec2(5.2, 1.3) + t * uWarpDrift));\n  vec2 r = vec2(fbm(p * uWarpScale + 4.0 * q + vec2(1.7, 9.2)),\n                fbm(p * uWarpScale + 4.0 * q + vec2(8.3, 2.8)));\n\n  vec2 warp = r;\n  if (uWarpMode == 1) {\n    // cellular — chunky territories (MEADOW block-like)\n    float c1 = cellular(p * uWarpScale * 1.5 + vec2(t * uWarpDrift * 2.0, 0.0));\n    float c2 = cellular(p * uWarpScale * 1.5 + vec2(11.0, 7.0 + t * uWarpDrift * 2.0));\n    warp = vec2(c1, c2);\n  } else if (uWarpMode == 2) {\n    // hybrid — fbm + cellular averaged\n    float c1 = cellular(p * uWarpScale * 1.2);\n    float c2 = cellular(p * uWarpScale * 1.2 + vec2(11.0, 7.0));\n    warp = mix(r, vec2(c1, c2), 0.5);\n  }\n  vec2 warped = p + uWarpAmount * warp;\n\n  // Cursor swirl — rotate p around uCursor with radial falloff.\n  // This warps the underlying color field so the bands sweep around the pointer.\n  if (uCursorStrength > 0.001) {\n    vec2 toP = p - uCursor;\n    float d = length(toP);\n    float r = max(uCursorRadius, 0.01);\n    // Smooth falloff; strong near cursor, zero beyond ~1.5× radius.\n    float w = exp(-(d * d) / (r * r * 0.45));\n    // Max rotation ~120° at cursor center, scaled by strength\n    float ang = w * uCursorStrength * 2.1;\n    float ca = cos(ang), sa = sin(ang);\n    vec2 rotated = vec2(ca * toP.x - sa * toP.y, sa * toP.x + ca * toP.y) + uCursor;\n    // Also pinch slightly toward the cursor (gravity) — adds depth to swirl\n    float pinch = w * uCursorStrength * 0.08;\n    rotated = mix(rotated, uCursor, pinch);\n    // Blend original warped position with cursor-rotated version\n    warped = mix(warped, rotated + uWarpAmount * warp * 0.7, w * uCursorStrength);\n  }\n\n  return warped;\n}\n\n// ── Palette LUT ───────────────────────────────────────────────────────────\nvec3 samplePalette(float id) {\n  id = clamp(id, 0.0, 1.0);\n  float scaled = id * float(uStopCount - 1);\n  int i0 = int(floor(scaled));\n  int i1 = min(i0 + 1, uStopCount - 1);\n  float t = fract(scaled);\n  t = smoothstep(0.0, 1.0, t);\n  return mix(uPalette[i0], uPalette[i1], t);\n}\n\n// ── Nuclei field ──────────────────────────────────────────────────────────\nvoid nucleiField(vec2 p, float t, out float paletteId, out float valueMod) {\n  float accumBias  = 0.0;\n  float accumValue = 0.0;\n  float accumW     = 0.0;\n  for (int i = 0; i < MAX_NUCLEI; i++) {\n    if (i >= uNucleiCount) break;\n    vec2 posI = uNucleiPos[i]\n              + uNucleiDriftRadius[i] * vec2(\n                  cos(t * uNucleiDrift + uNucleiDriftPhase[i]),\n                  sin(t * uNucleiDrift + uNucleiDriftPhase[i] * 1.13)\n                );\n    vec2 diff = p - posI;\n    // Anisotropic Gaussian: rotate diff into the nucleus's local frame\n    // (major axis along uNucleiAngle), then scale the major-axis component by\n    // 1/elongation so the squared distance describes an ellipse. Defaults\n    // 1.0/0.0 reduce to the isotropic dot(diff, diff).\n    float ca = cos(uNucleiAngle[i]);\n    float sa = sin(uNucleiAngle[i]);\n    vec2  local = vec2( ca * diff.x + sa * diff.y,\n                       -sa * diff.x + ca * diff.y);\n    float along  = local.x / max(uNucleiElong[i], 0.01);\n    float across = local.y;\n    float d2 = along * along + across * across;\n    float r = max(uNucleiRadius[i], 0.01);\n    float w = exp(-uSoftmaxBeta * d2 / (r * r));\n    accumBias  += w * uNucleiPaletteBias[i];\n    accumValue += w * uNucleiValueBias[i];\n    accumW     += w;\n  }\n  paletteId = accumBias  / max(accumW, 1e-4);\n  valueMod  = accumValue / max(accumW, 1e-4);\n\n  // Palette drift — subtle global paletteId shift\n  paletteId += 0.04 * sin(t * uPaletteDrift * 6.2831) * uPaletteDrift * 20.0;\n  paletteId = clamp(paletteId, 0.0, 1.0);\n}\n\n// ── Flow field ────────────────────────────────────────────────────────────\nvec2 flowField(vec2 p, float t) {\n  vec2 dir = vec2(1.0, 0.0);\n  if (uFlowPattern == 1) {\n    // radial\n    dir = normalize(p - uFlowFocal + 1e-4);\n  } else if (uFlowPattern == 2) {\n    // swirl — tangent to radial\n    vec2 rad = normalize(p - uFlowFocal + 1e-4);\n    dir = vec2(-rad.y, rad.x);\n  } else if (uFlowPattern == 3) {\n    // diagonal\n    float a = radians(uFlowAngle);\n    dir = vec2(cos(a), sin(a));\n  } else if (uFlowPattern == 4) {\n    // multi — curl-noise driven\n    float n = fbm(p * 2.0 + t * 0.02);\n    float a = n * 6.2831;\n    dir = vec2(cos(a), sin(a));\n  }\n  // curl — perturb by noise. Radial gets much less curl so rays stay clean.\n  if (uFlowCurl > 0.0) {\n    float n = fbm(p * 3.0) - 0.5;\n    float curlAmt = uFlowCurl;\n    if (uFlowPattern == 1) curlAmt *= 0.25;  // radial: preserve ray clarity\n    if (uFlowPattern == 2) curlAmt *= 0.55;  // swirl: allow moderate curl\n    float a = atan(dir.y, dir.x) + n * 3.14159 * curlAmt;\n    dir = vec2(cos(a), sin(a));\n  }\n  // cursor influence — swirl around the cursor position\n  if (uCursorStrength > 0.001) {\n    vec2 toCur = uCursor - p;\n    float d = length(toCur);\n    float r = max(uCursorRadius, 0.01);\n    float w = exp(-(d * d) / (r * r * 0.5));\n    // swirl tangent\n    vec2 tangent = vec2(-toCur.y, toCur.x) / max(d, 1e-4);\n    float a0 = atan(dir.y, dir.x);\n    float a1 = atan(tangent.y, tangent.x);\n    // blend angle\n    float da = a1 - a0;\n    da = atan(sin(da), cos(da)); // wrap to [-pi, pi]\n    float a = a0 + da * w * uCursorStrength;\n    dir = vec2(cos(a), sin(a));\n  }\n  return dir;\n}\n\n// ── Color utils ───────────────────────────────────────────────────────────\nconst vec3 W_LUMA = vec3(0.2126, 0.7152, 0.0722);\n\nvec3 hueShift(vec3 c, float degrees) {\n  float a = radians(degrees);\n  float co = cos(a), si = sin(a);\n  mat3 m = mat3(\n    0.299 + 0.701 * co + 0.168 * si,\n    0.587 - 0.587 * co + 0.330 * si,\n    0.114 - 0.114 * co - 0.497 * si,\n\n    0.299 - 0.299 * co - 0.328 * si,\n    0.587 + 0.413 * co + 0.035 * si,\n    0.114 - 0.114 * co + 0.292 * si,\n\n    0.299 - 0.300 * co + 1.250 * si,\n    0.587 - 0.588 * co - 1.050 * si,\n    0.114 + 0.886 * co - 0.203 * si\n  );\n  return m * c;\n}\n\nvec3 brokenColorJitter(vec3 c, float hueSeed, float valueSeed, float strength) {\n  float amt = clamp(uBrokenColor * strength, 0.0, 1.0);\n  if (amt <= 0.001) return c;\n  float hueDeg = (hueSeed - 0.5) * 32.0 * amt;\n  float valueMul = 1.0 + (valueSeed - 0.5) * 0.28 * amt;\n  return max(hueShift(c, hueDeg) * valueMul, vec3(0.0));\n}\n\nvec3 saturate3(vec3 c, float amt) {\n  float l = dot(c, W_LUMA);\n  return mix(vec3(l), c, amt);\n}\n\n// ACES approximation\nvec3 aces(vec3 x) {\n  float a = 2.51;\n  float b = 0.03;\n  float c = 2.43;\n  float d = 0.59;\n  float e = 0.14;\n  return clamp((x * (a * x + b)) / (x * (c * x + d) + e), 0.0, 1.0);\n}\n\n// ── Medium overlays ───────────────────────────────────────────────────────\n\n// A quick re-computation of base color for edge-mask sampling\nvec3 sampleBase(vec2 p, float t) {\n  vec2 pw = domainWarp(p, t);\n  float id; float vm;\n  nucleiField(pw, t, id, vm);\n  vec3 c = samplePalette(id);\n  c *= 1.0 + uValueVariance * vm;\n  return c;\n}\n\nvec3 mediumWatercolor(vec3 col, vec2 p, float t) {\n  // Wet-edge cauliflowers via luma-gradient magnitude\n  float eps = 0.004;\n  vec3 cx1 = sampleBase(p + vec2(eps, 0.0), t);\n  vec3 cx2 = sampleBase(p - vec2(eps, 0.0), t);\n  vec3 cy1 = sampleBase(p + vec2(0.0, eps), t);\n  vec3 cy2 = sampleBase(p - vec2(0.0, eps), t);\n  float gx = dot(cx1 - cx2, W_LUMA);\n  float gy = dot(cy1 - cy2, W_LUMA);\n  float edge = sqrt(gx * gx + gy * gy) / (2.0 * eps);\n  float mask = smoothstep(0.0, 2.5, edge);\n  col *= mix(1.0, 0.78, mask * uWetEdge);\n\n  // Granulation — pigment settles in paper tooth\n  float paper = 0.5 * vnoise(p * 160.0) + 0.5 * vnoise(p * 360.0);\n  float pigLoad = 1.0 - dot(col, W_LUMA);\n  col *= 1.0 - uGranulation * pigLoad * (paper - 0.5);\n\n  // Wash banding — faint horizontal wet gradient\n  float band = fbm(vec2(p.x * 1.5, p.y * 0.4));\n  col *= 1.0 + 0.04 * (band - 0.5);\n  return col;\n}\n\nvec3 mediumPastel(vec3 col, vec2 p, float t) {\n  vec2 flow = flowField(p, t);\n  vec2 perp = vec2(-flow.y, flow.x);\n  float along  = dot(p, flow) * uStrokeScale;\n  float across = dot(p, perp) * uStrokeScale;\n  across += 0.03 * (vnoise(p * 260.0) - 0.5);\n\n  float aniso = mix(1.0, 0.18, uStrokeAnisotropy);\n  float stroke = fbm(vec2(along * aniso, across));\n  col *= mix(1.0, 0.82 + 0.32 * stroke, uStrokeAmount);\n\n  // Pastel tooth — tiny high-frequency grain\n  float tooth = vnoise(p * 800.0);\n  col *= 1.0 - 0.08 * uStrokeAmount * (tooth - 0.5);\n  return col;\n}\n\n// ── Curved swept brushstroke primitive ────────────────────────────────────\n// A stroke is a curved spine from A to B with quadratic bulge K (sideways offset\n// at midpoint). Width varies along length via a shape profile. Edge is ragged\n// (bristle-modulated), ends are rounded blobs, inside has streak modulation.\n//\n// For pixel p, we invert an approximate projection onto the curved spine:\n//   1) project p onto straight AB axis -> along0, cross0\n//   2) at parameter along0, spine offset = 4·K·along0·(1-along0) perpendicular\n//   3) cross = cross0 - spineOffset, refine along one iteration\n// Coverage blends paint atop col based on per-stroke color sampled from the\n// underlying base at spine midpoint — so overlapping strokes from different\n// palette regions meet at hard, ragged demarcations.\n\nstruct StrokeHit {\n  float coverage;  // 0..1\n  vec3  color;\n  float alongT;    // 0..1 along spine, for internal modulation\n  float crossN;    // cross distance / current half-width, signed\n  float edgeN;     // distance to edge in half-widths (0 = at edge, 1 = at spine)\n};\n\nStrokeHit noHit() { return StrokeHit(0.0, vec3(0.0), 0.0, 0.0, 0.0); }\n\nvec2 rotateDir(vec2 dir, float angle) {\n  float ca = cos(angle), sa = sin(angle);\n  return vec2(dir.x * ca - dir.y * sa, dir.x * sa + dir.y * ca);\n}\n\nvec2 safeDir(vec2 dir) {\n  float len = length(dir);\n  return len > 1e-4 ? dir / len : vec2(1.0, 0.0);\n}\n\n// Shape profile along the stroke. type:\n//   0 tapered    — thin-fat-thin (classic brush)\n//   1 load-drag  — fat start, tapers to a point\n//   2 dab        — ellipse-like, round center\n//   3 even       — near-constant, slight end taper\nfloat strokeShape(float t, int type) {\n  t = clamp(t, 0.0, 1.0);\n  if (type == 1) {\n    // loaded at t=0, tapering\n    return pow(1.0 - t, 0.55) * smoothstep(0.0, 0.08, t);\n  } else if (type == 2) {\n    // dab / blob\n    float d = t - 0.5;\n    return exp(-d * d * 12.0);\n  } else if (type == 3) {\n    // mostly even, slight end softening\n    return smoothstep(0.0, 0.08, t) * smoothstep(1.0, 0.92, t) * 0.95 + 0.05;\n  }\n  // 0 tapered\n  return smoothstep(0.0, 0.22, t) * smoothstep(1.0, 0.78, t);\n}\n\n// A single curved stroke.\n//   a, b           — endpoints\n//   halfW          — base half-width (world units)\n//   bulge          — signed perpendicular midpoint offset, in world units\n//   shapeType      — 0..3\n//   bristleFreq    — spatial frequency of edge raggedness\n//   bristleAmp     — 0..0.5 fraction of halfW chewed away at edge extrema\n//   streakSeed     — uniqueness seed for internal streaks\n//   colAtMid       — pre-sampled color at midpoint\nStrokeHit curvedStroke(vec2 p, vec2 a, vec2 b, float halfW,\n                       float bulge, int shapeType,\n                       float bristleFreq, float bristleAmp,\n                       float streakSeed, vec3 colAtMid) {\n  vec2 ab = b - a;\n  float L = length(ab);\n  if (L < 1e-5) return noHit();\n  vec2 tang = ab / L;\n  vec2 norm = vec2(-tang.y, tang.x);\n\n  vec2 rel = p - a;\n  float along0 = dot(rel, tang) / L;      // straight projection 0..1 along AB\n  float cross0 = dot(rel, norm);          // signed cross\n\n  // Spine sideways offset due to bulge (parabolic)\n  float bend = 4.0 * bulge * along0 * (1.0 - along0);\n  float cross1 = cross0 - bend;\n\n  // One refinement step: as the spine bends, the closest-point along shifts.\n  // Spine tangent differs from straight tangent; first-order correction:\n  float dBend = 4.0 * bulge * (1.0 - 2.0 * along0);  // d(bend)/d(along)\n  float along1 = along0 + (cross1 * dBend) / (L * (1.0 + dBend * dBend / (L * L)));\n\n  // Bristle-ragged edge: half-width gets chewed by 1D noise along the spine\n  float edgeNoise = fbm(vec2(along1 * bristleFreq, streakSeed * 7.3)) - 0.5;\n  float edgeNoise2 = fbm(vec2(along1 * bristleFreq * 2.3, streakSeed * 3.1 + 17.0)) - 0.5;\n  float edgeMod = 1.0 - bristleAmp * (0.6 + 0.4 * edgeNoise) * (0.5 + edgeNoise2);\n\n  // Width profile along the stroke\n  float shape = strokeShape(along1, shapeType);\n  float halfWNow = halfW * shape * edgeMod;\n\n  // Inside-segment coverage\n  float cov = 0.0;\n  if (along1 >= 0.0 && along1 <= 1.0 && halfWNow > 1e-6) {\n    float cn = abs(cross1) / halfWNow;\n    // razor-hard edge with tiny aa\n    cov = 1.0 - smoothstep(0.88, 1.02, cn);\n  }\n\n  // End-cap blobs (rounded tips, not perpendicular cuts)\n  float capA = 0.0, capB = 0.0;\n  {\n    vec2 capCenterA = a + norm * (bulge * 0.0); // at a\n    vec2 capCenterB = a + tang * L + norm * bend * 0.0 + norm * 0.0; // at b; bend is 0 at endpoints\n    capCenterB = b;\n    float endShapeA = strokeShape(0.02, shapeType);\n    float endShapeB = strokeShape(0.98, shapeType);\n    float rA = halfW * endShapeA * (0.9 + 0.2 * fbm(vec2(streakSeed * 13.0)));\n    float rB = halfW * endShapeB * (0.9 + 0.2 * fbm(vec2(streakSeed * 19.0 + 5.0)));\n    float dA = length(p - capCenterA);\n    float dB = length(p - capCenterB);\n    capA = 1.0 - smoothstep(rA * 0.85, rA * 1.05, dA);\n    capB = 1.0 - smoothstep(rB * 0.85, rB * 1.05, dB);\n    // Only apply caps if we're BEYOND the segment; otherwise the segment wins.\n    capA *= (along1 < 0.05) ? 1.0 : 0.0;\n    capB *= (along1 > 0.95) ? 1.0 : 0.0;\n  }\n\n  float coverage = max(cov, max(capA, capB));\n  if (coverage < 0.002) return noHit();\n\n  // Edge distance (for impasto later): 0 at edge, 1 at spine\n  float edgeDist = halfWNow > 1e-6 ? clamp(1.0 - abs(cross1) / halfWNow, 0.0, 1.0) : 0.0;\n\n  return StrokeHit(\n    coverage,\n    colAtMid,\n    clamp(along1, 0.0, 1.0),\n    halfWNow > 1e-6 ? cross1 / halfWNow : 0.0,\n    edgeDist\n  );\n}\n\n// Composite stroke over col with internal streaking + impasto edge highlight.\n//   streakAmp    — 0..0.2 how much internal streaks darken/lighten\n//   impastoAmp   — 0..1 edge catch-light strength\n//   hardness     — 0..1 how crisp the compositing transition is (1 = razor, 0 = creamy)\nvoid paintOver(inout vec3 col, StrokeHit s, float streakFreq, float streakAmp,\n               float impastoAmp, float hardness, float streakSeed) {\n  if (s.coverage < 0.002) return;\n  float strokeOpacity = clamp(uStrokeAmount, 0.0, 1.0);\n  if (strokeOpacity <= 0.001) return;\n  vec3 c = s.color;\n\n  // Internal streaks — fbm along spine, modulated by cross position. Gives\n  // the loaded-brush look: some bristles carry more pigment than others.\n  float streakA = fbm(vec2(s.alongT * streakFreq, s.crossN * 2.7 + streakSeed));\n  float streakB = fbm(vec2(s.alongT * streakFreq * 0.6 + streakSeed * 3.7, s.crossN * 4.1));\n  float streak = 0.6 * (streakA - 0.5) + 0.4 * (streakB - 0.5);\n  c *= 1.0 + streak * streakAmp * 2.0;\n\n  // Subtle value variance across width (hollow-center catch-light)\n  float crossShade = smoothstep(0.0, 0.4, s.edgeN) * (1.0 - smoothstep(0.65, 1.0, s.edgeN));\n  c *= 1.0 + crossShade * 0.05;\n\n  // Impasto edge highlight — bright rim on one side of the stroke\n  float rim = smoothstep(0.85, 1.0, 1.0 - s.edgeN) * step(0.0, s.crossN);\n  c += impastoAmp * rim * vec3(0.18, 0.15, 0.11);\n  // Shadow on the other side (darker, cooler)\n  float shadow = smoothstep(0.85, 1.0, 1.0 - s.edgeN) * step(0.0, -s.crossN);\n  c -= impastoAmp * shadow * 0.25 * vec3(0.10, 0.09, 0.07);\n\n  float softLimit = mix(0.35, 0.98, hardness);\n  float alpha = smoothstep(0.0, 1.0 - softLimit, s.coverage) * strokeOpacity;\n  col = mix(col, c, alpha);\n}\n\n// Best-of-9-neighbor placement: sample 3x3 surrounding cells and take the\n// stroke that covers this pixel most. Breaks the grid by per-cell jitter and\n// sparse density via noise thresholding.\nStrokeHit bestOil(vec2 p, float cellSize, float lenMul, float halfWMul,\n                  float jitterAmt, float density, int shapeType,\n                  float bristleAmp, vec2 flow, float t, float seed) {\n  vec2 cell = floor(p / cellSize);\n\n  StrokeHit best = noHit();\n  // 3x3 neighborhood\n  for (int dy = -1; dy <= 1; dy++) {\n    for (int dx = -1; dx <= 1; dx++) {\n      vec2 cc = cell + vec2(float(dx), float(dy));\n      vec2 hh = hash22(cc + seed) - 0.5;\n      // Density gate — noise threshold; sparse placement.\n      float gate = hash21(cc * 1.7 + seed * 0.3);\n      if (gate > density) continue;\n\n      vec2 center = (cc + 0.5 + hh * jitterAmt) * cellSize;\n\n      // Per-stroke direction: consume the layer-provided flow, then add only\n      // deterministic local perturbation so alternate stroke layers stay live.\n      vec2 f = safeDir(flow);\n      float angJ = (hash21(cc + seed + 11.0) - 0.5) * 0.9;  // +/- 0.45 rad\n      float localCurl = (fbm(center * (2.6 + seed * 0.11) + seed * 1.9) - 0.5) * 0.55 * uFlowCurl;\n      vec2 dir = rotateDir(f, angJ + localCurl);\n\n      float lenV = cellSize * lenMul * (0.65 + 0.55 * hash21(cc + seed + 23.0));\n      float halfW = cellSize * halfWMul * (0.70 + 0.55 * hash21(cc + seed + 41.0));\n      float bulge = (hash21(cc + seed + 53.0) - 0.5) * lenV * 0.35;\n\n      vec2 a = center - dir * (lenV * 0.5);\n      vec2 b = center + dir * (lenV * 0.5);\n\n      vec3 colMid = brokenColorJitter(\n        sampleBase(center, t),\n        hash21(cc + seed + 89.0),\n        hash21(cc * 2.3 + seed + 97.0),\n        1.0\n      );\n\n      StrokeHit h = curvedStroke(p, a, b, halfW, bulge, shapeType,\n                                 7.0, bristleAmp,\n                                 hash21(cc + seed + 67.0), colMid);\n      if (h.coverage > best.coverage) best = h;\n    }\n  }\n  return best;\n}\n\n// ── Crayon / oil-pastel — paper tooth × wax pigment ───────────────────────\n// Crayon is not strokes. It's pigment crumbs dragged across paper tooth.\n// Model: heavy 2D tooth noise at multiple scales, anisotropically stretched\n// along flow direction, multiplied into the base color. Add a slow \"waxy\n// film\" that slightly unifies hues, and occasional darker \"pressed\" spots\n// where the crayon dug in. NO straight segments.\nvec3 mediumOil_crayon(vec3 col, vec2 p, float t) {\n  vec2 flow = flowField(p, t);\n  float ang = atan(flow.y, flow.x);\n  float ca = cos(-ang), sa = sin(-ang);\n  vec2 pr = vec2(p.x * ca - p.y * sa, p.x * sa + p.y * ca);\n\n  // Anisotropic tooth — squished along flow, coarse cross flow.\n  float aniso = mix(0.45, 0.95, uStrokeAnisotropy);\n  float scale = max(uStrokeScale * 1.6, 180.0);\n\n  float t1 = vnoise(vec2(pr.x * scale * aniso, pr.y * scale));\n  float t2 = vnoise(vec2(pr.x * scale * aniso * 0.4, pr.y * scale * 0.4) + 11.0);\n  float t3 = vnoise(vec2(pr.x * scale * aniso * 2.1, pr.y * scale * 2.1) + 23.0);\n  float tooth = 0.55 * t1 + 0.30 * t2 + 0.15 * t3;\n  // Center at 0, amplify\n  tooth = (tooth - 0.5) * 1.4;\n\n  // Multiplicative darkening where tooth is low (pigment skipped paper valleys)\n  float lay = 1.0 + tooth * 0.32 * uStrokeAmount;\n  vec3 result = col * lay;\n\n  // Occasional pressed-in crumbs — rare darker crumbs\n  float crumbs = smoothstep(0.78, 0.95, vnoise(pr * scale * 3.0));\n  result *= 1.0 - crumbs * 0.18 * uStrokeAmount;\n\n  // Waxy highlight film — slight lightening on tooth peaks\n  float waxy = smoothstep(0.55, 0.85, t1);\n  result += waxy * 0.04 * vec3(1.0);\n\n  // Paper tooth overlay (subtler than oil's canvas)\n  float paperTooth = vnoise(p * 340.0) - 0.5;\n  result *= 1.0 + paperTooth * 0.14 * uCanvasGrain;\n\n  // Broken-color pigment: stable wax/pigment patches, not temporal flicker.\n  vec2 pigmentCell = floor(pr * max(scale * 0.18, 32.0));\n  float pigmentMask = smoothstep(0.28, 0.82, vnoise(pr * scale * 0.21 + 19.0));\n  result = brokenColorJitter(\n    result,\n    hash21(pigmentCell + 17.0),\n    hash21(pigmentCell * 2.1 + 31.0),\n    0.45 + 0.55 * pigmentMask\n  );\n\n  // Crayon is saturation-amplified\n  result = saturate3(result, 1.12);\n\n  return result;\n}\n\nvec3 mediumOil(vec3 col, vec2 p, float t) {\n  // Mode knobs (uStrokeMode):\n  //   0 oil         — balanced modern-abstract/palette-knife hybrid\n  //   1 knife       — palette-knife impasto: razor edges, heavy bristle/shadow\n  //   2 crayon      — soft-edged wax smudges on tooth (no straight segments)\n  //   3 brushwork   — thick bristle brush\n  int mode = uStrokeMode;\n\n  // Per-mode parameters\n  int  shapeType   = 0;     // tapered\n  float bristleAmp = 0.25;  // 0..0.5\n  float streakFreq = 9.0;\n  float streakAmp  = 0.09;\n  float impastoAmp = 0.9;\n  float hardness   = 0.80;  // edge compositing\n  float toothScale = 240.0;\n  float toothAmp   = 0.09;\n  float pigmentSat = 1.03;\n  float densityBig = 0.65;\n  float densityMed = 0.78;\n  float densitySml = 0.90;\n\n  if (mode == 1) {        // palette knife\n    shapeType = 3;        // flat, even\n    bristleAmp = 0.12;\n    streakFreq = 4.0;  streakAmp = 0.05;\n    impastoAmp = 1.6;\n    hardness   = 0.95;\n    toothAmp   = 0.04;\n    densityBig = 0.80; densityMed = 0.88; densitySml = 0.70;\n  } else if (mode == 2) { // crayon — handled specially below\n    return mediumOil_crayon(col, p, t);\n  } else if (mode == 3) { // thick brushwork\n    shapeType = 0;        // tapered\n    bristleAmp = 0.32;\n    streakFreq = 14.0; streakAmp = 0.14;\n    impastoAmp = 1.2;\n    hardness   = 0.85;\n    toothAmp   = 0.07;\n  }\n\n  // Scales & multipliers from uniforms\n  float baseScale = max(uStrokeScale * 0.006, 0.008);\n  // Three layers: big gestural, medium body, small dabs\n  float sBig = baseScale * 2.4;\n  float sMed = baseScale * 1.1;\n  float sSml = baseScale * 0.45;\n\n  float lenMulBig = mix(2.2, 3.8, uStrokeAnisotropy);\n  float widMulBig = mix(0.55, 0.32, uStrokeAnisotropy);\n  float lenMulMed = mix(2.0, 3.4, uStrokeAnisotropy);\n  float widMulMed = mix(0.50, 0.30, uStrokeAnisotropy);\n  float lenMulSml = mix(1.6, 2.6, uStrokeAnisotropy);\n  float widMulSml = mix(0.45, 0.32, uStrokeAnisotropy);\n\n  float jitterAmt = 0.75;   // large jitter — no grid\n  vec2 flow = flowField(p, t);\n\n  vec3 result = col;\n\n  // Layer 1 — big gestural strokes (sparse, shaping)\n  StrokeHit hBig = bestOil(p, sBig, lenMulBig, widMulBig, jitterAmt * 0.55,\n                           densityBig, shapeType, bristleAmp, flow, t, 1.3);\n  paintOver(result, hBig, streakFreq * 0.7, streakAmp,\n            uImpasto * impastoAmp * uStrokeAmount, hardness, 1.3);\n\n  // Layer 2 — medium body strokes\n  StrokeHit hMed = bestOil(p + vec2(11.3, 3.7), sMed, lenMulMed, widMulMed,\n                           jitterAmt, densityMed, shapeType, bristleAmp, flow, t, 2.7);\n  paintOver(result, hMed, streakFreq, streakAmp,\n            uImpasto * impastoAmp * uStrokeAmount, hardness, 2.7);\n\n  // Layer 3 — small dabs (more frequent, smaller)\n  int smlShape = (mode == 1) ? 2 : shapeType; // knife uses dabs for sparkle\n  StrokeHit hSml = bestOil(p + vec2(-5.1, 8.4), sSml, lenMulSml, widMulSml,\n                           jitterAmt * 1.3, densitySml, smlShape,\n                           bristleAmp * 0.85, flow, t, 4.1);\n  paintOver(result, hSml, streakFreq * 1.4, streakAmp * 0.8,\n            uImpasto * impastoAmp * 0.65 * uStrokeAmount, hardness, 4.1);\n\n  // Layer 4 — fill dabs (very dense, very small) — covers bald spots\n  float sFill = baseScale * 0.22;\n  float lenMulFill = mix(1.4, 2.0, uStrokeAnisotropy);\n  float widMulFill = mix(0.50, 0.38, uStrokeAnisotropy);\n  int fillShape = (mode == 1) ? 3 : 2; // knife=even, others=dab (round fills)\n  StrokeHit hFill = bestOil(p + vec2(3.9, -6.2), sFill, lenMulFill, widMulFill,\n                            jitterAmt * 1.5, 0.95, fillShape,\n                            bristleAmp * 0.6, flow, t, 8.9);\n  paintOver(result, hFill, streakFreq * 1.8, streakAmp * 0.6,\n            uImpasto * impastoAmp * 0.4 * uStrokeAmount, hardness * 0.9, 8.9);\n\n  // Optional crosshatch layer\n  if (uStrokeLayers == 2) {\n    vec2 flow2 = vec2(-flow.y, flow.x);\n    StrokeHit hX = bestOil(p + vec2(7.3, -2.1), sMed, lenMulMed * 0.9, widMulMed,\n                           jitterAmt, densityMed * 0.7, shapeType, bristleAmp, flow2, t, 6.5);\n    paintOver(result, hX, streakFreq, streakAmp * 0.85,\n              uImpasto * impastoAmp * 0.55 * uStrokeAmount, hardness, 6.5);\n  }\n\n  // Canvas tooth — linen weave\n  float tooth1 = vnoise(p * toothScale);\n  float tooth2 = vnoise(p * toothScale * vec2(0.6, 2.4) + 37.0);\n  float tooth  = (0.6 * tooth1 + 0.4 * tooth2) - 0.5;\n  result *= 1.0 + tooth * toothAmp * uCanvasGrain;\n\n  // Pigment saturation boost\n  result = saturate3(result, pigmentSat);\n\n  return result;\n}\n\n// ── Main ──────────────────────────────────────────────────────────────────\nvoid main() {\n  // Normalized 0..1 coordinates for nuclei, domain warp, and medium sampling.\n  vec2 uv = vUv;\n  vec2 pN = uv;\n\n  float t = uTime;\n\n  // Warp in pN space\n  vec2 p_warp = domainWarp(pN, t);\n\n  // Composition\n  float paletteId; float valueMod;\n  nucleiField(p_warp, t, paletteId, valueMod);\n  vec3 col = samplePalette(paletteId);\n  col *= 1.0 + uValueVariance * valueMod;\n\n  // Breath — slow global luminance wobble\n  float breath = sin(t * 6.2831 / max(uBreathPeriod, 1.0));\n  col *= 1.0 + uBreathDepth * breath * 0.5;\n\n  // Medium\n  if (uMedium == 1) col = mediumPastel(col, pN, t);\n  else if (uMedium == 2) col = mediumWatercolor(col, pN, t);\n  else if (uMedium == 3) col = mediumOil(col, pN, t);\n\n  // Saturation trim\n  col = saturate3(col, uSaturation);\n\n  // Tonemap + film grain\n  col = aces(col);\n  float grain = hash21(gl_FragCoord.xy + t * 17.0);\n  col += (grain - 0.5) * uPaperGrain;\n\n  col = clamp(col * 0.985 + 0.008, 0.0, 1.0);\n  fragColor = vec4(col * uAlpha, uAlpha);\n}\n";
@@ -144,14 +144,14 @@ var R = {
 	knife: 1,
 	crayon: 2,
 	chunky: 3
-}, H = .22, U = .18, W = .992;
-function G(e) {
+}, H = .22, U = .18, W = .992, G = .001;
+function K(e) {
 	return e.mode === "capture" ? !0 : e.initStrategy === "eager";
 }
-function K(e) {
+function q(e) {
 	return typeof e.preserveDrawingBuffer == "boolean" ? e.preserveDrawingBuffer : e.mode === "capture";
 }
-function q(e, t, n) {
+function J(e, t, n) {
 	let r = e.createShader(t);
 	if (e.shaderSource(r, n), e.compileShader(r), !e.getShaderParameter(r, e.COMPILE_STATUS)) {
 		let t = e.getShaderInfoLog(r) ?? "unknown";
@@ -159,7 +159,7 @@ function q(e, t, n) {
 	}
 	return r;
 }
-function J(e, t, n) {
+function Y(e, t, n) {
 	let r = e.createProgram();
 	if (e.attachShader(r, t), e.attachShader(r, n), e.linkProgram(r), !e.getProgramParameter(r, e.LINK_STATUS)) {
 		let t = e.getProgramInfoLog(r) ?? "unknown";
@@ -167,9 +167,25 @@ function J(e, t, n) {
 	}
 	return r;
 }
-var Y = /* @__PURE__ */ "uTime.uPalette.uStopCount.uNucleiCount.uNucleiPos.uNucleiRadius.uNucleiPaletteBias.uNucleiValueBias.uNucleiDriftRadius.uNucleiDriftPhase.uNucleiElong.uNucleiAngle.uSoftmaxBeta.uValueVariance.uWarpAmount.uWarpScale.uWarpDrift.uWarpMode.uNoiseOctaves.uMedium.uFlowPattern.uFlowFocal.uFlowAngle.uFlowCurl.uCursor.uCursorStrength.uCursorRadius.uStrokeAmount.uStrokeScale.uStrokeAnisotropy.uStrokeLayers.uStrokeMode.uWetEdge.uGranulation.uImpasto.uBrokenColor.uCanvasGrain.uNucleiDrift.uPaletteDrift.uBreathDepth.uBreathPeriod.uSaturation.uPaperGrain.uAlpha".split(".");
+var ee = /* @__PURE__ */ "uTime.uPalette.uStopCount.uNucleiCount.uNucleiPos.uNucleiRadius.uNucleiPaletteBias.uNucleiValueBias.uNucleiDriftRadius.uNucleiDriftPhase.uNucleiElong.uNucleiAngle.uSoftmaxBeta.uValueVariance.uWarpAmount.uWarpScale.uWarpDrift.uWarpMode.uNoiseOctaves.uMedium.uFlowPattern.uFlowFocal.uFlowAngle.uFlowCurl.uCursor.uCursorStrength.uCursorRadius.uStrokeAmount.uStrokeScale.uStrokeAnisotropy.uStrokeLayers.uStrokeMode.uWetEdge.uGranulation.uImpasto.uBrokenColor.uCanvasGrain.uNucleiDrift.uPaletteDrift.uBreathDepth.uBreathPeriod.uSaturation.uPaperGrain.uAlpha".split(".");
 function X(e, t, n = {}) {
-	let r = K(n), i = t, a = n.mode !== "capture", o = typeof window < "u" && window.matchMedia ? window.matchMedia("(prefers-reduced-motion: reduce)").matches : !1, s = performance.now(), c = {
+	let r = q(n), i = t, a = /* @__PURE__ */ new Set();
+	n.mode === "capture" && a.add("manual");
+	let o = () => a.size === 0, s = typeof window < "u" && window.matchMedia ? window.matchMedia("(prefers-reduced-motion: reduce)").matches : !1, c = performance.now(), l = 0, u = null;
+	function d(e) {
+		let t = o();
+		a.add(e), t && !o() && (cancelAnimationFrame(l), l = 0);
+	}
+	function f(e) {
+		let t = !o();
+		a.delete(e), t && o() && u && (c = performance.now() - 1e3, u());
+	}
+	let p = typeof document < "u";
+	function m() {
+		document.hidden ? d("tab-hidden") : f("tab-hidden");
+	}
+	p && document.addEventListener("visibilitychange", m);
+	let h = {
 		x: .5,
 		y: .5,
 		targetX: .5,
@@ -177,21 +193,21 @@ function X(e, t, n = {}) {
 		strength: 0,
 		targetStrength: 0,
 		radius: .25
-	}, l = null, u = !1;
-	function d(e, t, n = .8) {
-		c.targetX = e, c.targetY = t, c.targetStrength = n;
+	}, g = null, _ = !1;
+	function b(e, t, n = .8) {
+		h.targetX = e, h.targetY = t, h.targetStrength = n, g?.wake();
 	}
-	function f() {
-		c.targetStrength = 0;
+	function x() {
+		h.targetStrength = 0, g?.wake();
 	}
-	function p(e) {
-		c.radius = e;
+	function S(e) {
+		h.radius = e, g?.wake();
 	}
-	function m(e) {
-		o = e;
+	function C(e) {
+		s = e, g?.wake();
 	}
-	function h() {
-		if (l || u) return;
+	function w() {
+		if (g || _) return;
 		let t = e.getContext("webgl2", {
 			antialias: !1,
 			alpha: !0,
@@ -199,12 +215,12 @@ function X(e, t, n = {}) {
 			preserveDrawingBuffer: r
 		});
 		if (!t) throw Error("[Aurora] WebGL2 unavailable");
-		let n = q(t, t.VERTEX_SHADER, v), d = q(t, t.FRAGMENT_SHADER, y), f = J(t, n, d);
-		t.useProgram(f);
-		let p = t.createVertexArray();
-		t.bindVertexArray(p);
-		let m = t.createBuffer();
-		t.bindBuffer(t.ARRAY_BUFFER, m), t.bufferData(t.ARRAY_BUFFER, new Float32Array([
+		let n = J(t, t.VERTEX_SHADER, v), a = J(t, t.FRAGMENT_SHADER, y), d = Y(t, n, a);
+		t.useProgram(d);
+		let f = t.createVertexArray();
+		t.bindVertexArray(f);
+		let p = t.createBuffer();
+		t.bindBuffer(t.ARRAY_BUFFER, p), t.bufferData(t.ARRAY_BUFFER, new Float32Array([
 			-1,
 			-1,
 			3,
@@ -212,19 +228,19 @@ function X(e, t, n = {}) {
 			-1,
 			3
 		]), t.STATIC_DRAW);
-		let h = t.getAttribLocation(f, "aPos");
-		t.enableVertexAttribArray(h), t.vertexAttribPointer(h, 2, t.FLOAT, !1, 0, 0);
-		let g = {};
-		for (let e of Y) g[e] = t.getUniformLocation(f, e);
-		function _() {
+		let m = t.getAttribLocation(d, "aPos");
+		t.enableVertexAttribArray(m), t.vertexAttribPointer(m, 2, t.FLOAT, !1, 0, 0);
+		let b = {};
+		for (let e of ee) b[e] = t.getUniformLocation(d, e);
+		function x() {
 			let n = Math.min(window.devicePixelRatio || 1, 2), r = e.clientWidth || e.parentElement?.clientWidth || 1, i = e.clientHeight || e.parentElement?.clientHeight || 1, a = Math.max(1, Math.floor(r * n)), o = Math.max(1, Math.floor(i * n));
-			e.width = a, e.height = o, t.viewport(0, 0, a, o), t.useProgram(f);
+			e.width = a, e.height = o, t.viewport(0, 0, a, o), t.useProgram(d);
 		}
-		let b = new ResizeObserver(() => _());
-		b.observe(e), requestAnimationFrame(() => {
-			_(), requestAnimationFrame(_);
+		let S = new ResizeObserver(() => x());
+		S.observe(e), requestAnimationFrame(() => {
+			x(), requestAnimationFrame(x);
 		});
-		let x = {
+		let C = {
 			palette: new Float32Array(24),
 			pos: new Float32Array(12),
 			rad: new Float32Array(6),
@@ -235,71 +251,68 @@ function X(e, t, n = {}) {
 			elong: new Float32Array(6),
 			angle: new Float32Array(6)
 		};
-		function S(e) {
-			i = e, t.useProgram(f), j(e.palette, 8, x.palette), t.uniform3fv(g.uPalette, x.palette), t.uniform1i(g.uStopCount, Math.min(e.palette.length, 8));
+		function w(e) {
+			i = e, t.useProgram(d), j(e.palette, 8, C.palette), t.uniform3fv(b.uPalette, C.palette), t.uniform1i(b.uStopCount, Math.min(e.palette.length, 8));
 			let n = Math.min(e.nuclei.length, 6);
-			t.uniform1i(g.uNucleiCount, n);
+			t.uniform1i(b.uNucleiCount, n);
 			for (let t = 0; t < n; t++) {
 				let n = e.nuclei[t];
-				x.pos[t * 2 + 0] = n.x, x.pos[t * 2 + 1] = 1 - n.y, x.rad[t] = n.radius, x.pb[t] = n.paletteBias, x.vb[t] = n.valueBias, x.dr[t] = n.driftRadius, x.dp[t] = n.driftPhase, x.elong[t] = n.elongation ?? 1, x.angle[t] = -(n.angle ?? 0) * Math.PI / 180;
+				C.pos[t * 2 + 0] = n.x, C.pos[t * 2 + 1] = 1 - n.y, C.rad[t] = n.radius, C.pb[t] = n.paletteBias, C.vb[t] = n.valueBias, C.dr[t] = n.driftRadius, C.dp[t] = n.driftPhase, C.elong[t] = n.elongation ?? 1, C.angle[t] = -(n.angle ?? 0) * Math.PI / 180;
 			}
-			for (let e = n; e < 6; e++) x.pos[e * 2 + 0] = 0, x.pos[e * 2 + 1] = 0, x.rad[e] = 0, x.pb[e] = 0, x.vb[e] = 0, x.dr[e] = 0, x.dp[e] = 0, x.elong[e] = 1, x.angle[e] = 0;
-			t.uniform2fv(g.uNucleiPos, x.pos), t.uniform1fv(g.uNucleiRadius, x.rad), t.uniform1fv(g.uNucleiPaletteBias, x.pb), t.uniform1fv(g.uNucleiValueBias, x.vb), t.uniform1fv(g.uNucleiDriftRadius, x.dr), t.uniform1fv(g.uNucleiDriftPhase, x.dp), t.uniform1fv(g.uNucleiElong, x.elong), t.uniform1fv(g.uNucleiAngle, x.angle), t.uniform1f(g.uSoftmaxBeta, e.softmaxBeta), t.uniform1f(g.uValueVariance, e.valueVariance), t.uniform1f(g.uWarpAmount, e.warpAmount), t.uniform1f(g.uWarpScale, e.warpScale), t.uniform1f(g.uWarpDrift, e.warpDrift), t.uniform1i(g.uWarpMode, B[e.warpMode]), t.uniform1i(g.uNoiseOctaves, e.noiseOctaves), t.uniform1i(g.uMedium, R[e.medium]), t.uniform1i(g.uFlowPattern, z[e.flow.pattern]), t.uniform2f(g.uFlowFocal, e.flow.focalX, 1 - e.flow.focalY), t.uniform1f(g.uFlowAngle, e.flow.angle), t.uniform1f(g.uFlowCurl, e.flow.curl), t.uniform2f(g.uCursor, c.x, 1 - c.y), t.uniform1f(g.uCursorStrength, c.strength), t.uniform1f(g.uCursorRadius, c.radius), t.uniform1f(g.uStrokeAmount, e.strokeAmount), t.uniform1f(g.uStrokeScale, e.strokeScale), t.uniform1f(g.uStrokeAnisotropy, e.strokeAnisotropy), t.uniform1i(g.uStrokeLayers, e.strokeLayers), t.uniform1i(g.uStrokeMode, V[e.strokeMode]), t.uniform1f(g.uWetEdge, e.wetEdge), t.uniform1f(g.uGranulation, e.granulation), t.uniform1f(g.uImpasto, e.impasto), t.uniform1f(g.uBrokenColor, e.brokenColor), t.uniform1f(g.uCanvasGrain, e.canvasGrain), t.uniform1f(g.uNucleiDrift, e.nucleiDrift), t.uniform1f(g.uPaletteDrift, e.paletteDrift), t.uniform1f(g.uBreathDepth, e.breathDepth), t.uniform1f(g.uBreathPeriod, e.breathPeriod), t.uniform1f(g.uSaturation, e.saturation), t.uniform1f(g.uPaperGrain, e.paperGrain), t.uniform1f(g.uAlpha, e.alpha);
-		}
-		S(i), _(), t.clearColor(0, 0, 0, 0), t.disable(t.DEPTH_TEST), t.enable(t.BLEND), t.blendFunc(t.ONE, t.ONE_MINUS_SRC_ALPHA);
-		let C = 0;
-		function w() {
-			c.x += (c.targetX - c.x) * H, c.y += (c.targetY - c.y) * H, c.strength += (c.targetStrength - c.strength) * U, c.targetStrength *= W;
+			for (let e = n; e < 6; e++) C.pos[e * 2 + 0] = 0, C.pos[e * 2 + 1] = 0, C.rad[e] = 0, C.pb[e] = 0, C.vb[e] = 0, C.dr[e] = 0, C.dp[e] = 0, C.elong[e] = 1, C.angle[e] = 0;
+			t.uniform2fv(b.uNucleiPos, C.pos), t.uniform1fv(b.uNucleiRadius, C.rad), t.uniform1fv(b.uNucleiPaletteBias, C.pb), t.uniform1fv(b.uNucleiValueBias, C.vb), t.uniform1fv(b.uNucleiDriftRadius, C.dr), t.uniform1fv(b.uNucleiDriftPhase, C.dp), t.uniform1fv(b.uNucleiElong, C.elong), t.uniform1fv(b.uNucleiAngle, C.angle), t.uniform1f(b.uSoftmaxBeta, e.softmaxBeta), t.uniform1f(b.uValueVariance, e.valueVariance), t.uniform1f(b.uWarpAmount, e.warpAmount), t.uniform1f(b.uWarpScale, e.warpScale), t.uniform1f(b.uWarpDrift, e.warpDrift), t.uniform1i(b.uWarpMode, B[e.warpMode]), t.uniform1i(b.uNoiseOctaves, e.noiseOctaves), t.uniform1i(b.uMedium, R[e.medium]), t.uniform1i(b.uFlowPattern, z[e.flow.pattern]), t.uniform2f(b.uFlowFocal, e.flow.focalX, 1 - e.flow.focalY), t.uniform1f(b.uFlowAngle, e.flow.angle), t.uniform1f(b.uFlowCurl, e.flow.curl), t.uniform2f(b.uCursor, h.x, 1 - h.y), t.uniform1f(b.uCursorStrength, h.strength), t.uniform1f(b.uCursorRadius, h.radius), t.uniform1f(b.uStrokeAmount, e.strokeAmount), t.uniform1f(b.uStrokeScale, e.strokeScale), t.uniform1f(b.uStrokeAnisotropy, e.strokeAnisotropy), t.uniform1i(b.uStrokeLayers, e.strokeLayers), t.uniform1i(b.uStrokeMode, V[e.strokeMode]), t.uniform1f(b.uWetEdge, e.wetEdge), t.uniform1f(b.uGranulation, e.granulation), t.uniform1f(b.uImpasto, e.impasto), t.uniform1f(b.uBrokenColor, e.brokenColor), t.uniform1f(b.uCanvasGrain, e.canvasGrain), t.uniform1f(b.uNucleiDrift, e.nucleiDrift), t.uniform1f(b.uPaletteDrift, e.paletteDrift), t.uniform1f(b.uBreathDepth, e.breathDepth), t.uniform1f(b.uBreathPeriod, e.breathPeriod), t.uniform1f(b.uSaturation, e.saturation), t.uniform1f(b.uPaperGrain, e.paperGrain), t.uniform1f(b.uAlpha, e.alpha);
 		}
-		function T(e) {
-			t.useProgram(f), t.uniform2f(g.uCursor, c.x, 1 - c.y), t.uniform1f(g.uCursorStrength, c.strength), t.uniform1f(g.uCursorRadius, c.radius), t.uniform1f(g.uTime, e), t.clear(t.COLOR_BUFFER_BIT), t.drawArrays(t.TRIANGLES, 0, 3);
+		w(i), x(), t.clearColor(0, 0, 0, 0), t.disable(t.DEPTH_TEST), t.enable(t.BLEND), t.blendFunc(t.ONE, t.ONE_MINUS_SRC_ALPHA);
+		function T() {
+			h.x += (h.targetX - h.x) * H, h.y += (h.targetY - h.y) * H, h.strength += (h.targetStrength - h.strength) * U, h.targetStrength *= W;
 		}
-		function E() {
-			if (!a) return;
-			let e = o ? 3.7 : (performance.now() - s) / 1e3;
-			w(), T(e), C = requestAnimationFrame(E);
+		function E(e) {
+			t.useProgram(d), t.uniform2f(b.uCursor, h.x, 1 - h.y), t.uniform1f(b.uCursorStrength, h.strength), t.uniform1f(b.uCursorRadius, h.radius), t.uniform1f(b.uTime, e), t.clear(t.COLOR_BUFFER_BIT), t.drawArrays(t.TRIANGLES, 0, 3);
 		}
-		a && (C = requestAnimationFrame(E));
-		function D(e) {
-			T(e);
+		function D() {
+			return s ? !1 : i.nucleiDrift !== 0 || i.paletteDrift !== 0 || i.breathDepth !== 0 || i.warpDrift !== 0 ? !0 : h.targetStrength > G || h.strength > G || Math.abs(h.x - h.targetX) > G || Math.abs(h.y - h.targetY) > G;
 		}
 		function O() {
-			a = !1, cancelAnimationFrame(C);
+			if (!o()) return;
+			let e = s ? 3.7 : (performance.now() - c) / 1e3;
+			T(), E(e), l = D() ? requestAnimationFrame(O) : 0;
 		}
+		u = O, o() && (l = requestAnimationFrame(O));
 		function k() {
-			a || (a = !0, s = performance.now() - 1e3, E());
+			o() && !l && (l = requestAnimationFrame(O));
 		}
-		function A() {
-			a = !1, cancelAnimationFrame(C), b.disconnect(), t.deleteProgram(f), t.deleteShader(n), t.deleteShader(d), t.deleteBuffer(m), t.deleteVertexArray(p);
+		function A(e) {
+			E(e);
+		}
+		function M() {
+			cancelAnimationFrame(l), l = 0, u = null, S.disconnect(), t.deleteProgram(d), t.deleteShader(n), t.deleteShader(a), t.deleteBuffer(p), t.deleteVertexArray(f);
 			let e = t.getExtension("WEBGL_lose_context");
 			e && e.loseContext();
 		}
-		l = {
-			setConfig: S,
-			renderAt: D,
-			pause: O,
-			resume: k,
-			dispose: A
+		g = {
+			setConfig: w,
+			renderAt: A,
+			wake: k,
+			dispose: M
 		};
 	}
-	return G(n) && h(), {
-		arm: h,
+	function T() {
+		p && document.removeEventListener("visibilitychange", m), a.clear();
+	}
+	return K(n) && w(), {
+		arm: w,
 		update: (e) => {
-			i = e, l?.setConfig(e);
+			i = e, g?.setConfig(e), g?.wake();
 		},
-		setCursor: d,
-		clearCursor: f,
-		setCursorRadius: p,
-		setReducedMotion: m,
-		pause: () => {
-			a = !1, l?.pause();
-		},
-		resume: () => {
-			a = !0, l?.resume();
-		},
-		renderAt: (e) => l?.renderAt(e),
+		setCursor: b,
+		clearCursor: x,
+		setCursorRadius: S,
+		setReducedMotion: C,
+		pause: (e = "manual") => d(e),
+		resume: (e = "manual") => f(e),
+		renderAt: (e) => g?.renderAt(e),
 		dispose: () => {
-			l ? l.dispose() : u = !0;
+			g ? g.dispose() : _ = !0, T();
 		}
 	};
 }
@@ -310,7 +323,7 @@ function Z(e) {
 }
 //#endregion
 //#region src/components/custom/aurora/composables/useAurora.ts
-function ee(e) {
+function te(e) {
 	if (typeof window > "u") return () => {};
 	if (typeof window.requestIdleCallback == "function") {
 		let t = window.requestIdleCallback(() => e(), { timeout: 2e3 });
@@ -369,12 +382,12 @@ function Q(e, t, n = {}, r = {}) {
 			return;
 		}
 		p = i(e, {
-			pause: () => s?.pause(),
-			resume: () => s?.resume()
-		});
+			pause: () => s?.pause("off-screen"),
+			resume: () => s?.resume("off-screen")
+		}, { pauseWhenHidden: !1 });
 		let r = p.isIntersecting;
 		l = _(r, (e) => {
-			!e || v || u || (u = ee(() => {
+			!e || v || u || (u = te(() => {
 				u = null, r.value && C();
 			}));
 		}, { immediate: !0 });
@@ -400,7 +413,7 @@ function $(e) {
 }
 //#endregion
 //#region src/components/custom/aurora/Aurora.vue
-var te = /* @__PURE__ */ e(/* @__PURE__ */ c({
+var ne = /* @__PURE__ */ e(/* @__PURE__ */ c({
 	__name: "Aurora",
 	props: {
 		config: { default: () => r },
@@ -441,7 +454,7 @@ var te = /* @__PURE__ */ e(/* @__PURE__ */ c({
 }), [["__scopeId", "data-v-80ea8f7d"]]);
 //#endregion
 //#region src/components/custom/aurora/composables/useCursorInteraction.ts
-function ne(e, t, n) {
+function re(e, t, n) {
 	let r = Z(t), i = n.hitFraction ?? .35, a = null, o = null;
 	function s(e, t) {
 		let n = t.getBoundingClientRect();
@@ -538,4 +551,4 @@ function ne(e, t, n) {
 	}), { isDragging: () => a };
 }
 //#endregion
-export { te as Aurora, r as DEFAULT_AURORA_CONFIG, t as MAX_NUCLEI, n as MAX_STOPS, X as createAurora, L as cssToOklch, j as flattenPalette, P as hexToOklchStop, N as oklchStopToHex, A as oklchToLinear, M as paletteToCssGradient, $ as resolveRenderMode, Q as useAurora, ne as useCursorInteraction };
+export { ne as Aurora, r as DEFAULT_AURORA_CONFIG, t as MAX_NUCLEI, n as MAX_STOPS, X as createAurora, L as cssToOklch, j as flattenPalette, P as hexToOklchStop, N as oklchStopToHex, A as oklchToLinear, M as paletteToCssGradient, $ as resolveRenderMode, Q as useAurora, re as useCursorInteraction };

package/dist/badge.js

@@ -1,2 +1,2 @@
-import { n as e, t } from "./badge-BbxVKZfw.js";
+import { n as e, t } from "./badge-x46my_Fo.js";
 export { e as Badge, t as badgeVariants };

package/dist/{button-BlOW34DT.js → button-C0aHmBbt.js}

@@ -24,6 +24,7 @@ var u = /* @__PURE__ */ n({
 		return (u, f) => (i(), t(o(c), {
 			as: n.as,
 			"as-child": n.asChild,
+			"data-size": n.size,
 			class: r(o(e)(o(d)({
 				variant: n.variant,
 				size: n.size
@@ -34,6 +35,7 @@ var u = /* @__PURE__ */ n({
 		}, 8, [
 			"as",
 			"as-child",
+			"data-size",
 			"class"
 		]));
 	}

package/dist/button.js

@@ -1,2 +1,2 @@
-import { n as e, t } from "./button-BlOW34DT.js";
+import { n as e, t } from "./button-C0aHmBbt.js";
 export { e as Button, t as buttonVariants };

package/dist/card.js

@@ -1,2 +1,2 @@
-import { a as e, i as t, n, o as r, r as i, t as a } from "./CardFooter-Yi0xtLLd.js";
+import { a as e, i as t, n, o as r, r as i, t as a } from "./CardFooter-CSGcJkqa.js";
 export { r as Card, n as CardContent, i as CardDescription, a as CardFooter, e as CardHeader, t as CardTitle };

package/dist/carousel.js

@@ -3,7 +3,7 @@ import { t } from "./createLucideIcon-Bn9a1b70.js";
 import { t as n } from "./chevron-down-DILQA1t6.js";
 import { t as r } from "./chevron-right-fS7fal2t.js";
 import { t as i } from "./chevron-up-BtYjYQOS.js";
-import { n as a } from "./button-BlOW34DT.js";
+import { n as a } from "./button-C0aHmBbt.js";
 import { Fragment as o, computed as s, createBlock as c, createCommentVNode as l, createElementBlock as u, createElementVNode as d, createVNode as f, defineComponent as p, mergeProps as m, normalizeClass as h, onMounted as g, openBlock as _, ref as v, renderList as y, renderSlot as b, resolveDynamicComponent as x, toDisplayString as S, unref as C, watch as w, withCtx as T } from "vue";
 import { createInjectionState as E } from "@vueuse/core";
 import D from "embla-carousel-vue";

package/dist/collapsible.js

@@ -1,2 +1,2 @@
-import { n as e, r as t, t as n } from "./CollapsibleContent-DHRuXE3P.js";
+import { n as e, r as t, t as n } from "./CollapsibleContent-CVMOcYlV.js";
 export { t as Collapsible, n as CollapsibleContent, e as CollapsibleTrigger };

package/dist/command.js

@@ -1,2 +1,2 @@
-import { a as e, c as t, i as n, l as r, n as i, o as a, r as o, s, t as c } from "./CommandShortcut-_INFUMu6.js";
+import { a as e, c as t, i as n, l as r, n as i, o as a, r as o, s, t as c } from "./CommandShortcut-DWT19a2Y.js";
 export { r as Command, t as CommandDialog, s as CommandEmpty, a as CommandGroup, e as CommandInput, n as CommandItem, o as CommandList, i as CommandSeparator, c as CommandShortcut };

package/dist/components/custom/aurora/composables/runtime.d.ts

@@ -10,6 +10,18 @@
  */
 import { type AuroraConfig, type AuroraInstance } from "../presets";
 export type AuroraRuntimeMode = "live" | "capture";
+/**
+ * The three independent reasons the RAF loop may be suspended. The runtime
+ * tracks them in a `Set<SuspendReason>` rather than one boolean, so the loop
+ * runs IFF the set is empty and each reason is cleared ONLY by the source that
+ * set it. This makes resume-while-still-suspended structurally unreachable — a
+ * `resume("tab-hidden")` cannot lift an `"off-screen"` suspension.
+ *
+ * - `"tab-hidden"` — the runtime's own `document.visibilitychange` owner.
+ * - `"off-screen"` — viewport-intersection, driven by `useIntersectionPause`.
+ * - `"manual"` — the public `pause()`/`resume()` API (and capture-mode seed).
+ */
+export type SuspendReason = "tab-hidden" | "off-screen" | "manual";
 /**
  * When the expensive WebGL path (context creation, shader compile + GPU link,
  * first uniform upload, rAF arm) actually runs.
@@ -51,4 +63,15 @@ export interface AuroraRuntimeOptions {
      */
     onInitError?: (err: Error) => void;
 }
-export declare function createAurora(canvas: HTMLCanvasElement, initial: AuroraConfig, options?: AuroraRuntimeOptions): AuroraInstance;
+/**
+ * The concrete `createAurora` return shape. It IS an {@link AuroraInstance}
+ * (structurally assignable — every member matches) but widens `pause`/`resume`
+ * to carry an optional {@link SuspendReason}, defaulting to `"manual"`. The
+ * Vue wrapper passes `"off-screen"` for the intersection seam; a bare
+ * `pause()`/`resume()` reads identically to the `AuroraInstance` contract.
+ */
+export interface AuroraRuntime extends Omit<AuroraInstance, "pause" | "resume"> {
+    pause(reason?: SuspendReason): void;
+    resume(reason?: SuspendReason): void;
+}
+export declare function createAurora(canvas: HTMLCanvasElement, initial: AuroraConfig, options?: AuroraRuntimeOptions): AuroraRuntime;

package/dist/components/custom/dialog-native/GlassDialogNative.vue.d.ts

@@ -0,0 +1,57 @@
+/**
+ * <GlassDialogNative> — the native-`<dialog>` glass pilot (AQ.W6 §Design 5).
+ *
+ * A real `<dialog class="glass-top-layer">` top-layer surface. Entry/exit is
+ * PURE CSS from the `.glass-top-layer` grammar (`@starting-style` + `overlay` +
+ * `allow-discrete` + a glass `::backdrop`; animations.css §TOP-LAYER) — no
+ * per-frame JS, no `useSpringMount`. Light-dismiss is the native `closedby="any"`
+ * with a ≤ 12-LOC backdrop-click shim as the feature-detected fallback for
+ * engines without `HTMLDialogElement.closedBy`.
+ *
+ * DISPOSITION (W8 overfitting audit): this is the simple-confirm/settings PILOT
+ * only — one heading, optional short form, a close action. reka-ui `Dialog` is
+ * UNCHANGED and stays the default for every compound focus-trap case (nested
+ * focus zones, async content, the drag-dismiss `spring` opt-in). The pilot ships
+ * gated to a demo story (its consumer) pending the muster J.W6 ≥2-consumer
+ * adoption; it is NOT on the public barrel or a flat subpath yet (no overfit
+ * surface). `commandfor`/`command` (Baseline LIMITED) is the PREFERRED trigger
+ * wiring where supported; the JS `showModal()`/`close()` path (exposed below)
+ * is the kept default for non-supporting targets.
+ *
+ * Baseline: `<dialog>` + `showModal` = Widely; `dialog-closedby` = Newly
+ * (≤ 20-LOC shim fallback); `invoker-commands` (`commandfor`) = LIMITED
+ * (progressive — the JS open path stays default).
+ */
+type __VLS_Props = {
+    /** Light-dismiss on backdrop/Esc — `closedby="any"`. Default true. */
+    lightDismiss?: boolean;
+    /** id so a sibling `<button commandfor=… command="show-modal">` can
+     *  target this dialog (the declarative-open path). */
+    id?: string;
+    /** `aria-labelledby` target — the id of the consumer's heading. */
+    labelledby?: string;
+    /** Class merged onto the `<dialog>` surface. */
+    class?: string;
+};
+declare function showModal(): void;
+declare function close(returnValue?: string): void;
+declare var __VLS_1: {
+    close: typeof close;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
+    showModal: typeof showModal;
+    close: typeof close;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    lightDismiss: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/custom/dialog-native/index.d.ts

@@ -0,0 +1 @@
+export { default as GlassDialogNative } from "./GlassDialogNative.vue";

package/dist/components/custom/dock/composables/useLayerTransition.d.ts

@@ -19,16 +19,26 @@ export interface UseLayerTransitionReturn {
     leavingLayer: Ref<string | null>;
 }
 /**
- * Coordinates simultaneous crossfade + FLIP size animation for
- * grid-stacked layer containers. Reusable at any nesting level.
+ * Coordinates the crossfade + size animation between grid-stacked dock layer
+ * panes. Reusable at any nesting level (the inner `<DockLayerGroup>` pair AND
+ * the outer GlassDock collapsed↔expanded pair).
  *
- * Algorithm on activeLayer change:
- * 1. Capture current container size
- * 2. Pin container to that size
- * 3. Swap classes: old layer → leaving (absolute, fading out),
- *    new layer → active (relative, fading in)
- * 4. nextTick: measure new natural size, re-pin to old
- * 5. Animate to new size via CSS transition
- * 6. On transitionend(size), clear inline size
+ * AQ.W6 §Design 7 — the swap FORKS on View-Transitions support:
+ *
+ * - **Native path** (`document.startViewTransition` present): the layer swap is
+ *   wrapped in `startViewTransition(() => mutate())`. The browser snapshots the
+ *   container + panes (tagged `view-transition-name` in `dock.css`) and morphs
+ *   the size + crossfades the pane content with ZERO `getBoundingClientRect`
+ *   reads. No pin/measure/re-pin dance, no inline size, no rAF.
+ *
+ * - **Fallback path** (no `startViewTransition`): the existing axis-aware FLIP
+ *   runs verbatim, KEPT as the sole feature-detected fallback (no alias — one
+ *   path or the other runs per swap, never both):
+ *   1. Capture current container size
+ *   2. Pin container to that size
+ *   3. Swap classes: old layer → leaving, new layer → active
+ *   4. nextTick: measure new natural size, re-pin to old
+ *   5. Animate to new size via CSS transition
+ *   6. On transitionend(size), clear inline size
  */
 export declare function useLayerTransition(options: UseLayerTransitionOptions): UseLayerTransitionReturn;

package/dist/components/custom/hover-popover/HoverPopover.vue.d.ts

@@ -40,14 +40,35 @@ type __VLS_Props = {
      * as "inside the dock".
      */
     keepDockOpen?: boolean;
+    /**
+     * AQ.W6 — opt into the native `interestfor` + `popover="hint"` path
+     * when the browser supports interest invokers. Default `false` →
+     * reka-ui `HoverCard` (the unchanged default). When `true` AND the
+     * engine supports interest invokers, the trigger carries
+     * `interestfor` (an implicit anchor) and the panel renders as a
+     * `popover="hint"` top-layer surface driven by the `.glass-top-layer`
+     * grammar. When `true` but unsupported, it falls straight through to
+     * the reka-ui HoverCard — zero behaviour change.
+     *
+     * Baseline: `interest-invokers` + `popover-hint` = LIMITED →
+     * progressive-enhancement only; reka-ui stays the default path. No
+     * polyfill (substrate cannot drag one).
+     */
+    native?: boolean;
 };
-declare var __VLS_14: {}, __VLS_16: {}, __VLS_30: {};
+declare var __VLS_1: {}, __VLS_3: {}, __VLS_5: {}, __VLS_20: {}, __VLS_22: {}, __VLS_36: {};
 type __VLS_Slots = {} & {
-    trigger?: (props: typeof __VLS_14) => any;
+    trigger?: (props: typeof __VLS_1) => any;
+} & {
+    default?: (props: typeof __VLS_3) => any;
+} & {
+    content?: (props: typeof __VLS_5) => any;
+} & {
+    trigger?: (props: typeof __VLS_20) => any;
 } & {
-    default?: (props: typeof __VLS_16) => any;
+    default?: (props: typeof __VLS_22) => any;
 } & {
-    content?: (props: typeof __VLS_30) => any;
+    content?: (props: typeof __VLS_36) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:open": (open: boolean) => any;
@@ -60,6 +81,7 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {},
     closeDelay: number;
     hoverOpenDelay: number;
     keepDockOpen: boolean;
+    native: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;