@mkbabb/glass-ui 4.1.0 → 4.2.0

package/dist/components/custom/concentric/shaders/concentric.wgsl.d.ts

@@ -1 +1 @@
-export declare const CONCENTRIC_WGSL = "\nconst PI: f32 = 3.141592653589793;\nconst TAU: f32 = 6.283185307179586;\nconst RING_GRAVITY: f32 = 9.81;\nconst MAX_RINGS: i32 = 8;\nconst MAX_CENTERS: i32 = 4;\nconst MAX_RING_STOPS: i32 = 4;\n\n// \u2500\u2500 Concentric uniforms (the typed-struct source-of-truth \u2014 see uniformBridgeWGPU.ts) \u2500\u2500\nstruct ConcentricUniforms {\n  // u0: (uTime, uSpeed, uAxisA, uAxisB)\n  u0: vec4<f32>,\n  // ints: (uCenterCount, uRingCount, uStopCount, uRenderMode)  // 0 rings \u00B7 1 contour \u00B7 2 both\n  ints: vec4<i32>,\n  // bg: (background.rgb (linear), hasBackground)\n  bg: vec4<f32>,\n  // norm: (uFieldNorm, uAspect, _pad, _pad) \u2014 field \u2192 [0,1] scale\n  norm: vec4<f32>,\n  // line: (lineHalfWidth, aaSoftness, contourLevels, _pad) \u2014 stroke geometry (field units)\n  line: vec4<f32>,\n  // each ring row: (amplitude, wavelength, phase, _pad)\n  rings: array<vec4<f32>, 8>,\n  // each center row: (x, y, weight, rotAlpha)\n  centers: array<vec4<f32>, 4>,\n  // each palette stop: linear-sRGB rgb + _pad\n  palette: array<vec4<f32>, 4>,\n};\n\n@group(0) @binding(0) var<uniform> u: ConcentricUniforms;\n\n\nfn srgbToLinearCh(c: f32) -> f32 {\n  if (c <= 0.04045) { return c / 12.92; }\n  return pow((c + 0.055) / 1.055, 2.4);\n}\nfn srgbToLinear(c: vec3<f32>) -> vec3<f32> {\n  return vec3<f32>(srgbToLinearCh(c.r), srgbToLinearCh(c.g), srgbToLinearCh(c.b));\n}\n\nfn linearToSrgbCh(c: f32) -> f32 {\n  if (c <= 0.0031308) { return c * 12.92; }\n  return 1.055 * pow(c, 1.0 / 2.4) - 0.055;\n}\nfn linearToSrgb(c: vec3<f32>) -> vec3<f32> {\n  return vec3<f32>(linearToSrgbCh(c.r), linearToSrgbCh(c.g), linearToSrgbCh(c.b));\n}\n\n// value.js LINEAR_SRGB_TO_LMS, row-major \u2192 WGSL columns (= the transpose).\nconst LINEAR_SRGB_TO_LMS: mat3x3<f32> = mat3x3<f32>(\n  0.4122214708, 0.2119034982, 0.0883024619,\n  0.5363325363, 0.6806995451, 0.2817188376,\n  0.0514459929, 0.1073969566, 0.6299787005\n);\n\n// value.js srgbToOKLab's INLINE LMS\u2192OKLab coefficients, row-major \u2192 WGSL columns.\nconst LMS_TO_OKLAB: mat3x3<f32> = mat3x3<f32>(\n  0.2104542553, 1.9779984951, 0.0259040371,\n  0.7936177850, -2.4285922050, 0.7827717662,\n  -0.0040720468, 0.4505937099, -0.8086757660\n);\n\n// value.js OKLAB_TO_LMS_COEFF, row-major \u2192 WGSL columns.\nconst OKLAB_TO_LMS: mat3x3<f32> = mat3x3<f32>(\n  1.0, 1.0, 1.0,\n  0.3963377774, -0.1055613458, -0.0894841775,\n  0.2158037573, -0.0638541728, -1.2914855480\n);\n\n// value.js LMS_TO_LINEAR_SRGB, row-major \u2192 WGSL columns.\nconst LMS_TO_LINEAR_SRGB: mat3x3<f32> = mat3x3<f32>(\n  4.0767416621, -1.2684380046, -0.0041960863,\n  -3.3077115913, 2.6097574011, -0.7034186147,\n  0.2309699292, -0.3413193965, 1.7076147010\n);\n\nfn cbrt3(v: vec3<f32>) -> vec3<f32> {\n  return sign(v) * pow(abs(v), vec3<f32>(1.0 / 3.0));\n}\n\n// Gamma sRGB \u2192 raw OKLab (L, a, b). Mirrors value.js srgbToOKLab.\nfn srgbToOklab(c: vec3<f32>) -> vec3<f32> {\n  let lin = srgbToLinear(c);\n  let lms = LINEAR_SRGB_TO_LMS * lin;\n  return LMS_TO_OKLAB * cbrt3(lms);\n}\n\n// Raw OKLab (L, a, b) \u2192 linear sRGB. Mirrors value.js oklabToLinearSRGB.\nfn oklabToLinearSrgb(lab: vec3<f32>) -> vec3<f32> {\n  let lms_ = OKLAB_TO_LMS * lab;\n  let lms = lms_ * lms_ * lms_;\n  return LMS_TO_LINEAR_SRGB * lms;\n}\n\n// OKLab \u2192 OKLCh: H in RADIANS, folded to [0, 2pi). Mirrors value.js rawOklabToOklch.\nfn oklabToOklch(lab: vec3<f32>) -> vec3<f32> {\n  let C = length(lab.yz);\n  var H = atan2(lab.z, lab.y);\n  if (H < 0.0) { H = H + 2.0 * PI; }\n  return vec3<f32>(lab.x, C, H);\n}\n\n// OKLCh (H radians) \u2192 OKLab. Mirrors value.js rawOklchToOklab.\nfn oklchToOklab(lch: vec3<f32>) -> vec3<f32> {\n  return vec3<f32>(lch.x, lch.y * cos(lch.z), lch.y * sin(lch.z));\n}\n\n// Full-screen-triangle (the pilot idiom): NDC corners (-1,-1),(3,-1),(-1,3) cover the\n// viewport from a single 3-vertex draw \u2014 no vertex buffer.\nstruct VSOut {\n  @builtin(position) pos: vec4<f32>,\n  @location(0) uv: vec2<f32>,  // domain [-1,1]\u00B2, aspect-corrected x\n};\n\n@vertex\nfn vs_main(@builtin(vertex_index) vi: u32) -> VSOut {\n  var corners = array<vec2<f32>, 3>(\n    vec2<f32>(-1.0, -1.0), vec2<f32>(3.0, -1.0), vec2<f32>(-1.0, 3.0),\n  );\n  let c = corners[vi];\n  var out: VSOut;\n  out.pos = vec4<f32>(c, 0.0, 1.0);\n  out.uv = vec2<f32>(c.x, c.y);\n  return out;\n}\n\n// The ellipsoidal radial distance in the family's ROTATED frame R(\u2212\u03B1): rotate (p \u2212 c) by\n// \u2212\u03B1, then scale by (a,b). Transcribes ringField.ts ellipsoidalRadiusRot.\nfn ellipsoidalRadiusRot(p: vec2<f32>, center: vec2<f32>, rotAlpha: f32, axisA: f32, axisB: f32) -> f32 {\n  let ca = cos(rotAlpha);\n  let sa = sin(rotAlpha);\n  let px = p.x - center.x;\n  let py = p.y - center.y;\n  let rx = ca * px + sa * py;\n  let ry = -sa * px + ca * py;\n  let dx = rx / max(axisA, 1e-4);\n  let dy = ry / max(axisB, 1e-4);\n  return sqrt(dx * dx + dy * dy);\n}\n\n// |\u2207r| of the rotated ellipsoidal radius \u2014 closed-form (the IQ distance-estimation\n// denominator). Transcribes ringField.ts ellipsoidalGradMag.\nfn ellipsoidalGradMag(p: vec2<f32>, center: vec2<f32>, rotAlpha: f32, axisA: f32, axisB: f32) -> f32 {\n  let ca = cos(rotAlpha);\n  let sa = sin(rotAlpha);\n  let px = p.x - center.x;\n  let py = p.y - center.y;\n  let rx = ca * px + sa * py;\n  let ry = -sa * px + ca * py;\n  let a = max(axisA, 1e-4);\n  let b = max(axisB, 1e-4);\n  let sx = rx / a;\n  let sy = ry / b;\n  let r = sqrt(sx * sx + sy * sy);\n  let gx = sx / a;\n  let gy = sy / b;\n  return sqrt(gx * gx + gy * gy) / max(r, 1e-4);\n}\n\n// The radial-Fourier ring-interference value f(p,t) \u2014 the multi-center weighted sum of\n// CLEAN radial sinusoids (the BEAT ENVELOPE; transcribes ringField.ts sampleRingField).\nfn sampleRingField(p: vec2<f32>, t: f32) -> f32 {\n  var acc = 0.0;\n  let speed = u.u0.y;\n  let axisA = u.u0.z;\n  let axisB = u.u0.w;\n  let centerCount = u.ints.x;\n  let ringCount = u.ints.y;\n  for (var j = 0; j < MAX_CENTERS; j = j + 1) {\n    if (j >= centerCount) { break; }\n    let cj = u.centers[j];\n    let radius = ellipsoidalRadiusRot(p, cj.xy, cj.w, axisA, axisB);\n    var centerSum = 0.0;\n    for (var i = 0; i < MAX_RINGS; i = i + 1) {\n      if (i >= ringCount) { break; }\n      let r = u.rings[i];\n      let k = TAU / max(r.y, 1e-4);\n      let omega = sqrt(RING_GRAVITY * k) * speed;\n      let theta = k * radius - omega * t + r.z;\n      centerSum = centerSum + r.x * sin(theta);\n    }\n    acc = acc + centerSum * cj.z;\n  }\n  return acc;\n}\n\n// The IQ gradient-normalized isoline INK + the beat ENVELOPE \u2014 the per-pixel line strength\n// (brightest-wins union over every family \u00D7 ring crest) and the raw envelope (the hue\n// driver). Transcribes ringField.ts ringIsolineInk.\nstruct InkEnv { ink: f32, env: f32, };\nfn ringIsolineInk(p: vec2<f32>, t: f32) -> InkEnv {\n  var ink = 0.0;\n  var env = 0.0;\n  let speed = u.u0.y;\n  let axisA = u.u0.z;\n  let axisB = u.u0.w;\n  let centerCount = u.ints.x;\n  let ringCount = u.ints.y;\n  let lineHalfW = u.line.x;\n  let aa = u.line.y;\n  for (var j = 0; j < MAX_CENTERS; j = j + 1) {\n    if (j >= centerCount) { break; }\n    let cj = u.centers[j];\n    let radius = ellipsoidalRadiusRot(p, cj.xy, cj.w, axisA, axisB);\n    let gradR = ellipsoidalGradMag(p, cj.xy, cj.w, axisA, axisB);\n    for (var i = 0; i < MAX_RINGS; i = i + 1) {\n      if (i >= ringCount) { break; }\n      let r = u.rings[i];\n      let k = TAU / max(r.y, 1e-4);\n      let omega = sqrt(RING_GRAVITY * k) * speed;\n      let phase = k * radius - omega * t + r.z;\n      let s = sin(phase);\n      let cphase = abs(cos(phase));\n      let gradPhase = max(k * gradR, 1e-4);\n      // The IQ gradient-normalized distance-to-isoline (domain units; round-trips JS).\n      let de = abs(s) / max(cphase * gradPhase, 1e-4);\n      // Convert the domain-units distance to PIXELS via fwidth(phase) (the device\n      // per-pixel phase change) so the stroke is a constant pixel width everywhere \u2014\n      // lineHalfW/aa are in pixels (NOT fwidthFine, Compatibility-Mode safe).\n      let dPx = max(fwidth(phase), 1e-4);\n      let dePx = de * gradPhase / dPx;\n      var lineV = 1.0 - smoothstep(lineHalfW, lineHalfW + aa, dePx);\n      // Analytic anti-aliasing: where the rings pack tighter than the pixel can resolve\n      // (fwidth(phase) \u2273 \u03C0, near a center / under DPR), FADE the line out instead of\n      // flooding to a solid mass (IQ filterwidth \u2014 the aliasing-fade that keeps the field\n      // thin LINES, not a bright slab where the rings converge).\n      let aliasFade = 1.0 - smoothstep(PI * 0.6, PI * 1.2, dPx);\n      lineV = lineV * aliasFade;\n      let w = r.x * cj.z;\n      ink = max(ink, lineV * w);\n      env = env + s * w;\n    }\n  }\n  var oe: InkEnv;\n  oe.ink = clamp(ink, 0.0, 1.0);\n  oe.env = env;\n  return oe;\n}\n\n// The topographic-contour operator: the isolines of the STATIC interference envelope at N\n// evenly-spaced heights. de_contour = |fract(f\u00B7N + 0.5) \u2212 0.5| / |fwidth(f\u00B7N)| \u2014 the IQ\n// contour-line form. fwidth is the device pixel-derivative safety clamp on the composite\n// ONLY (NOT fwidthFine \u2014 Compatibility-Mode safe on Metal/WebKit).\nfn contourInk(envValue: f32, levels: f32) -> f32 {\n  let fN = envValue * levels;\n  let band = abs(fract(fN + 0.5) - 0.5);\n  // fwidth is the device pixel-derivative safety clamp (NOT fwidthFine \u2014 Compatibility-Mode\n  // safe on Metal/WebKit).\n  let aaW = max(fwidth(fN), 1e-4);\n  return 1.0 - smoothstep(u.line.x, u.line.x + u.line.y, band / aaW);\n}\n\n// Sample the multi-stop palette (linear-sRGB stops, OKLab mix). t in [0,1].\nfn samplePaletteLin(t: f32) -> vec3<f32> {\n  let stopCount = u.ints.z;\n  if (stopCount <= 1) { return u.palette[0].rgb; }\n  let n = f32(stopCount);\n  let ft = clamp(t, 0.0, 1.0) * (n - 1.0);\n  let i0 = i32(floor(ft));\n  let i1 = min(i0 + 1, stopCount - 1);\n  let f = ft - f32(i0);\n  let labA = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * u.palette[i0].rgb);\n  let labB = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * u.palette[i1].rgb);\n  return oklabToLinearSrgb(mix(labA, labB, f));\n}\n\n@fragment\nfn fs_main(in: VSOut) -> @location(0) vec4<f32> {\n  // aspect-correct the domain x so the rings read circular under the ellipsoidal norm.\n  let aspect = max(u.norm.y, 1e-4);\n  let p = vec2<f32>(in.uv.x * aspect, in.uv.y);\n  let t = u.u0.x;\n  let mode = u.ints.w;  // 0 traveling-rings \u00B7 1 static-contour \u00B7 2 both\n  let levels = u.line.z;\n\n  // The isoline strokes (the LINES) + the beat envelope (the HUE).\n  let oe = ringIsolineInk(p, t);\n  var ink = oe.ink;\n  let env = oe.env;\n\n  // The static-contour mode draws elevation lines of the (static) envelope.\n  if (mode == 1) {\n    ink = contourInk(env * u.norm.x, max(levels, 1.0));\n  } else if (mode == 2) {\n    ink = max(ink, contourInk(env * u.norm.x, max(levels, 1.0)));\n  }\n  // fwidth safety clamp on the final line composite (Compatibility-Mode safe).\n  ink = clamp(ink, 0.0, 1.0);\n\n  // The beat-envelope drives the warm-family tone across the ramp (cream\u2194amber\u2194ember) so the\n  // crossing ring families read as warm-light interference; the saturated mid-amber reads on\n  // BOTH the cream page and the dark page (the warm-cream identity, NOT a themed hue).\n  let v = clamp(0.5 + env * u.norm.x, 0.0, 1.0);\n  let lin = samplePaletteLin(v);\n  let rgb = clamp(linearToSrgb(lin), vec3<f32>(0.0), vec3<f32>(1.0));\n\n  let hasBg = u.bg.w;\n  if (hasBg > 0.5) {\n    // opaque themed ground: composite the lit line over the themed bg.\n    let bg = clamp(linearToSrgb(u.bg.rgb), vec3<f32>(0.0), vec3<f32>(1.0));\n    let outRgb = mix(bg, rgb, ink);\n    return vec4<f32>(outRgb, 1.0);\n  }\n  // transparent ground: the LINE carries the alpha \u2014 the page reads through the troughs.\n  let alpha = ink;\n  return vec4<f32>(rgb * alpha, alpha);\n}\n";
+export declare const CONCENTRIC_WGSL = "\nconst PI: f32 = 3.141592653589793;\nconst TAU: f32 = 6.283185307179586;\nconst MAX_RING_STOPS: i32 = 4;\n\n// \u2500\u2500 Concentric uniforms (the typed-struct source-of-truth \u2014 see uniformBridgeWGPU.ts) \u2500\u2500\nstruct ConcentricUniforms {\n  // u0: (uTime, uSpeed, uCellSize, _pad)\n  u0: vec4<f32>,\n  // ints: (_pad, _pad, uStopCount, _pad)\n  ints: vec4<i32>,\n  // bg: (background.rgb (linear), hasBackground)\n  bg: vec4<f32>,\n  // norm: (uFieldNorm, uAspect, lightDirX, lightDirY)\n  norm: vec4<f32>,\n  // line: (lineHalfWidth, aaSoftness, contourLevels, indexEvery)\n  line: vec4<f32>,\n  // wave: (waveDirX, waveDirY, waveK, waveOmega)\n  wave: vec4<f32>,\n  // wave2: (waveSigma, twistMax, shearMax, amp)\n  wave2: vec4<f32>,\n  // topo: (heightOctaves, heightSeed, swellAmp, perturbAmp)\n  topo: vec4<f32>,\n  // cursor: (cursorX, cursorY, cursorWell, interactive)\n  cursor: vec4<f32>,\n  // tune: (toneGain, shadeAmp, indexMul, inkDarken)\n  tune: vec4<f32>,\n  // each palette stop: linear-sRGB rgb + _pad\n  palette: array<vec4<f32>, 4>,\n};\n\n@group(0) @binding(0) var<uniform> u: ConcentricUniforms;\n\n\nfn srgbToLinearCh(c: f32) -> f32 {\n  if (c <= 0.04045) { return c / 12.92; }\n  return pow((c + 0.055) / 1.055, 2.4);\n}\nfn srgbToLinear(c: vec3<f32>) -> vec3<f32> {\n  return vec3<f32>(srgbToLinearCh(c.r), srgbToLinearCh(c.g), srgbToLinearCh(c.b));\n}\n\nfn linearToSrgbCh(c: f32) -> f32 {\n  if (c <= 0.0031308) { return c * 12.92; }\n  return 1.055 * pow(c, 1.0 / 2.4) - 0.055;\n}\nfn linearToSrgb(c: vec3<f32>) -> vec3<f32> {\n  return vec3<f32>(linearToSrgbCh(c.r), linearToSrgbCh(c.g), linearToSrgbCh(c.b));\n}\n\n// value.js LINEAR_SRGB_TO_LMS, row-major \u2192 WGSL columns (= the transpose).\nconst LINEAR_SRGB_TO_LMS: mat3x3<f32> = mat3x3<f32>(\n  0.4122214708, 0.2119034982, 0.0883024619,\n  0.5363325363, 0.6806995451, 0.2817188376,\n  0.0514459929, 0.1073969566, 0.6299787005\n);\n\n// value.js srgbToOKLab's INLINE LMS\u2192OKLab coefficients, row-major \u2192 WGSL columns.\nconst LMS_TO_OKLAB: mat3x3<f32> = mat3x3<f32>(\n  0.2104542553, 1.9779984951, 0.0259040371,\n  0.7936177850, -2.4285922050, 0.7827717662,\n  -0.0040720468, 0.4505937099, -0.8086757660\n);\n\n// value.js OKLAB_TO_LMS_COEFF, row-major \u2192 WGSL columns.\nconst OKLAB_TO_LMS: mat3x3<f32> = mat3x3<f32>(\n  1.0, 1.0, 1.0,\n  0.3963377774, -0.1055613458, -0.0894841775,\n  0.2158037573, -0.0638541728, -1.2914855480\n);\n\n// value.js LMS_TO_LINEAR_SRGB, row-major \u2192 WGSL columns.\nconst LMS_TO_LINEAR_SRGB: mat3x3<f32> = mat3x3<f32>(\n  4.0767416621, -1.2684380046, -0.0041960863,\n  -3.3077115913, 2.6097574011, -0.7034186147,\n  0.2309699292, -0.3413193965, 1.7076147010\n);\n\nfn cbrt3(v: vec3<f32>) -> vec3<f32> {\n  return sign(v) * pow(abs(v), vec3<f32>(1.0 / 3.0));\n}\n\n// Gamma sRGB \u2192 raw OKLab (L, a, b). Mirrors value.js srgbToOKLab.\nfn srgbToOklab(c: vec3<f32>) -> vec3<f32> {\n  let lin = srgbToLinear(c);\n  let lms = LINEAR_SRGB_TO_LMS * lin;\n  return LMS_TO_OKLAB * cbrt3(lms);\n}\n\n// Raw OKLab (L, a, b) \u2192 linear sRGB. Mirrors value.js oklabToLinearSRGB.\nfn oklabToLinearSrgb(lab: vec3<f32>) -> vec3<f32> {\n  let lms_ = OKLAB_TO_LMS * lab;\n  let lms = lms_ * lms_ * lms_;\n  return LMS_TO_LINEAR_SRGB * lms;\n}\n\n// OKLab \u2192 OKLCh: H in RADIANS, folded to [0, 2pi). Mirrors value.js rawOklabToOklch.\nfn oklabToOklch(lab: vec3<f32>) -> vec3<f32> {\n  let C = length(lab.yz);\n  var H = atan2(lab.z, lab.y);\n  if (H < 0.0) { H = H + 2.0 * PI; }\n  return vec3<f32>(lab.x, C, H);\n}\n\n// OKLCh (H radians) \u2192 OKLab. Mirrors value.js rawOklchToOklab.\nfn oklchToOklab(lch: vec3<f32>) -> vec3<f32> {\n  return vec3<f32>(lch.x, lch.y * cos(lch.z), lch.y * sin(lch.z));\n}\n\n// Full-screen-triangle (the pilot idiom).\nstruct VSOut {\n  @builtin(position) pos: vec4<f32>,\n  @location(0) uv: vec2<f32>,\n};\n\n@vertex\nfn vs_main(@builtin(vertex_index) vi: u32) -> VSOut {\n  var corners = array<vec2<f32>, 3>(\n    vec2<f32>(-1.0, -1.0), vec2<f32>(3.0, -1.0), vec2<f32>(-1.0, 3.0),\n  );\n  let c = corners[vi];\n  var out: VSOut;\n  out.pos = vec4<f32>(c, 0.0, 1.0);\n  out.uv = vec2<f32>(c.x, c.y);\n  return out;\n}\n\n// \u2500\u2500 The host noise basis (the SAME quintic-faded value-noise the suite speaks) \u2500\u2500\nfn hash21(x: f32, y: f32) -> f32 {\n  var px = fract(x * 0.1031);\n  var py = fract(y * 0.1031);\n  var pz = fract(x * 0.1031);\n  let d = px * (py + 33.33) + py * (pz + 33.33) + pz * (px + 33.33);\n  px = px + d; py = py + d; pz = pz + d;\n  return fract((px + py) * pz);\n}\nfn valueNoise(x: f32, y: f32) -> f32 {\n  let ix = floor(x); let iy = floor(y);\n  let fx = x - ix; let fy = y - iy;\n  let ux = fx * fx * fx * (fx * (fx * 6.0 - 15.0) + 10.0);\n  let uy = fy * fy * fy * (fy * (fy * 6.0 - 15.0) + 10.0);\n  let a = hash21(ix, iy);\n  let b = hash21(ix + 1.0, iy);\n  let c = hash21(ix, iy + 1.0);\n  let d2 = hash21(ix + 1.0, iy + 1.0);\n  return mix(mix(a, b, ux), mix(c, d2, ux), uy);\n}\n// The single-octave potential the curl operator wraps + the height field samples.\nfn potentialFBM(p: vec2f) -> f32 {\n  var v = 0.0; var amp = 0.5; var freq = 1.0;\n  var px = p.x; var py = p.y;\n  for (var i = 0; i < 3; i = i + 1) {\n    v = v + amp * valueNoise(px * freq, py * freq);\n    let rx = 0.8 * px - 0.6 * py;\n    let ry = 0.6 * px + 0.8 * py;\n    px = rx; py = ry; freq = freq * 2.0; amp = amp * 0.5;\n  }\n  return v;\n}\n\n// The shared curl + wave chunks (splice AFTER valueNoise + potentialFBM are declared).\n\nconst CURL_EPS: f32 = 0.012;\n\n// \u2207\u00D7\u03C8 in 2D \u2014 the divergence-free flow direction. Central finite differences of the\n// scalar potential give the partials; the cross-pairing (\u2202y, \u2212\u2202x) is the 2D curl.\nfn curlFBM(p: vec2f) -> vec2f {\n  let dx = potentialFBM(p + vec2f(CURL_EPS, 0.0)) - potentialFBM(p - vec2f(CURL_EPS, 0.0));\n  let dy = potentialFBM(p + vec2f(0.0, CURL_EPS)) - potentialFBM(p - vec2f(0.0, CURL_EPS));\n  // \u03C8-gradient is (dx, dy)/(2\u00B7eps); the curl rotates it 90\u00B0: (\u2202\u03C8/\u2202y, \u2212\u2202\u03C8/\u2202x).\n  let g = vec2f(dx, dy) / (2.0 * CURL_EPS);\n  return vec2f(g.y, -g.x);\n}\n\n\nconst WAVE_FIELD_TAU: f32 = 6.283185307179586;\n\n// The traveling-wave envelope \u2014 a moving Gaussian crest band sweeping along waveDir.\nfn travelingEnvelope(pivot: vec2f, t: f32, waveDir: vec2f, waveK: f32, waveOmega: f32, waveSigma: f32) -> f32 {\n  let coord = dot(pivot, waveDir) * waveK - t * waveOmega;\n  let crest = fract(coord / WAVE_FIELD_TAU);\n  let z = (crest - 0.5) * 2.0;\n  return exp(-(z * z) / max(waveSigma, 1e-3));\n}\n\n// The curl-direction scalar \u2014 the smooth low-freq director the per-cell twist follows.\nfn curlScalar(cc: vec2f, t: f32) -> f32 {\n  let f = curlFBM(vec2f(cc.x * 0.5 + t * 0.08, cc.y * 0.5 - t * 0.06));\n  return clamp(f.x, -1.0, 1.0);\n}\n\n// The directed-twist FLOOR (the visibility cure): keep the curl SIGN (adjacent cells lean\n// together) but floor the magnitude so a crest-band cell ALWAYS rotates decisively.\nconst WAVE_FIELD_TWIST_FLOOR: f32 = 0.62;\nfn directedTwist(s: f32, floorMag: f32) -> f32 {\n  let mag = max(floorMag, abs(s));\n  let sgn = tanh(s * 6.0);\n  return sgn * mag;\n}\n\n// \u2500\u2500 The FACE leaf (the structurally-absent RE-INVENT \u2014 height-lit filled cell interior) \u2500\u2500\n// DECLARED ABOVE cellTwist (no WGSL forward declaration): cellTwist rides cellHeight via the\n// driver so twist + face read ONE envelope.\n\n// The sheet displacement at a cell center = the EXACT traveling-wave scalar the twist rides.\nfn cellHeight(cc: vec2f, t: f32, waveDir: vec2f, waveK: f32, waveOmega: f32, waveSigma: f32, amp: f32) -> f32 {\n  return travelingEnvelope(cc, t, waveDir, waveK, waveOmega, waveSigma) * amp;\n}\n\n// The pre-twist driver (FOLD A): the cell pivot cc + the crest envelope env the twist AND the\n// face both ride. The face samples height/relief at THIS pre-twist cc (the crest twist crosses\n// the cell boundary \u2192 floor(twisted_g) would light a NEIGHBOUR cell). cc in .xy, env in .z.\nfn cellDriver(g: vec2f, cellSize: f32, t: f32, waveDir: vec2f, waveK: f32, waveOmega: f32,\n              waveSigma: f32, amp: f32) -> vec3f {\n  let cs = max(cellSize, 1e-3);\n  let cc = (floor(g / cs) + 0.5) * cs;\n  let env = cellHeight(cc, t, waveDir, waveK, waveOmega, waveSigma, amp);\n  return vec3f(cc, env);\n}\n\n// The central-difference slope of cellHeight across a cell (eps = 0.5\u00B7cellSize) \u2014 derivative-\n// FREE (NO dFdx on the height) \u2192 Safari WebGL2-safe. Returns \u2207H.\nfn faceRelief(cc: vec2f, cellSize: f32, t: f32, waveDir: vec2f, waveK: f32, waveOmega: f32,\n              waveSigma: f32, amp: f32) -> vec2f {\n  let eps = max(cellSize, 1e-3) * 0.5;\n  let hxp = cellHeight(cc + vec2f(eps, 0.0), t, waveDir, waveK, waveOmega, waveSigma, amp);\n  let hxm = cellHeight(cc - vec2f(eps, 0.0), t, waveDir, waveK, waveOmega, waveSigma, amp);\n  let hyp = cellHeight(cc + vec2f(0.0, eps), t, waveDir, waveK, waveOmega, waveSigma, amp);\n  let hym = cellHeight(cc - vec2f(0.0, eps), t, waveDir, waveK, waveOmega, waveSigma, amp);\n  return vec2f((hxp - hxm) / (2.0 * eps), (hyp - hym) / (2.0 * eps));\n}\n\n// Soft inset-square coverage inside a (warped) cell \u2014 the filled FACE plateau. d is the\n// distance into the cell from the nearest gutter (the Golus triangle-wave); the inset retreats\n// as it grows (the squash). aa = the shader's fwidth(g) (JS passes a fixed uvDeriv).\nfn facePlateau(g: vec2f, inset: f32, uvDeriv: vec2f) -> f32 {\n  let tri = 1.0 - abs(fract(g) * 2.0 - 1.0);\n  let d = min(tri.x, tri.y);\n  let aa = max(uvDeriv.x, uvDeriv.y) * 1.5;\n  return smoothstep(inset, inset + 2.0 * aa, d);\n}\n\n// The cell-local twist about each cell's own center, gated by the traveling wave + directed\n// by the curl flow. amp is the spring-eased envelope amplitude the JS host drives. FOLD C: the\n// TWIST_FLOOR is crest-gated by env so OFF-crest cells relax to flat calm paper (the traveling\n// read, not static foil).\nfn cellTwist(g: vec2f, cellSize: f32, t: f32, waveDir: vec2f, waveK: f32, waveOmega: f32,\n             waveSigma: f32, twistMax: f32, shearMax: f32, amp: f32) -> vec2f {\n  let drv = cellDriver(g, cellSize, t, waveDir, waveK, waveOmega, waveSigma, amp);\n  let cc = drv.xy;\n  let env = drv.z;\n  let floorMag = WAVE_FIELD_TWIST_FLOOR * env;   // FOLD C: crest-gated floor\n  let theta = twistMax * env * directedTwist(curlScalar(cc, t), floorMag);\n  let shear = shearMax * env * directedTwist(curlScalar(cc + vec2f(17.3, 9.1), t), floorMag);\n  let local = g - cc;\n  let ct = cos(theta);\n  let st = sin(theta);\n  var rot = vec2f(ct * local.x - st * local.y, st * local.x + ct * local.y);\n  rot.x = rot.x + shear * rot.y;   // a small skew so the box MORPHS, not just rotates\n  return cc + rot;\n}\n\n// The CONTINUOUS traveling-wave FLOW warp \u2014 the SMOOTH twin of cellTwist (no per-cell seam;\n// for the level-set contours that shatter into a mesh under the cell discontinuity).\nfn waveFlow(g: vec2f, t: f32, waveDir: vec2f, waveK: f32, waveOmega: f32, waveSigma: f32,\n            twistMax: f32, amp: f32) -> vec2f {\n  let env = travelingEnvelope(g, t, waveDir, waveK, waveOmega, waveSigma) * amp;\n  let f = curlFBM(vec2f(g.x * 0.6 + t * 0.05, g.y * 0.6 - t * 0.04));\n  let f2 = curlFBM(vec2f(g.x * 1.1 - t * 0.03, g.y * 1.1 + t * 0.035));\n  let k = twistMax * env;\n  return g + (f + f2 * 0.5) * k;\n}\n\n// The local cursor swirl \u2014 the finger twists the cells around it (re-aimed cursorBulge).\nfn cursorSwirl(g: vec2f, cursor: vec2f, strength: f32, radius: f32) -> vec2f {\n  let to = g - cursor;\n  let d2 = dot(to, to);\n  let r = max(radius, 1e-4);\n  let theta = strength * exp(-d2 / (2.0 * r * r));\n  let ct = cos(theta);\n  let st = sin(theta);\n  return cursor + vec2f(ct * to.x - st * to.y, st * to.x + ct * to.y);\n}\n\n// The LOW-octave value-noise topography \u2014 the scalar field concentric extracts contours of.\nfn heightField(p: vec2f, octavesF: f32, seed: f32) -> f32 {\n  var v = 0.0;\n  var amp = 0.5;\n  var freq = 1.0;\n  var px = p.x + seed;\n  var py = p.y - seed;\n  let n = i32(clamp(octavesF, 1.0, 6.0));\n  for (var i = 0; i < 6; i = i + 1) {\n    if (i >= n) { break; }\n    v = v + amp * valueNoise(px * freq, py * freq);\n    let rx = 0.8 * px - 0.6 * py;\n    let ry = 0.6 * px + 0.8 * py;\n    px = rx;\n    py = ry;\n    freq = freq * 2.0;\n    amp = amp * 0.5;\n  }\n  return v;\n}\n\n// The \u03C9=\u221A(g\u00B7k) breathing swell \u2014 basins inflate/deflate with weight.\nfn waveSwell(t: f32, phase: f32) -> f32 {\n  return sin(t * 0.35 + phase) * 0.5 + sin(t * 0.21 + phase * 1.7) * 0.5;\n}\n\n\nfn smoothstepEdge(e0: f32, e1: f32, x: f32) -> f32 {\n  let t = clamp((x - e0) / max(e1 - e0, 1e-6), 0.0, 1.0);\n  return t * t * (3.0 - 2.0 * t);\n}\n\n// The level-set height at domain p (transcribes levelField.ts sampleHeight). The sampling\n// coordinate is cell-twisted (the SAME wave that twists paper-grid cells \u2014 kinship); the\n// height is a low-octave topography + the swell + the cursor peak.\nfn sampleHeight(p: vec2f, t: f32) -> f32 {\n  // The CONTINUOUS traveling-wave flow warp (no per-cell seam \u2014 the contours flow + twist as\n  // the wave passes OVER and THROUGH them, the SAME wave that twists the paper-grid cells).\n  var g = waveFlow(p, t, u.wave.xy, u.wave.z, u.wave.w, u.wave2.x, u.wave2.y, u.wave2.w);\n  if (u.cursor.w > 0.5) {\n    g = cursorSwirl(g, u.cursor.xy, u.cursor.z * 0.6, u.u0.z * 2.5);\n  }\n  // Sample the topography at a LOW base frequency so the basins are BROAD nested loops (a\n  // readable contour map \u2014 not a fine speckle). heightOctaves carries the fractal detail.\n  var H = heightField(g * 0.9, u.topo.x, u.topo.y);\n  H = H + u.topo.z * waveSwell(t, u.topo.y);\n  if (u.cursor.w > 0.5) {\n    let d = p - u.cursor.xy;\n    let d2 = dot(d, d);\n    // The cursor HEAVE \u2014 a SOFT bulge (a Gaussian peak feathered by a smoothstep falloff so\n    // the heave is C1-smooth, NOT the hard-edged quad the old dark render showed). The well\n    // depth/radius already carry the velocity-HEAVE scale (packed JS-side into u.cursor.z).\n    let g0 = exp(-d2 / 0.22);\n    let fall = smoothstepEdge(0.0, 0.55, exp(-d2 / 0.6));\n    H = H + u.cursor.z * g0 * fall;\n  }\n  return H;\n}\n\n// The IQ gradient-free level-set contour ink \u2014 KEPT BYTE-FROZEN (the perfect GPU AA). It is\n// FED the per-level half-width 'hw' (a parameter, NOT a re-derivation): de_contour =\n// |fract(fN + 0.5) \u2212 0.5| / fwidth(fN). The contour density tracks 1/|\u2207H| automatically.\n// 'aaW' floors against a DPR-aware minimum so the index line stays CONTINUOUS where the heave\n// packs contours (steep |\u2207H| saturates fwidth \u2014 challenge R4).\nfn contourInk(fN: f32, hw: f32) -> f32 {\n  let band = abs(fract(fN + 0.5) - 0.5);\n  let aaW = max(fwidth(fN), 6e-4);\n  return 1.0 - smoothstepEdge(hw, hw + u.line.y, band / aaW);\n}\n\n// Sample the multi-stop palette (linear-sRGB stops, OKLab mix). t in [0,1].\nfn samplePaletteLin(t: f32) -> vec3<f32> {\n  let stopCount = u.ints.z;\n  if (stopCount <= 1) { return u.palette[0].rgb; }\n  let n = f32(stopCount);\n  let ft = clamp(t, 0.0, 1.0) * (n - 1.0);\n  let i0 = i32(floor(ft));\n  let i1 = min(i0 + 1, stopCount - 1);\n  let f = ft - f32(i0);\n  let labA = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * u.palette[i0].rgb);\n  let labB = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * u.palette[i1].rgb);\n  return oklabToLinearSrgb(mix(labA, labB, f));\n}\n\n// The SHARED hillshade finite-diff epsilon \u2014 pinned ONCE (mirrors levelField.HILLSHADE_EPSILON\n// + the GLSL twin; a per-backend drift would red the L6 numeric parity).\nconst HILLSHADE_E: f32 = 0.012;\n\n@fragment\nfn fs_main(in: VSOut) -> @location(0) vec4<f32> {\n  let aspect = max(u.norm.y, 1e-4);\n  let p = vec2<f32>(in.uv.x * aspect, in.uv.y);\n  let t = u.u0.x * u.u0.y;\n  let levels = max(u.line.z, 1.0);\n\n  // The level-set topography (the KEPT field \u2014 the PRIMARY path).\n  let H = sampleHeight(p, t);\n\n  // \u2500\u2500 1. HYPSOMETRIC TONE \u2014 tanh expands the compressed band so basins+ridges hit the ramp\n  //    ENDS (the live lumVar-flat cause). samplePaletteLin is the KEPT OKLab operator.\n  let tone = 0.5 + 0.5 * tanh(H * u.tune.x);\n  var fill = samplePaletteLin(tone);\n\n  // \u2500\u2500 2. ANALYTIC HILLSHADE \u2014 one \u2207H finite-diff at the SHARED e, dotted with the fixed cel\n  //    light \u2192 2.5-D relief. A read-only re-sample of sampleHeight (no second field).\n  let e = HILLSHADE_E;\n  let hx = sampleHeight(p + vec2<f32>(e, 0.0), t) - sampleHeight(p - vec2<f32>(e, 0.0), t);\n  let hy = sampleHeight(p + vec2<f32>(0.0, e), t) - sampleHeight(p - vec2<f32>(0.0, e), t);\n  let grad = vec2<f32>(hx, hy) / (2.0 * e);\n  let L = normalize(u.norm.zw + vec2<f32>(1e-5, 1e-5));\n  let shade = 0.5 + 0.5 * clamp(dot(normalize(grad + vec2<f32>(1e-5)), L), -1.0, 1.0);\n  fill = fill * mix(1.0 - u.tune.y, 1.0 + u.tune.y, shade);\n\n  // \u2500\u2500 3. TWO-TIER INDEX/MINOR CONTOUR \u2014 isIndex a pure f(level) (floor + mod + select, NOT a\n  //    state buffer); the per-level half-width hw is FED to the byte-frozen contourInk.\n  let fN = H * levels + u.topo.w * sin(floor(H * levels) * 2.4 + t * 0.7);\n  let indexEvery = max(u.line.w, 1.0);\n  let lvl = floor(fN);\n  let isIndex = select(0.0, 1.0, fract(lvl / indexEvery) < (0.5 / indexEvery));\n  let hw = mix(u.line.x, u.line.x * u.tune.z, isIndex);\n  let ink = clamp(contourInk(fN, hw), 0.0, 1.0);\n\n  // \u2500\u2500 4. INK = a darker ember of the LOCAL fill (the edge-of-its-own-band signature).\n  let inkCol = mix(fill, fill * u.tune.w, 0.85);\n\n  // \u2500\u2500 5. ONE color path + OPAQUE OUT \u2014 the viz IS the colorful field, never lines-over-nothing.\n  //    Per-mode is resolved in the CONSUMED stops + the bg token (no in-shader uMode branch).\n  let col = mix(fill, inkCol, ink);\n  return vec4<f32>(clamp(linearToSrgb(col), vec3<f32>(0.0), vec3<f32>(1.0)), 1.0);\n}\n";

package/dist/components/custom/configurator/Configurator.vue.d.ts

@@ -23,6 +23,20 @@ export type ConfiguratorScrollMode = "auto" | "always" | "never";
  * Below `lg` the layout is a single column and the side has no meaning.
  */
 export type ConfiguratorAsideSide = "left" | "right";
+/**
+ * Where the preset gallery sits.
+ *
+ * `aside` (default) keeps the preset row inside the right-hand aside (the
+ * inspector idiom — the legacy placement, unchanged).
+ *
+ * `top` lifts the gallery OUT of the 360px aside and pins it as a large,
+ * full-width, horizontally-scrollable glass dock across the TOP of the studio
+ * frame — the §2.1 reflow (gallery up-top + larger + scrollable). The stage +
+ * controls reclaim the full height below it. An additive axis: the grid arm is
+ * the precompiled `[data-slot=configurator][data-gallery=top]` rule in
+ * configurator.css (never a dead JIT bracket — the BC.W-CONFIG-RIGHT lesson).
+ */
+export type ConfiguratorGalleryPlacement = "aside" | "top";
 /**
  * Generic preset descriptor. Consumers pass `T` as the live config shape.
  * The primitive carries no preset semantics beyond `key + label` for
@@ -68,6 +82,13 @@ declare const __VLS_export: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_se
          * stays stage→aside. No effect below `lg` (single-column).
          */
         asideSide?: ConfiguratorAsideSide;
+        /**
+         * Where the preset gallery sits. Default `"aside"` (the inspector idiom).
+         * `"top"` pins the gallery as a large full-width scrollable glass dock
+         * across the top of the studio (the §2.1 up-top reflow), driven by the
+         * precompiled `[data-gallery="top"]` rule in configurator.css.
+         */
+        galleryPlacement?: ConfiguratorGalleryPlacement;
         /**
          * Aside width band at `lg`+ width, as a CSS length pair driving
          * `minmax(--configurator-aside-min, --configurator-aside-max)`. The
@@ -89,12 +110,12 @@ declare const __VLS_export: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_se
     expose: (exposed: {}) => void;
     attrs: any;
     slots: {
-        stage?: (props: {}) => any;
-    } & {
         presets?: (props: {
             presets: readonly ConfiguratorPreset<T>[] | undefined;
             activePreset: string | undefined;
         }) => any;
+    } & {
+        stage?: (props: {}) => any;
     } & {
         controls?: (props: {
             layers: readonly {

package/dist/components/custom/configurator/index.d.ts

@@ -1,6 +1,6 @@
 export { default as Configurator } from "./Configurator.vue";
 export { default as ConfiguratorLayer } from "./ConfiguratorLayer.vue";
 export { default as ConfiguratorRow } from "./ConfiguratorRow.vue";
-export type { ConfiguratorAsideSide, ConfiguratorPreset, ConfiguratorScrollMode, } from "./Configurator.vue";
+export type { ConfiguratorAsideSide, ConfiguratorGalleryPlacement, ConfiguratorPreset, ConfiguratorScrollMode, } from "./Configurator.vue";
 export { CONFIGURATOR_DENSITY_KEY, provideConfiguratorDensity, useOptionalConfiguratorDensity, type ConfiguratorDensity, } from "./density";
 export { useConfiguratorState, type ConfiguratorCloneMode, type ConfiguratorState, type ConfiguratorStateOptions, } from "./useConfiguratorState";

package/dist/components/custom/dock/DockDropdownTrigger.vue.d.ts

@@ -3,9 +3,10 @@ import { type DropdownMenuTriggerProps } from "reka-ui";
 /**
  * <DockDropdownTrigger> — variable-width DropdownMenu trigger for use inside GlassDock.
  *
- * Emits the dock dropdown-trigger class contract. Interactive styling is owned
- * by src/styles/dock.css. Matches DockIconButton's hover-scale behaviour
- * unlike DockSelectTrigger, which doesn't scale.
+ * Emits the SHARED `.dock-trigger` recipe (BD.W-DOCK-CORE A8 — the unified dock
+ * overlay-trigger family: select/dropdown/popover are byte-identical geometry + style +
+ * baseline alignment). Interactive styling is owned by dock-controls/triggers.css; the
+ * hover-scale is OFF across the family so portaled content anchors smoothly.
  *
  * Consumers provide the button content (icon + text + optional chevron)
  * via the default slot.

package/dist/components/custom/dock/DockIconButton.vue.d.ts

@@ -35,6 +35,15 @@ type __VLS_Props = {
     active?: boolean;
     /** Button type attribute (default: "button" to prevent form submission). */
     type?: ButtonHTMLAttributes["type"];
+    /**
+     * Disabled state (the four-state contract). A boundary nav control (a
+     * prev/next at the first/last item) stays PRESENT but disabled so the row
+     * geometry holds, never DOM-absent (the "flaky" read). On a <button> host it
+     * lands the native `disabled` attribute + `aria-disabled`; the CSS reads the
+     * `:disabled` register (the shared `.dock-icon-button:disabled` dim + the
+     * `pointer-events:none` press-suppress).
+     */
+    disabled?: boolean;
     /** Host tag/component (reka-ui Primitive `as`; default "button"). */
     as?: string | Component;
     /** Merge props onto a slotted child instead of rendering a host tag. */
@@ -49,6 +58,7 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {},
     active: boolean;
     type: "button" | "reset" | "submit";
     compact: boolean;
+    disabled: boolean;
     asChild: boolean;
     as: string | Component;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/components/custom/dock/DockPopoverTrigger.vue.d.ts

@@ -0,0 +1,19 @@
+import { type ButtonHTMLAttributes, type HTMLAttributes } from "vue";
+import { type PopoverTriggerProps } from "reka-ui";
+type __VLS_Props = PopoverTriggerProps & {
+    type?: ButtonHTMLAttributes["type"];
+    class?: HTMLAttributes["class"];
+};
+declare var __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, 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/dock/DockStack.vue.d.ts

@@ -1,39 +1,51 @@
 import { type Component } from "vue";
 import type { DockStackItem } from "./constants";
 /**
- * <DockStack> — BC.W-DOCK-STACK-RAIL. The macOS Dock hover-expand STACK (the clean-break
- * rebuild of the retired divider-carousel `DockRail`). It renders in `GlassDock`'s `#rail`
- * slot, over the KEPT `.glass-dock-frame` non-clipping escape, so it extends BEYOND the
- * dock edge into its own gutter WITHOUT touching the dock box (the box-INVIOLATE
- * discipline — `deltaW = deltaH = 0`).
+ * <DockStack> — BC.W-DOCK-STACK-RAIL + BE.W-DOCK-RAIL-REALIZE. The ONE rail engine on
+ * the KEPT `.glass-dock-frame` non-clipping escape, with TWO render modes:
  *
- * THE STACK. A `core` anchor item (the always-visible glyph, sitting in the dock(1)) +
- * `items: readonly DockStackItem[]` (the members). On hover (pointer-enter) OR focus of
- * the core item, the members FAN OUT next to the rail — a column (vertical dock) / row
- * (horizontal dock) of FULLY-VISIBLE glass icons springing open beside the line, each on
- * the iOS liquid clock, staggered by `--dock-stack-stagger * var(--i)` in reading order.
- * The hover-collapse reverses on the no-overshoot `--ease-out`. Every member is a clear
- * `--glass-bg-floating` glass icon — NEVER a shadowed half-tucked chip (the "NOT shadowed"
- * verbatim ask). At rest only the core (1) shows; expanded, the n members.
+ *   • `mode="stack"` (DEFAULT — the BC byte-identical path). The macOS Dock
+ *     hover-expand STACK: a `core` anchor glyph + N members that FAN OUT on hover/focus
+ *     beside the rail, each a clear `--glass-bg-floating` glass icon.
  *
- * 3 CONFIGURABLE, SCROLLABLE, N-STACK. `visibleCount` (default 3) members fan at rest;
- * an >visibleCount stack routes the fanned column through `<FadingScroll>` (the one
- * scroll-fade port) so the n-stack is reachable by scrolling the rail, NOT by overflowing
- * the dock box.
+ *   • `mode="facets"` (BE.W-DOCK-RAIL-REALIZE — the re-instated AZ context carousel).
+ *     The members render as a CONTEXT CAROUSEL — a flex strip of facet-CHIPS that fans
+ *     in the SAME gutter, each chip carrying its OWN `--glass-accent` hue (the
+ *     per-instance chromatic-rim axis), the active facet lit on the selected-as-glass
+ *     `--dock-control-active-bg` tier. Clicking a chip writes the consumer-owned
+ *     `v-model:selected`. This is a RENDER MODE, NOT a second component — there is no
+ *     `DockRail.vue`/`DockFacetRail.vue`; `<DockStack>` owns both modes.
+ *
+ * THE KEPT ESCAPE (both modes). It renders in `GlassDock`'s `#rail` slot, over the
+ * `.glass-dock-frame` shell — a `display:contents`-by-default wrapper that becomes a
+ * NON-clipping positioning context only on `data-has-rail`, so the rail extends BEYOND
+ * the dock edge into its own gutter WITHOUT touching the dock box (the box-INVIOLATE
+ * discipline — `deltaW = deltaH = 0`; the chips feed NO size into the dock's intrinsic
+ * box).
+ *
+ * 3 CONFIGURABLE, SCROLLABLE, N-STACK (both modes). `visibleCount` (default 3) members
+ * fan at rest; an >visibleCount set routes the fanned strip through `<FadingScroll>`
+ * (the one scroll-fade port) so the n-set is reachable by scrolling the rail, NOT by
+ * overflowing the dock box.
  *
  * THE HOVER-HYSTERESIS (REUSED, not re-forked — AZ.W-DOCK-FLICKER). The pointer-enter
- * commits the open only after the `HOVER_INTENT_MS` intent-dwell (the SAME constant the
- * dock-collapse hysteresis reads), so a sweeping-edge enter does not flash the stack open.
- * Focus opens immediately (keyboard intent is explicit); blur/leave closes.
+ * commits the open only after the `HOVER_INTENT_MS` intent-dwell. Focus opens
+ * immediately; blur/leave closes.
  *
- * ONE REGISTRY (R2 KEPT). The members write the consumer-owned `v-model:selected`; this
+ * ONE REGISTRY (R4 KEPT). The members write the consumer-owned `v-model:selected`; this
  * primitive owns NO internal `ref()`/`reactive()` shadow of the active member. The hover
  * `expanded` is a transient UI state (optionally `v-model:expanded` controlled), NOT a
  * selection shadow.
  */
 type __VLS_Props = {
-    /** The stack members — the fan-out contents (NOT facet chips; the macOS stack). */
+    /** The stack/facet members — the fan-out contents. */
     items: readonly DockStackItem[];
+    /**
+     * The render mode. `"stack"` (default) = the macOS hover-expand glyph fan (the BC
+     * byte-identical path). `"facets"` = the re-instated AZ context carousel of
+     * accent-tinted facet chips (each chip writes its own `--glass-accent` hue).
+     */
+    mode?: "stack" | "facets";
     /** The core anchor glyph (the always-visible dock(1) item). Default: a layers glyph. */
     core?: Component;
     /** The core's accessible label (the stack's name). */
@@ -58,6 +70,7 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {},
     "onUpdate:expanded"?: ((value: boolean) => any) | undefined;
 }>, {
     position: "start" | "end";
+    mode: "stack" | "facets";
     visibleCount: number;
     coreLabel: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/components/custom/dock/GlassDock.vue.d.ts

@@ -1,5 +1,11 @@
 import { type DockProps } from "./composables/useDockShellProps";
-declare var __VLS_1: {}, __VLS_3: {}, __VLS_5: {}, __VLS_7: {}, __VLS_9: {};
+/** Imperative split/merge/toggle — re-measure pieces, then run the fission spring. */
+declare function split(): void;
+declare function merge(): void;
+declare function toggleSplit(): void;
+declare var __VLS_1: {}, __VLS_3: {}, __VLS_5: {}, __VLS_7: {}, __VLS_9: {
+    fissioned: boolean;
+}, __VLS_11: {};
 type __VLS_Slots = {} & {
     persistent?: (props: typeof __VLS_1) => any;
 } & {
@@ -9,7 +15,9 @@ type __VLS_Slots = {} & {
 } & {
     search?: (props: typeof __VLS_7) => any;
 } & {
-    rail?: (props: typeof __VLS_9) => any;
+    split?: (props: typeof __VLS_9) => any;
+} & {
+    rail?: (props: typeof __VLS_11) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<DockProps, {
     expanded: import("vue").Ref<boolean, boolean>;
@@ -20,7 +28,15 @@ declare const __VLS_base: import("vue").DefineComponent<DockProps, {
     collapse: () => void;
     keepOpen: () => void;
     release: () => void;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<DockProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+    split: typeof split;
+    merge: typeof merge;
+    toggleSplit: typeof toggleSplit;
+    fissioned: Readonly<import("vue").Ref<boolean, boolean>>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:order": (from: number, to: number) => any;
+}, string, import("vue").PublicProps, Readonly<DockProps> & Readonly<{
+    "onUpdate:order"?: ((from: number, to: number) => any) | undefined;
+}>, {}, {}, {}, {}, 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;

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

@@ -3,37 +3,24 @@ import type { Ref } from "vue";
  * AX.W02 — ONE morph orchestrator per dock. The dock is a single morph stack
  * whose active "layer" is `(expandedState × activePane)`: the outer
  * collapse↔expand swap and the inner `<DockLayerGroup>` pane swaps are
- * transitions in the SAME group — ONE spring, ONE scalar (`--dock-morph-t`,
- * established by W01), ONE clock. No second engine.
+ * transitions in the SAME group — ONE spring, ONE scalar (`--dock-morph-t`),
+ * ONE clock. No second engine.
  *
- * Re-derived from first principles on W01's settled single-scalar substrate:
- *  - `--dock-morph-t` is written to the `.glass-dock` root and INHERITS to every
- *    descendant (dock.css `@property … inherits:true`), so ONE spring writing
- *    that one scalar drives EVERY registered container's size calc at once.
- *  - Each morphing container carries its OWN `--dock-morph-from`/`--dock-morph-to`
- *    px span (the allowed one-time FLIP measurement) and interpolates it against
- *    the shared scalar — `from + (to − from) · t`. So a simultaneous
- *    collapse + pane-swap reads as one continuous spring: the box, the nested
- *    stack, and every child stagger ramp on the same `t`.
- *
- * The orchestrator OWNS one `SpringProgress`. The OUTER collapse↔expand pair
- * registers as a target; a NESTED `<DockLayerGroup>` registers a SECOND target
- * instead of minting its own `useLayerTransition` engine. A re-toggle mid-flight
- * re-bases the live solver onto the new span from its current velocity (the iOS
- * interruptible-physics contract W01 keeps), so even an interrupted morph stays
- * one continuous trajectory.
- *
- * This is the dock-flavored first instance of the general `MorphGroup` /
- * `GlassEffectContainer` facility (the iOS-26 Liquid-Glass corpus, facet 26 —
- * the `provideMorphGroup` two-part seam: a per-element driver + a provide/inject
- * orchestrator). AX.W42 generalizes it; W02 establishes the seam it builds on.
+ * BD.W-DOCK-CORE (the size re-invent) — the orchestrator no longer MEASURES a
+ * per-swap `from/to` span. The visible size is a ratio-free convex blend of two
+ * endpoints measured ONCE per content change (`useDockExpandedSize` writes
+ * `--dock-expanded-px`/`--dock-collapsed-px`; layers.css blends them on
+ * `--dock-morph-t`). So this driver shrinks to its essence: on a layer swap it
+ * arms `[data-morphing]`, swaps the crossfade classes (the a11y-006 3-state
+ * hit-test contract, LOAD-BEARING — KEPT verbatim), and runs ONE `SpringProgress`
+ * gliding `--dock-morph-t` 0→1; on settle it clears the morph state. A re-toggle
+ * mid-flight re-bases the live solver onto a fresh spring CARRYING the prior
+ * velocity (the iOS interruptible-physics continuity).
  *
  * LIGHT-surface only: `SpringProgress` owns its own rAF via `.play(onFrame)` and
- * carries no static value.js edge — never import `AnimationGroup` / `./engine`
- * (that pulls value.js into the dock bundle).
+ * carries no static value.js edge — never import `AnimationGroup` / `./engine`.
  *
- * The `DOCK_SPRING` tuning this orchestrator drives is the ONE authority shared with
- * `useLayerTransition` — it lives in `../constants` (the feature-dir constants home).
+ * `DOCK_SPRING` is byte-fenced — it lives in `../constants`.
  */
 export interface DockMorphGroupRegistration {
     /** The container element owning this group's grid-stacked panes. */
@@ -84,10 +71,9 @@ export interface UseDockMorphOrchestratorReturn {
     onOuterTransitionEnd(e: TransitionEvent): void;
 }
 /**
- * The ONE morph engine for a dock instance. Owns a single `SpringProgress`;
- * drives the outer collapse↔expand box AND every nested `<DockLayerGroup>`'s
- * pane-swap off the one `--dock-morph-t` scalar. Replaces the per-pair
- * `useLayerTransition` instantiation (W01's single-scalar primitive) with a
- * single multi-target driver, so a nested dock runs ONE engine, not two.
+ * The ONE morph engine for a dock instance. Owns a single `SpringProgress` that
+ * glides the one `--dock-morph-t` scalar 0→1 on a layer swap; the size is a
+ * ratio-free blend of the measure-ONCE endpoints (layers.css). Crossfade classes
+ * (the 3-state a11y hit-test contract) swap on the swap; the spring is the clock.
  */
 export declare function useDockMorphOrchestrator(options: UseDockMorphOrchestratorOptions): UseDockMorphOrchestratorReturn;