@vitreajs/vitrea 0.1.0

package/dist/dist-FGJI5LQM.js

@@ -0,0 +1,3573 @@
+import { DEFAULT_GROUP_UNION, LowPassHysteresisDriver, WGSL_RSUPN, WGSL_RSUP, resolveFromChannels, resolveConcentric, governorFieldParams, fieldParams, DEFAULT_MOTION_PROFILE } from './chunk-ST6GFEQT.js';
+
+// ../renderer-webgpu/dist/wgsl/analysis.js
+var ANALYSIS_WORKGROUP = 64;
+var ANALYSIS_GRID = 64;
+var ANALYSIS_STATS_FLOATS = 4;
+var WGSL_ANALYSIS_PASS = `struct AnalysisUniforms {
+  /// grid.xy = sample grid size, grid.z = source level, grid.w = 1/(grid-1)
+  grid : vec4f,
+  /// texel.xy = one texel of the sampled level, in uv
+  texel : vec4f,
+};
+
+@group(0) @binding(0) var<uniform> au : AnalysisUniforms;
+@group(0) @binding(1) var analysisSampler : sampler;
+@group(0) @binding(2) var analysisTexture : texture_2d<f32>;
+@group(0) @binding(3) var<storage, read_write> stats : array<f32>;
+
+var<workgroup> partialLum  : array<f32, ${ANALYSIS_WORKGROUP}>;
+var<workgroup> partialSq   : array<f32, ${ANALYSIS_WORKGROUP}>;
+var<workgroup> partialEdge : array<f32, ${ANALYSIS_WORKGROUP}>;
+
+fn lum_at(uv : vec2f) -> f32 {
+  let s = textureSampleLevel(analysisTexture, analysisSampler, uv, au.grid.z);
+  // Level 0 onwards is premultiplied linear; unpremultiplying keeps a
+  // transparent backdrop region from reading as black rather than as absent.
+  let colour = s.rgb / max(s.a, 1e-6);
+  return luminance(colour);
+}
+
+@compute @workgroup_size(${ANALYSIS_WORKGROUP})
+fn cs_analysis(@builtin(local_invocation_index) lane : u32) {
+  let total = u32(au.grid.x * au.grid.y);
+  var sumLum = 0.0;
+  var sumSq = 0.0;
+  var sumEdge = 0.0;
+  var n = 0.0;
+
+  var i = lane;
+  loop {
+    if (i >= total) { break; }
+    let gx = f32(i % u32(au.grid.x));
+    let gy = f32(i / u32(au.grid.x));
+    let uv = vec2f(gx, gy) * au.grid.w;
+
+    let c = lum_at(uv);
+    let dx = lum_at(uv + vec2f(au.texel.x, 0.0)) - lum_at(uv - vec2f(au.texel.x, 0.0));
+    let dy = lum_at(uv + vec2f(0.0, au.texel.y)) - lum_at(uv - vec2f(0.0, au.texel.y));
+
+    sumLum = sumLum + c;
+    sumSq = sumSq + c * c;
+    sumEdge = sumEdge + length(vec2f(dx, dy)) * 0.5;
+    n = n + 1.0;
+
+    i = i + ${ANALYSIS_WORKGROUP}u;
+  }
+
+  partialLum[lane] = sumLum;
+  partialSq[lane] = sumSq;
+  partialEdge[lane] = sumEdge;
+  workgroupBarrier();
+
+  // Tree reduction. ${ANALYSIS_WORKGROUP} is a power of two, so no tail case.
+  var stride = ${ANALYSIS_WORKGROUP}u / 2u;
+  loop {
+    if (stride == 0u) { break; }
+    if (lane < stride) {
+      partialLum[lane] = partialLum[lane] + partialLum[lane + stride];
+      partialSq[lane] = partialSq[lane] + partialSq[lane + stride];
+      partialEdge[lane] = partialEdge[lane] + partialEdge[lane + stride];
+    }
+    workgroupBarrier();
+    stride = stride / 2u;
+  }
+
+  if (lane == 0u) {
+    let count = max(f32(total), 1.0);
+    let mean = partialLum[0] / count;
+    stats[0] = mean;
+    stats[1] = max(partialSq[0] / count - mean * mean, 0.0);
+    stats[2] = partialEdge[0] / count;
+    stats[3] = count;
+  }
+}`;
+
+// ../renderer-webgpu/dist/color.js
+var BACKDROP_COLOR_SPACES = ["srgb", "display-p3"];
+var BACKDROP_ALPHA_MODES = ["premultiplied", "unpremultiplied", "opaque"];
+var WORKING_TEXTURE_FORMAT = "rgba16float";
+var OUTPUT_TEXTURE_FORMAT = "rgba8unorm";
+var SRGB_LINEAR_CUTOFF = 31308e-7;
+var SRGB_ENCODED_CUTOFF = 0.04045;
+var SRGB_SLOPE = 12.92;
+var SRGB_ALPHA = 1.055;
+var SRGB_OFFSET = 0.055;
+var SRGB_GAMMA = 2.4;
+function srgbToLinearChannel(c) {
+  if (c <= SRGB_ENCODED_CUTOFF)
+    return c / SRGB_SLOPE;
+  return Math.pow((c + SRGB_OFFSET) / SRGB_ALPHA, SRGB_GAMMA);
+}
+function linearToSrgbChannel(c) {
+  if (c <= SRGB_LINEAR_CUTOFF)
+    return c * SRGB_SLOPE;
+  return SRGB_ALPHA * Math.pow(c, 1 / SRGB_GAMMA) - SRGB_OFFSET;
+}
+var srgbToLinear = (c) => [
+  srgbToLinearChannel(c[0]),
+  srgbToLinearChannel(c[1]),
+  srgbToLinearChannel(c[2])
+];
+var linearToSrgb = (c) => [
+  linearToSrgbChannel(c[0]),
+  linearToSrgbChannel(c[1]),
+  linearToSrgbChannel(c[2])
+];
+var LUMINANCE_WEIGHTS = [0.2126, 0.7152, 0.0722];
+function relativeLuminance(linear) {
+  return linear[0] * LUMINANCE_WEIGHTS[0] + linear[1] * LUMINANCE_WEIGHTS[1] + linear[2] * LUMINANCE_WEIGHTS[2];
+}
+var P3_TO_SRGB = [
+  [1.224940176280559, -0.224940176280559, 0],
+  [-0.042056973821316, 1.042056973821316, 0],
+  [-0.019637554590334, -0.078636046901105, 1.098273601491439]
+];
+function displayP3ToSrgbLinear(linearP3) {
+  const out = [];
+  for (const row of P3_TO_SRGB) {
+    out.push(Math.min(1, Math.max(0, row[0] * linearP3[0] + row[1] * linearP3[1] + row[2] * linearP3[2])));
+  }
+  return [out[0], out[1], out[2]];
+}
+function importColorMatrix(space) {
+  if (space === "srgb") {
+    return new Float32Array([1, 0, 0, 0, 1, 0, 0, 0, 1]);
+  }
+  const rows = P3_TO_SRGB;
+  return new Float32Array([
+    ...rows[0],
+    ...rows[1],
+    ...rows[2]
+  ]);
+}
+function alphaNormalisationMode(mode) {
+  switch (mode) {
+    case "premultiplied":
+      return 0;
+    case "unpremultiplied":
+      return 1;
+    case "opaque":
+      return 2;
+  }
+}
+function encodeOutput(linear, alpha) {
+  const a = Math.min(1, Math.max(0, alpha));
+  const encoded = linearToSrgb(linear);
+  return [encoded[0] * a, encoded[1] * a, encoded[2] * a, a];
+}
+function encodeOutputBytes(linear, alpha) {
+  return encodeOutput(linear, alpha).map((c) => Math.round(Math.min(1, Math.max(0, c)) * 255));
+}
+
+// ../renderer-webgpu/dist/material.js
+var REFRACTION_LADDER = ["none", "approximate", "true"];
+function refractionRank(quality) {
+  return REFRACTION_LADDER.indexOf(quality);
+}
+function accessibilityRefractionCap(policy) {
+  switch (policy.refraction) {
+    case "nominal":
+      return "true";
+    case "reduced":
+      return "approximate";
+    case "none":
+      return "none";
+  }
+}
+function effectiveRefraction(a, b) {
+  return refractionRank(a) <= refractionRank(b) ? a : b;
+}
+var MATERIAL_VARIANTS = ["regular", "clear"];
+var SRGB_WHITE_TINT = [1, 1, 1];
+var INCREASED_OCCLUSION_LIFT = 0.4722;
+function occlusionAlphaUnderPolicy(nominal, occlusion, lift = INCREASED_OCCLUSION_LIFT) {
+  switch (occlusion) {
+    case "nominal":
+      return nominal;
+    case "increased":
+      return nominal + lift * (1 - nominal);
+    case "opaque":
+      return 1;
+  }
+}
+var DEFAULT_MATERIAL_PROFILE = {
+  optics: {
+    // σ = 8 for the regular variant, which keeps this package's blur and
+    // `platform-web`'s CSS-tier blur on the same number — and makes core's 24 px
+    // `samplingPadding` advisory exactly the 3σ S1 measured.
+    regular: {
+      blurSigma: 8,
+      tint: srgbToLinear(SRGB_WHITE_TINT),
+      // MEASURED (C9a), against apple-macos-26.5-1x-light-standard. The advisory
+      // 0.28 made vitrea's regular material roughly half as opaque as the
+      // reference: regressing interior level against backdrop level across the
+      // calibration scenes puts Apple's transmission at 0.26 of the backdrop
+      // where vitrea's was 0.70. 0.62 is the minimiser of the declared tuning
+      // objective; see docs/doperpowers/specs/c9a-fidelity-claims.md, and note
+      // that no single value can be right for every size — Apple's opacity falls
+      // with surface span (0.88 at 32 px to 0.56 at 96 px) and this renderer has
+      // no size term on the tint.
+      tintAlpha: 0.62,
+      rimWidth: 1.5,
+      rimAlpha: 0.18,
+      specularPower: 6,
+      specularGain: 0.55,
+      shadowDepth: 0.35,
+      shadowAlpha: 0.55,
+      highlight: srgbToLinear(SRGB_WHITE_TINT)
+    },
+    // Persistently more transparent, so it frosts less and tints less.
+    clear: {
+      blurSigma: 4,
+      tint: srgbToLinear(SRGB_WHITE_TINT),
+      tintAlpha: 0.1,
+      rimWidth: 1.25,
+      rimAlpha: 0.14,
+      specularPower: 8,
+      specularGain: 0.45,
+      shadowDepth: 0.22,
+      shadowAlpha: 0.4,
+      highlight: srgbToLinear(SRGB_WHITE_TINT)
+    }
+  },
+  /*
+   * MEASURED (C9a): both ends are the same tint, which makes the crossover inert
+   * by default. That is a finding, not a shortcut.
+   *
+   * The two ends used to straddle the backdrop — white over a dark backdrop,
+   * near-black over a light one — so the material always contrasted with what was
+   * behind it. Apple's Regular material does not do that. Its interior rises
+   * monotonically with the backdrop across the whole canonical range (0.680 at a
+   * backdrop of 0.003, 0.932 at 0.891, light scheme), which is a fixed tint at
+   * partial transmission. What it keys on instead is the COLOUR SCHEME: over the
+   * same bright checkerboard the reference sits at 0.809 in light and 0.055 in
+   * dark. Leaving the inversion on cost more than the whole tint tune was worth —
+   * it drove the light-scheme error from 0.348 to 0.449 on the interior-level
+   * term alone.
+   *
+   * So the scheme picks the tint, and the calibration profiles carry one set of
+   * numbers per scheme (packages/calibration/profiles/). The crossover mechanism
+   * is untouched and still available to a profile that wants it; the default
+   * simply no longer claims a behaviour the reference does not have.
+   *
+   * Two limits worth naming. The ends are global rather than per-variant, so the
+   * clear variant inherits this — and clear has no calibration scenes at all, so
+   * it is uncalibrated either way. And nothing yet selects a profile from the
+   * scheme; that is C9a's parent-impact item.
+   */
+  adaptiveTintDark: srgbToLinear(SRGB_WHITE_TINT),
+  adaptiveTintLight: srgbToLinear(SRGB_WHITE_TINT),
+  adaptiveLuminanceLow: 0.12,
+  adaptiveLuminanceHigh: 0.42,
+  refractionScale: {
+    none: 0,
+    approximate: 0.45,
+    true: 1
+  },
+  lensSpanMin: 28,
+  lensSpanMax: 420,
+  lensSizeGainMax: 2.6,
+  lensBodyLodPerPx: 0.16,
+  lensRimLodBias: 2.5,
+  reducedTransparencyFrost: 1.75,
+  increasedOcclusionLift: INCREASED_OCCLUSION_LIFT,
+  strongBorderRim: { rimWidth: 2, rimAlpha: 0.95 },
+  reducedTintAdaptation: 0.35,
+  lightDirection: [-0.3714, -0.9285],
+  sweepBandRadians: 0.55,
+  glowRadiusCss: 44,
+  glowGain: 0.6,
+  sweepGain: 0.85
+};
+var REFRACTION_SCALE = DEFAULT_MATERIAL_PROFILE.refractionScale;
+var MATERIAL_OPTICS = DEFAULT_MATERIAL_PROFILE.optics;
+var ADAPTIVE_TINT_DARK = DEFAULT_MATERIAL_PROFILE.adaptiveTintDark;
+var ADAPTIVE_TINT_LIGHT = DEFAULT_MATERIAL_PROFILE.adaptiveTintLight;
+var ADAPTIVE_LUMINANCE_LOW = DEFAULT_MATERIAL_PROFILE.adaptiveLuminanceLow;
+var ADAPTIVE_LUMINANCE_HIGH = DEFAULT_MATERIAL_PROFILE.adaptiveLuminanceHigh;
+var LENS_SPAN_MIN = DEFAULT_MATERIAL_PROFILE.lensSpanMin;
+var LENS_SPAN_MAX = DEFAULT_MATERIAL_PROFILE.lensSpanMax;
+var LENS_SIZE_GAIN_MAX = DEFAULT_MATERIAL_PROFILE.lensSizeGainMax;
+var LENS_BODY_LOD_PER_PX = DEFAULT_MATERIAL_PROFILE.lensBodyLodPerPx;
+var LENS_RIM_LOD_BIAS = DEFAULT_MATERIAL_PROFILE.lensRimLodBias;
+function withMaterialOverrides(base, patch) {
+  const optics = {};
+  for (const variant of MATERIAL_VARIANTS) {
+    optics[variant] = { ...base.optics[variant], ...patch.optics?.[variant] };
+  }
+  const refractionScale = {};
+  for (const rung of REFRACTION_LADDER) {
+    refractionScale[rung] = patch.refractionScale?.[rung] ?? base.refractionScale[rung];
+  }
+  return {
+    optics,
+    adaptiveTintDark: patch.adaptiveTintDark ?? base.adaptiveTintDark,
+    adaptiveTintLight: patch.adaptiveTintLight ?? base.adaptiveTintLight,
+    adaptiveLuminanceLow: patch.adaptiveLuminanceLow ?? base.adaptiveLuminanceLow,
+    adaptiveLuminanceHigh: patch.adaptiveLuminanceHigh ?? base.adaptiveLuminanceHigh,
+    refractionScale,
+    lensSpanMin: patch.lensSpanMin ?? base.lensSpanMin,
+    lensSpanMax: patch.lensSpanMax ?? base.lensSpanMax,
+    lensSizeGainMax: patch.lensSizeGainMax ?? base.lensSizeGainMax,
+    lensBodyLodPerPx: patch.lensBodyLodPerPx ?? base.lensBodyLodPerPx,
+    lensRimLodBias: patch.lensRimLodBias ?? base.lensRimLodBias,
+    reducedTransparencyFrost: patch.reducedTransparencyFrost ?? base.reducedTransparencyFrost,
+    increasedOcclusionLift: patch.increasedOcclusionLift ?? base.increasedOcclusionLift,
+    strongBorderRim: { ...base.strongBorderRim, ...patch.strongBorderRim },
+    reducedTintAdaptation: patch.reducedTintAdaptation ?? base.reducedTintAdaptation,
+    lightDirection: patch.lightDirection ?? base.lightDirection,
+    sweepBandRadians: patch.sweepBandRadians ?? base.sweepBandRadians,
+    glowRadiusCss: patch.glowRadiusCss ?? base.glowRadiusCss,
+    glowGain: patch.glowGain ?? base.glowGain,
+    sweepGain: patch.sweepGain ?? base.sweepGain
+  };
+}
+function opticsUnderPolicy(optics, policy, profile = DEFAULT_MATERIAL_PROFILE) {
+  let next = optics;
+  if (policy.frost === "increased") {
+    next = { ...next, blurSigma: next.blurSigma * profile.reducedTransparencyFrost };
+  } else if (policy.frost === "none") {
+    next = { ...next, blurSigma: 0 };
+  }
+  next = {
+    ...next,
+    tintAlpha: occlusionAlphaUnderPolicy(next.tintAlpha, policy.occlusion, profile.increasedOcclusionLift)
+  };
+  if (policy.border === "strong")
+    next = { ...next, ...profile.strongBorderRim };
+  return next;
+}
+function adaptationStrength(policy, analysisExact, profile = DEFAULT_MATERIAL_PROFILE) {
+  if (!analysisExact)
+    return 0;
+  switch (policy.ambientTint) {
+    case "nominal":
+      return 1;
+    case "reduced":
+      return profile.reducedTintAdaptation;
+    case "none":
+      return 0;
+  }
+}
+var smoothstep = (edge0, edge1, x) => {
+  if (edge1 <= edge0)
+    return x < edge0 ? 0 : 1;
+  const t = Math.min(1, Math.max(0, (x - edge0) / (edge1 - edge0)));
+  return t * t * (3 - 2 * t);
+};
+function lensSizeGain(spanPx, profile = DEFAULT_MATERIAL_PROFILE) {
+  return 1 + (profile.lensSizeGainMax - 1) * smoothstep(profile.lensSpanMin, profile.lensSpanMax, spanPx);
+}
+function lensDepthPx(thicknessPx, spanPx, profile = DEFAULT_MATERIAL_PROFILE) {
+  const gain = lensSizeGain(spanPx, profile);
+  return Math.min(Math.max(thicknessPx, 0) * gain, spanPx * 0.5);
+}
+function bodyLod(lensDepth, maxLod, profile = DEFAULT_MATERIAL_PROFILE) {
+  return Math.min(Math.max(lensDepth * profile.lensBodyLodPerPx, 0), maxLod);
+}
+
+// ../renderer-webgpu/dist/analysis.js
+var ZERO_STATS = {
+  luminance: 0,
+  variance: 0,
+  edgeDensity: 0,
+  sampleCount: 0
+};
+function statsFromBuffer(values) {
+  return {
+    luminance: values[0] ?? 0,
+    variance: values[1] ?? 0,
+    edgeDensity: values[2] ?? 0,
+    sampleCount: values[3] ?? 0
+  };
+}
+var LUMINANCE_CONFIG = {
+  kind: "low-pass-hysteresis",
+  timeConstantMs: 500,
+  hysteresis: 0.04,
+  restDistance: 1e-3
+};
+var VARIANCE_CONFIG = { ...LUMINANCE_CONFIG, hysteresis: 0.01 };
+var EDGE_CONFIG = { ...LUMINANCE_CONFIG, hysteresis: 0.01 };
+var smoothstep2 = (edge0, edge1, x) => {
+  if (edge1 <= edge0)
+    return x < edge0 ? 0 : 1;
+  const t = Math.min(1, Math.max(0, (x - edge0) / (edge1 - edge0)));
+  return t * t * (3 - 2 * t);
+};
+function adaptiveTint(luminance, profile = DEFAULT_MATERIAL_PROFILE) {
+  const dark = profile.adaptiveTintDark;
+  const light = profile.adaptiveTintLight;
+  const t = smoothstep2(profile.adaptiveLuminanceLow, profile.adaptiveLuminanceHigh, luminance);
+  return [
+    dark[0] + (light[0] - dark[0]) * t,
+    dark[1] + (light[1] - dark[1]) * t,
+    dark[2] + (light[2] - dark[2]) * t
+  ];
+}
+function createAdaptationState(initial = ZERO_STATS, profile = DEFAULT_MATERIAL_PROFILE) {
+  const luminance = new LowPassHysteresisDriver(LUMINANCE_CONFIG, initial.luminance);
+  const variance = new LowPassHysteresisDriver(VARIANCE_CONFIG, initial.variance);
+  const edge = new LowPassHysteresisDriver(EDGE_CONFIG, initial.edgeDensity);
+  let observed = initial.sampleCount > 0;
+  return {
+    observe(stats) {
+      if (stats.sampleCount <= 0)
+        return;
+      observed = true;
+      luminance.retarget(stats.luminance);
+      variance.retarget(stats.variance);
+      edge.retarget(stats.edgeDensity);
+    },
+    advance(deltaMs) {
+      luminance.advance(deltaMs);
+      variance.advance(deltaMs);
+      edge.advance(deltaMs);
+    },
+    reset(stats) {
+      observed = stats.sampleCount > 0;
+      luminance.jumpTo(stats.luminance);
+      variance.jumpTo(stats.variance);
+      edge.jumpTo(stats.edgeDensity);
+    },
+    get values() {
+      return {
+        luminance: luminance.value,
+        variance: variance.value,
+        edgeDensity: edge.value,
+        tint: adaptiveTint(luminance.value, profile),
+        observed
+      };
+    },
+    get settled() {
+      return luminance.settled && variance.settled && edge.settled;
+    }
+  };
+}
+function readbackDue(lastAtMs, nowMs, cadenceHz) {
+  if (cadenceHz <= 0)
+    return false;
+  if (lastAtMs === void 0)
+    return true;
+  return nowMs - lastAtMs >= 1e3 / cadenceHz;
+}
+
+// ../renderer-webgpu/dist/errors.js
+var RENDERER_ERROR_CODES = [
+  /** A `GPUTextureView`'s backing texture lacks a required usage flag. */
+  "texture-usage",
+  /** Format outside the set the sampling path can read. */
+  "texture-format",
+  /** Wrong view dimension, or a depth/array layer count the pass cannot bind. */
+  "texture-dimension",
+  /** Zero or absurd extent, or a size that exceeds the device's limits. */
+  "texture-size",
+  /** A source id registered twice, or an unknown id referenced. */
+  "source-identity",
+  /** The provider was asked for a frame it cannot produce (closed video, detached canvas). */
+  "source-unavailable",
+  /** No device is attached, or the attached one is lost. */
+  "device-unavailable",
+  /** A frame was acquired twice without a release, or released without an acquire. */
+  "frame-protocol",
+  /** A pass was asked to draw something the current resources cannot express. */
+  "pass-input"
+];
+var RendererError = class extends Error {
+  code;
+  /** The source, group or node the failure is about, when there is one. */
+  subject;
+  constructor(code, message, subject) {
+    super(message);
+    this.name = "RendererError";
+    this.code = code;
+    this.subject = subject;
+  }
+};
+function rendererError(code, message, subject) {
+  return new RendererError(code, message, subject);
+}
+
+// ../renderer-webgpu/dist/backdrop.js
+var BACKDROP_KINDS = [
+  "image",
+  "video",
+  "canvas",
+  "gradient",
+  "app-texture-view"
+];
+var SUPPORTED_APP_TEXTURE_FORMATS = [
+  "rgba8unorm",
+  "rgba8unorm-srgb",
+  "bgra8unorm",
+  "bgra8unorm-srgb",
+  "rgba16float",
+  "rgba32float"
+];
+var copyUsage = () => GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT;
+function trackSize(tracker, width, height) {
+  if (tracker.width === width && tracker.height === height)
+    return;
+  tracker.width = width;
+  tracker.height = height;
+  tracker.epoch += 1;
+}
+function createCopyProvider(options) {
+  let device = options.device;
+  const size = { epoch: 0, width: options.width, height: options.height };
+  const live = options.live ?? options.kind === "canvas";
+  let dirty = true;
+  let texture;
+  let generation = options.generation ?? 0;
+  const ensureTexture = () => {
+    if (texture !== void 0 && texture.width === size.width && texture.height === size.height) {
+      return texture;
+    }
+    texture?.destroy();
+    texture = device.createTexture({
+      label: `vitrea:backdrop:${options.id}:upload`,
+      size: { width: size.width, height: size.height, depthOrArrayLayers: 1 },
+      // 8-bit is the honest storage for an image or a canvas: both are 8-bit
+      // sources, and the import pass promotes to float on the way into level 0.
+      format: "rgba8unorm",
+      usage: copyUsage()
+    });
+    return texture;
+  };
+  return {
+    id: options.id,
+    kind: options.kind,
+    get generation() {
+      return generation;
+    },
+    isDirty() {
+      return dirty || live;
+    },
+    acquire() {
+      if (size.width <= 0 || size.height <= 0) {
+        throw rendererError("source-unavailable", `Backdrop "${options.id}" has a zero extent (${size.width}\xD7${size.height}); nothing can be copied from it.`, options.id);
+      }
+      const target = ensureTexture();
+      if (dirty || live) {
+        device.queue.copyExternalImageToTexture({ source: options.source, flipY: false }, {
+          texture: target,
+          colorSpace: options.colorSpace ?? "srgb",
+          // X3: copied images arrive premultiplied. Declaring it here is what
+          // makes that true rather than assumed — the copy performs the multiply
+          // when the source is not already premultiplied.
+          premultipliedAlpha: true
+        }, { width: size.width, height: size.height });
+      }
+      return {
+        sourceId: options.id,
+        binding: { kind: "sampled", view: target.createView() },
+        width: size.width,
+        height: size.height,
+        sizeEpoch: size.epoch,
+        colorSpace: options.colorSpace ?? "srgb",
+        alphaMode: "premultiplied",
+        encoded: true
+      };
+    },
+    release() {
+    },
+    markImported() {
+      dirty = false;
+    },
+    invalidate(next, nextDevice) {
+      generation = next;
+      device = nextDevice;
+      texture?.destroy();
+      texture = void 0;
+      dirty = true;
+    },
+    resize(width, height) {
+      const changed = size.width !== width || size.height !== height;
+      trackSize(size, width, height);
+      if (changed)
+        dirty = true;
+    },
+    destroy() {
+      texture?.destroy();
+      texture = void 0;
+    }
+  };
+}
+function createVideoProvider(options) {
+  let device = options.device;
+  const size = { epoch: 0, width: 0, height: 0 };
+  let ownedFrame;
+  let acquired = false;
+  let generation = options.generation ?? 0;
+  return {
+    id: options.id,
+    kind: "video",
+    get generation() {
+      return generation;
+    },
+    isDirty() {
+      return true;
+    },
+    acquire() {
+      if (acquired) {
+        throw rendererError("frame-protocol", `Backdrop "${options.id}" was acquired twice without a release. X3 pairs one acquire per frame with one release after submit.`, options.id);
+      }
+      let source;
+      if (options.source.kind === "element") {
+        const element = options.source.element;
+        if (element.readyState < 2 || element.videoWidth === 0) {
+          throw rendererError("source-unavailable", `Backdrop "${options.id}" is a video with no decoded frame yet (readyState ${element.readyState}). Wait for "loadeddata" before registering it, or let the group render without a backdrop until it arrives.`, options.id);
+        }
+        trackSize(size, element.videoWidth, element.videoHeight);
+        source = element;
+      } else {
+        const frame = options.source.next();
+        if (frame === void 0) {
+          throw rendererError("source-unavailable", `Backdrop "${options.id}" produced no VideoFrame for this frame.`, options.id);
+        }
+        ownedFrame = frame;
+        trackSize(size, frame.displayWidth, frame.displayHeight);
+        source = frame;
+      }
+      let texture;
+      try {
+        texture = device.importExternalTexture({
+          label: `vitrea:backdrop:${options.id}:external`,
+          source,
+          colorSpace: "srgb"
+        });
+      } catch (error) {
+        ownedFrame?.close();
+        ownedFrame = void 0;
+        throw error;
+      }
+      acquired = true;
+      return {
+        sourceId: options.id,
+        binding: { kind: "external", texture },
+        width: size.width,
+        height: size.height,
+        sizeEpoch: size.epoch,
+        colorSpace: options.colorSpace ?? "srgb",
+        // X3: imported video arrives UNPREMULTIPLIED.
+        alphaMode: "unpremultiplied",
+        encoded: true
+      };
+    },
+    release() {
+      acquired = false;
+      ownedFrame?.close();
+      ownedFrame = void 0;
+    },
+    markImported() {
+    },
+    invalidate(next, nextDevice) {
+      generation = next;
+      device = nextDevice;
+      ownedFrame?.close();
+      ownedFrame = void 0;
+      acquired = false;
+    },
+    destroy() {
+      ownedFrame?.close();
+      ownedFrame = void 0;
+      acquired = false;
+    }
+  };
+}
+function createGradientProvider(options) {
+  const width = Math.max(1, options.width ?? 64);
+  const height = Math.max(1, options.height ?? 64);
+  const direction = options.direction ?? [0, 1];
+  const stops = [...options.stops].sort((a, b) => a.offset - b.offset);
+  if (stops.length === 0) {
+    throw rendererError("source-unavailable", `Gradient backdrop "${options.id}" has no stops.`, options.id);
+  }
+  const texels = new Uint8Array(width * height * 4);
+  const axisLength = Math.hypot(direction[0], direction[1]) || 1;
+  const ax = direction[0] / axisLength;
+  const ay = direction[1] / axisLength;
+  const sample = (t) => {
+    const clamped = Math.min(1, Math.max(0, t));
+    let lower = stops[0];
+    let upper = stops[stops.length - 1];
+    for (let i = 0; i < stops.length - 1; i += 1) {
+      const a = stops[i];
+      const b = stops[i + 1];
+      if (clamped >= a.offset && clamped <= b.offset) {
+        lower = a;
+        upper = b;
+        break;
+      }
+    }
+    const span = upper.offset - lower.offset;
+    const local = span <= 0 ? 0 : (clamped - lower.offset) / span;
+    const mix = (from, to) => from + (to - from) * local;
+    const channel = (index) => linearToSrgbChannel(mix(srgbToLinearChannel(lower.color[index]), srgbToLinearChannel(upper.color[index])));
+    return [channel(0), channel(1), channel(2), mix(lower.color[3], upper.color[3])];
+  };
+  for (let y = 0; y < height; y += 1) {
+    for (let x = 0; x < width; x += 1) {
+      const u = width === 1 ? 0 : x / (width - 1);
+      const v = height === 1 ? 0 : y / (height - 1);
+      const t = (u * ax + v * ay + Math.max(0, -ax) + Math.max(0, -ay)) / (Math.abs(ax) + Math.abs(ay) || 1);
+      const [r, g, b, a] = sample(t);
+      const index = (y * width + x) * 4;
+      texels[index + 0] = Math.round(Math.min(1, Math.max(0, r)) * 255);
+      texels[index + 1] = Math.round(Math.min(1, Math.max(0, g)) * 255);
+      texels[index + 2] = Math.round(Math.min(1, Math.max(0, b)) * 255);
+      texels[index + 3] = Math.round(Math.min(1, Math.max(0, a)) * 255);
+    }
+  }
+  let texture;
+  let uploaded = false;
+  let device = options.device;
+  let generation = options.generation ?? 0;
+  return {
+    id: options.id,
+    kind: "gradient",
+    get generation() {
+      return generation;
+    },
+    isDirty() {
+      return !uploaded;
+    },
+    acquire() {
+      texture ??= device.createTexture({
+        label: `vitrea:backdrop:${options.id}:gradient`,
+        size: { width, height, depthOrArrayLayers: 1 },
+        format: "rgba8unorm",
+        usage: copyUsage()
+      });
+      if (!uploaded) {
+        device.queue.writeTexture({ texture }, texels, { bytesPerRow: width * 4, rowsPerImage: height }, { width, height });
+      }
+      return {
+        sourceId: options.id,
+        binding: { kind: "sampled", view: texture.createView() },
+        width,
+        height,
+        sizeEpoch: 0,
+        colorSpace: "srgb",
+        alphaMode: "premultiplied",
+        encoded: true
+      };
+    },
+    release() {
+    },
+    markImported() {
+      uploaded = true;
+    },
+    invalidate(next, nextDevice) {
+      generation = next;
+      device = nextDevice;
+      texture?.destroy();
+      texture = void 0;
+      uploaded = false;
+    },
+    destroy() {
+      texture?.destroy();
+      texture = void 0;
+      uploaded = false;
+    }
+  };
+}
+function linearGradientStops(from, to) {
+  const encode = (c) => [linearToSrgbChannel(c[0]), linearToSrgbChannel(c[1]), linearToSrgbChannel(c[2]), 1];
+  return [
+    { offset: 0, color: encode(from) },
+    { offset: 1, color: encode(to) }
+  ];
+}
+function validateAppTexture(texture, limits, subject) {
+  if (texture.dimension !== "2d") {
+    throw rendererError("texture-dimension", `Backdrop "${subject}" supplied a ${texture.dimension} texture. The sampling path binds a 2d texture; register a 2d texture or a 2d view of one slice.`, subject);
+  }
+  if (texture.depthOrArrayLayers !== 1) {
+    throw rendererError("texture-dimension", `Backdrop "${subject}" supplied a texture with ${texture.depthOrArrayLayers} array layers. Bind a single-layer view.`, subject);
+  }
+  if ((texture.usage & GPUTextureUsage.TEXTURE_BINDING) === 0) {
+    throw rendererError("texture-usage", `Backdrop "${subject}" supplied a texture without GPUTextureUsage.TEXTURE_BINDING, so it cannot be sampled. Add TEXTURE_BINDING to the texture's usage when you create it.`, subject);
+  }
+  if (!SUPPORTED_APP_TEXTURE_FORMATS.includes(texture.format)) {
+    throw rendererError("texture-format", `Backdrop "${subject}" supplied a "${texture.format}" texture. Supported formats are ${SUPPORTED_APP_TEXTURE_FORMATS.join(", ")}.`, subject);
+  }
+  if (texture.width <= 0 || texture.height <= 0) {
+    throw rendererError("texture-size", `Backdrop "${subject}" supplied a ${texture.width}\xD7${texture.height} texture.`, subject);
+  }
+  const max = limits.maxTextureDimension2D;
+  if (texture.width > max || texture.height > max) {
+    throw rendererError("texture-size", `Backdrop "${subject}" supplied a ${texture.width}\xD7${texture.height} texture, past this adapter's maxTextureDimension2D of ${max}.`, subject);
+  }
+}
+function createAppTextureProvider(options) {
+  validateAppTexture(options.texture, options.device.limits, options.id);
+  const encoded = options.encoded ?? !options.texture.format.includes("float");
+  const size = {
+    epoch: 0,
+    width: options.texture.width,
+    height: options.texture.height
+  };
+  const builtGeneration = options.generation ?? 0;
+  let generation = builtGeneration;
+  return {
+    id: options.id,
+    kind: "app-texture-view",
+    get generation() {
+      return generation;
+    },
+    isDirty() {
+      return true;
+    },
+    acquire() {
+      if (generation !== builtGeneration) {
+        throw rendererError("source-unavailable", `Backdrop "${options.id}" wraps a GPUTexture from device generation ${builtGeneration}, and the renderer is now on generation ${generation}. WebGPU has no cross-device texture sharing: unregister this source and register the replacement texture the app made on the new device.`, options.id);
+      }
+      return {
+        sourceId: options.id,
+        binding: {
+          kind: "sampled",
+          view: options.view ?? options.texture.createView()
+        },
+        width: size.width,
+        height: size.height,
+        sizeEpoch: size.epoch,
+        colorSpace: options.colorSpace ?? "srgb",
+        alphaMode: options.alphaMode ?? "premultiplied",
+        encoded
+      };
+    },
+    release() {
+    },
+    markImported() {
+    },
+    invalidate(next) {
+      generation = next;
+    },
+    destroy() {
+    }
+  };
+}
+
+// ../renderer-webgpu/dist/device.js
+function createDeviceHost(options = {}) {
+  let status = {
+    webgpu: "not-requested",
+    deviceHealth: "ok",
+    ownership: "vitrea",
+    device: void 0,
+    generation: 0,
+    replacementPending: false
+  };
+  const hooks = /* @__PURE__ */ new Set();
+  let destroyed = false;
+  let recovery;
+  const publish = (next) => {
+    status = next;
+    if (!destroyed)
+      options.onStatusChange?.(status);
+  };
+  const runTeardown = () => {
+    for (const hook of [...hooks]) {
+      try {
+        hook();
+      } catch {
+      }
+    }
+  };
+  const watchLoss = (device, generation) => {
+    void device.lost.then((info) => {
+      if (destroyed || status.generation !== generation)
+        return;
+      runTeardown();
+      const ownership = status.ownership;
+      publish({
+        webgpu: "available",
+        deviceHealth: "lost",
+        ownership,
+        device: void 0,
+        generation,
+        replacementPending: ownership === "app",
+        unavailableReason: "lost"
+      });
+      if (info.reason === "destroyed")
+        return;
+      if (ownership === "app") {
+        options.onReplacementNeeded?.();
+        return;
+      }
+      const reacquire = options.reacquire;
+      if (reacquire === void 0)
+        return;
+      recovery = (async () => {
+        const replacement = await reacquire();
+        if (destroyed) {
+          replacement?.destroy();
+          return;
+        }
+        if (replacement === void 0)
+          return;
+        attach(replacement, "vitrea");
+      })();
+    });
+  };
+  function attach(device, ownership) {
+    const generation = status.generation + 1;
+    publish({
+      webgpu: "available",
+      deviceHealth: "ok",
+      ownership,
+      device,
+      generation,
+      replacementPending: false
+    });
+    watchLoss(device, generation);
+  }
+  return {
+    get status() {
+      return status;
+    },
+    get capabilityInput() {
+      return { webgpu: status.webgpu, deviceHealth: status.deviceHealth };
+    },
+    requireDevice() {
+      const { device } = status;
+      if (device === void 0) {
+        throw rendererError("device-unavailable", status.replacementPending ? "The app-owned GPUDevice was lost and no replacement has been handed in yet. Call replaceDevice() and re-register the app's texture views before drawing again." : "No GPUDevice is attached. Attach one (platform-web's WebGPU lifecycle produces it) before building resources or drawing.");
+      }
+      return device;
+    },
+    attach,
+    replaceDevice(device) {
+      attach(device, status.ownership);
+    },
+    markUnavailable(reason) {
+      publish({
+        ...status,
+        webgpu: "unavailable",
+        device: void 0,
+        unavailableReason: reason
+      });
+    },
+    addTeardownHook(hook) {
+      hooks.add(hook);
+      return () => hooks.delete(hook);
+    },
+    async settled() {
+      await recovery;
+    },
+    destroy() {
+      destroyed = true;
+      runTeardown();
+      if (status.ownership === "vitrea")
+        status.device?.destroy();
+      hooks.clear();
+      status = { ...status, device: void 0 };
+    }
+  };
+}
+
+// ../renderer-webgpu/dist/governor.js
+var NOMINAL_GOVERNOR = {
+  fieldFamily: "rsupn",
+  refractionResolutionScale: 1,
+  adaptationCadenceHz: 15
+};
+var GOVERNOR_LADDER = [
+  NOMINAL_GOVERNOR,
+  { fieldFamily: "rsup", refractionResolutionScale: 1, adaptationCadenceHz: 15 },
+  { fieldFamily: "rsup", refractionResolutionScale: 0.75, adaptationCadenceHz: 7.5 },
+  { fieldFamily: "rsup", refractionResolutionScale: 0.5, adaptationCadenceHz: 4 }
+];
+var FAMILY_C_CROSS_CHECK = {
+  ran: true,
+  adapter: "apple/metal-3",
+  points: 5535,
+  maxAbsDiffPx: 3042e-8,
+  boundPx: 0.574
+};
+var clampScale = (s) => Math.min(1, Math.max(0.125, s));
+function createGovernor(options = {}) {
+  let knobs = NOMINAL_GOVERNOR;
+  let verified = options.familyCVerified ?? FAMILY_C_CROSS_CHECK.ran;
+  const apply = (next) => {
+    const family = next.fieldFamily === "rsup" && !verified ? "rsupn" : next.fieldFamily;
+    knobs = {
+      fieldFamily: family,
+      refractionResolutionScale: clampScale(next.refractionResolutionScale),
+      adaptationCadenceHz: Math.max(0, next.adaptationCadenceHz)
+    };
+    options.onChange?.(knobs);
+    return knobs;
+  };
+  return {
+    get knobs() {
+      return knobs;
+    },
+    get familyCVerified() {
+      return verified;
+    },
+    set(patch) {
+      return apply({ ...knobs, ...patch });
+    },
+    setLevel(level) {
+      const index = Math.min(GOVERNOR_LADDER.length - 1, Math.max(0, Math.round(level)));
+      return apply(GOVERNOR_LADDER[index]);
+    },
+    reset() {
+      return apply(NOMINAL_GOVERNOR);
+    },
+    recordFamilyCVerified() {
+      verified = true;
+    }
+  };
+}
+
+// ../renderer-webgpu/dist/pipeline-cache.js
+function createPipelineCache(factory) {
+  const modules = /* @__PURE__ */ new Map();
+  const renderPipelines = /* @__PURE__ */ new Map();
+  const computePipelines = /* @__PURE__ */ new Map();
+  let hits = 0;
+  let misses = 0;
+  function memo(store, key, make) {
+    const existing = store.get(key);
+    if (existing !== void 0) {
+      hits += 1;
+      return existing;
+    }
+    misses += 1;
+    const made = make();
+    store.set(key, made);
+    return made;
+  }
+  return {
+    get stats() {
+      return {
+        modules: modules.size,
+        renderPipelines: renderPipelines.size,
+        computePipelines: computePipelines.size,
+        hits,
+        misses
+      };
+    },
+    module(key, source) {
+      return memo(modules, key, () => factory.createShaderModule({ label: key, code: source() }));
+    },
+    renderPipeline(key, describe) {
+      return memo(renderPipelines, key, () => factory.createRenderPipeline(describe()));
+    },
+    computePipeline(key, describe) {
+      return memo(computePipelines, key, () => factory.createComputePipeline(describe()));
+    },
+    clear() {
+      modules.clear();
+      renderPipelines.clear();
+      computePipelines.clear();
+    }
+  };
+}
+var pipelineKey = {
+  field: (family, format) => `field:${family}:${format}`,
+  import: (kind, format) => `import:${kind}:${format}`,
+  chain: (entry, format) => `chain:${entry}:${format}`,
+  analysis: () => "analysis",
+  optics: (format, blend) => `optics:${format}:${blend}`,
+  highlight: (format, blend) => `highlight:${format}:${blend}`
+};
+
+// ../renderer-webgpu/dist/texture-pool.js
+var sameShape = (a, b) => a.width === b.width && a.height === b.height && a.format === b.format && a.usage === b.usage && (a.mipLevelCount ?? 1) === (b.mipLevelCount ?? 1);
+function createTexturePool(allocator) {
+  const entries = /* @__PURE__ */ new Map();
+  let epoch = 0;
+  let created = 0;
+  let destroyed = 0;
+  let reused = 0;
+  const destroy = (entry) => {
+    entry.texture.destroy();
+    destroyed += 1;
+  };
+  return {
+    get sizeEpoch() {
+      return epoch;
+    },
+    get stats() {
+      return { live: entries.size, created, destroyed, reused, epoch };
+    },
+    acquire(key, request) {
+      const existing = entries.get(key);
+      if (existing !== void 0) {
+        if (existing.epoch === epoch && sameShape(existing.request, request)) {
+          reused += 1;
+          return existing.texture;
+        }
+        destroy(existing);
+      }
+      const texture = allocator.createTexture({
+        size: {
+          width: Math.max(1, Math.floor(request.width)),
+          height: Math.max(1, Math.floor(request.height)),
+          depthOrArrayLayers: 1
+        },
+        format: request.format,
+        usage: request.usage,
+        mipLevelCount: request.mipLevelCount ?? 1,
+        ...request.label === void 0 ? {} : { label: request.label }
+      });
+      created += 1;
+      entries.set(key, { texture, request, epoch });
+      return texture;
+    },
+    peek(key) {
+      return entries.get(key)?.texture;
+    },
+    release(key) {
+      const entry = entries.get(key);
+      if (entry === void 0)
+        return;
+      destroy(entry);
+      entries.delete(key);
+    },
+    bumpSizeEpoch() {
+      epoch += 1;
+      return epoch;
+    },
+    sweep() {
+      let swept = 0;
+      for (const [key, entry] of [...entries]) {
+        if (entry.epoch === epoch)
+          continue;
+        destroy(entry);
+        entries.delete(key);
+        swept += 1;
+      }
+      return swept;
+    },
+    clear() {
+      for (const entry of entries.values())
+        destroy(entry);
+      entries.clear();
+    }
+  };
+}
+var poolKey = {
+  backdropLevel0: (sourceId) => `backdrop:${sourceId}:level0`,
+  backdropChain: (sourceId) => `backdrop:${sourceId}:chain`,
+  backdropChainScratch: (sourceId, level) => `backdrop:${sourceId}:chain-scratch:${level}`,
+  backdropBody: (sourceId) => `backdrop:${sourceId}:body`,
+  backdropBodyScratch: (sourceId) => `backdrop:${sourceId}:body-scratch`,
+  backdropUpload: (sourceId) => `backdrop:${sourceId}:upload`,
+  groupField: (groupId) => `group:${groupId}:field`,
+  groupAux: (groupId) => `group:${groupId}:aux`
+};
+
+// ../renderer-webgpu/dist/gpu-context.js
+function createGpuContext(device, generation) {
+  const pool = createTexturePool(device);
+  const cache = createPipelineCache(device);
+  const chainSampler = device.createSampler({
+    label: "vitrea:sampler:chain",
+    magFilter: "linear",
+    minFilter: "linear",
+    mipmapFilter: "linear",
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge"
+  });
+  const flatSampler = device.createSampler({
+    label: "vitrea:sampler:flat",
+    magFilter: "linear",
+    minFilter: "linear",
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge"
+  });
+  return {
+    device,
+    generation,
+    pool,
+    cache,
+    chainSampler,
+    flatSampler,
+    destroy() {
+      pool.clear();
+      cache.clear();
+    }
+  };
+}
+function createUniformSlot(device, floats, label) {
+  const size = Math.ceil(floats * 4 / 16) * 16;
+  const buffer = device.createBuffer({
+    label,
+    size,
+    usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+  });
+  const data = new Float32Array(size / 4);
+  return {
+    buffer,
+    data,
+    write() {
+      device.queue.writeBuffer(buffer, 0, data.buffer, data.byteOffset, data.byteLength);
+    }
+  };
+}
+function createStorageSlot(device, initialBytes, label) {
+  let capacity = Math.max(initialBytes, 256);
+  let buffer = device.createBuffer({
+    label,
+    size: capacity,
+    usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
+  });
+  return {
+    get buffer() {
+      return buffer;
+    },
+    ensure(byteLength) {
+      if (byteLength <= capacity)
+        return buffer;
+      buffer.destroy();
+      capacity = 1 << Math.ceil(Math.log2(byteLength));
+      buffer = device.createBuffer({
+        label,
+        size: capacity,
+        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
+      });
+      return buffer;
+    },
+    write(data, floatCount) {
+      device.queue.writeBuffer(buffer, 0, data.buffer, data.byteOffset, floatCount * 4);
+    },
+    destroy() {
+      buffer.destroy();
+    }
+  };
+}
+
+// ../renderer-webgpu/dist/render-model.js
+var IDLE_CHANNELS = {
+  press: 0,
+  glow: 0,
+  sweep: 0,
+  lensStrength: 1
+};
+
+// ../renderer-webgpu/dist/instances.js
+var INSTANCE_FLOATS = 16;
+var INSTANCE_BYTES = INSTANCE_FLOATS * 4;
+var channelsOf = (input) => ({
+  ...IDLE_CHANNELS,
+  ...input.channels
+});
+function compressedChannels(shape, press) {
+  if (press <= 0)
+    return shape;
+  const scale = 1 - Math.min(1, Math.max(0, press)) * DEFAULT_MOTION_PROFILE.pressCompressionScale;
+  return { ...shape, size: [shape.size[0] * scale, shape.size[1] * scale] };
+}
+function resolveSurfaces(group, family, profile = DEFAULT_MATERIAL_PROFILE) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const surface of group.surfaces) {
+    if (byId.has(surface.nodeId)) {
+      throw rendererError("source-identity", `Group "${group.groupId}" lists surface "${surface.nodeId}" twice.`, surface.nodeId);
+    }
+    byId.set(surface.nodeId, surface);
+  }
+  const resolvedShapes = /* @__PURE__ */ new Map();
+  const resolving = /* @__PURE__ */ new Set();
+  const resolveShapeOf = (surface) => {
+    const cached = resolvedShapes.get(surface.nodeId);
+    if (cached !== void 0)
+      return cached;
+    if (resolving.has(surface.nodeId)) {
+      throw rendererError("pass-input", `Concentric surfaces in group "${group.groupId}" form a cycle through "${surface.nodeId}". A level set needs a parent field that resolves without it.`, surface.nodeId);
+    }
+    resolving.add(surface.nodeId);
+    const channels = channelsOf(surface);
+    const reference = surface.reference ?? "apple-continuous";
+    if (surface.concentricOf === void 0) {
+      const shape2 = resolveFromChannels(compressedChannels(surface.shape, channels.press), reference, surface.family, { devMode: false });
+      resolvedShapes.set(surface.nodeId, shape2);
+      resolving.delete(surface.nodeId);
+      return shape2;
+    }
+    const parentInput = byId.get(surface.concentricOf.nodeId);
+    if (parentInput === void 0) {
+      throw rendererError("pass-input", `Surface "${surface.nodeId}" is concentric to "${surface.concentricOf.nodeId}", which is not a member of group "${group.groupId}". X8 rider 2 renders a concentric child as a level set of its parent's field, so the parent has to be in the same field pass.`, surface.nodeId);
+    }
+    const shape = resolveConcentric(resolveShapeOf(parentInput), {
+      inset: surface.concentricOf.inset
+    }).shape;
+    resolvedShapes.set(surface.nodeId, shape);
+    resolving.delete(surface.nodeId);
+    return shape;
+  };
+  const paramsFor = (shape) => family === "rsup" ? governorFieldParams(shape) : fieldParams(shape);
+  return group.surfaces.filter((surface) => surface.fieldReferenceOnly !== true).map((surface) => {
+    const channels = channelsOf(surface);
+    const shape = resolveShapeOf(surface);
+    const fieldSource = surface.concentricOf === void 0 ? shape : resolveShapeOf(byId.get(surface.concentricOf.nodeId));
+    const inset = surface.concentricOf?.inset ?? 0;
+    const spanPx = Math.min(shape.channels.size[0], shape.channels.size[1]);
+    return {
+      nodeId: surface.nodeId,
+      shape,
+      field: paramsFor(fieldSource),
+      inset,
+      centre: [fieldSource.channels.center[0], fieldSource.channels.center[1]],
+      channels,
+      spanPx,
+      lensDepthPx: lensDepthPx(shape.channels.thickness, spanPx, profile)
+    };
+  });
+}
+function groupFieldRect(surfaces, union = DEFAULT_GROUP_UNION, rimWidthPx = 2) {
+  if (surfaces.length === 0)
+    return { x: 0, y: 0, width: 0, height: 0 };
+  let minX = Number.POSITIVE_INFINITY;
+  let minY = Number.POSITIVE_INFINITY;
+  let maxX = Number.NEGATIVE_INFINITY;
+  let maxY = Number.NEGATIVE_INFINITY;
+  for (const surface of surfaces) {
+    const [cx, cy] = surface.shape.channels.center;
+    const [w, h] = surface.shape.channels.size;
+    minX = Math.min(minX, cx - w / 2);
+    minY = Math.min(minY, cy - h / 2);
+    maxX = Math.max(maxX, cx + w / 2);
+    maxY = Math.max(maxY, cy + h / 2);
+  }
+  const pad = rimWidthPx + union.maxBulge + 1;
+  return {
+    x: minX - pad,
+    y: minY - pad,
+    width: maxX - minX + 2 * pad,
+    height: maxY - minY + 2 * pad
+  };
+}
+function clipFieldRectToCanvas(snapped, devicePixelRatio, canvasDevice) {
+  const left = Math.max(0, Math.round(snapped.x * devicePixelRatio));
+  const top = Math.max(0, Math.round(snapped.y * devicePixelRatio));
+  const right = Math.min(canvasDevice[0], Math.round((snapped.x + snapped.width) * devicePixelRatio));
+  const bottom = Math.min(canvasDevice[1], Math.round((snapped.y + snapped.height) * devicePixelRatio));
+  if (right <= left || bottom <= top)
+    return void 0;
+  return { x: left, y: top, width: right - left, height: bottom - top };
+}
+function snapRectToDevicePixels(rect, devicePixelRatio) {
+  const x = Math.floor(rect.x * devicePixelRatio) / devicePixelRatio;
+  const y = Math.floor(rect.y * devicePixelRatio) / devicePixelRatio;
+  const right = Math.ceil((rect.x + rect.width) * devicePixelRatio) / devicePixelRatio;
+  const bottom = Math.ceil((rect.y + rect.height) * devicePixelRatio) / devicePixelRatio;
+  return { x, y, width: Math.max(right - x, 0), height: Math.max(bottom - y, 0) };
+}
+function packInstances(surfaces, origin, into) {
+  const needed = Math.max(surfaces.length, 1) * INSTANCE_FLOATS;
+  const data = into !== void 0 && into.length >= needed ? into : new Float32Array(needed);
+  for (let i = 0; i < surfaces.length; i += 1) {
+    const s = surfaces[i];
+    const o = i * INSTANCE_FLOATS;
+    data[o + 0] = s.centre[0] - origin[0];
+    data[o + 1] = s.centre[1] - origin[1];
+    data[o + 2] = s.field.halfW;
+    data[o + 3] = s.field.halfH;
+    data[o + 4] = s.field.reach;
+    data[o + 5] = s.field.k[0];
+    data[o + 6] = s.field.k[1];
+    data[o + 7] = s.field.k[2];
+    data[o + 8] = s.field.k[3];
+    data[o + 9] = s.field.k[4];
+    data[o + 10] = s.inset;
+    data[o + 11] = s.shape.channels.thickness;
+    data[o + 12] = s.channels.press;
+    data[o + 13] = s.channels.glow;
+    data[o + 14] = s.lensDepthPx * Math.min(1, Math.max(0, s.channels.lensStrength));
+    data[o + 15] = 0;
+  }
+  return { data, count: surfaces.length };
+}
+
+// ../renderer-webgpu/dist/timing.js
+function supportsTimestamps(device) {
+  return device.features.has("timestamp-query");
+}
+function createTimingCollector(device, capacity = 64) {
+  const querySet = device.createQuerySet({
+    label: "vitrea:timing",
+    type: "timestamp",
+    count: capacity * 2
+  });
+  const byteLength = capacity * 2 * 8;
+  const resolveBuffer = device.createBuffer({
+    label: "vitrea:timing:resolve",
+    size: byteLength,
+    usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.COPY_SRC
+  });
+  const staging = device.createBuffer({
+    label: "vitrea:timing:staging",
+    size: byteLength,
+    usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST
+  });
+  let used = 0;
+  let anomalies = 0;
+  const labels = [];
+  const take = (label) => {
+    if (used >= capacity)
+      return void 0;
+    const index = used;
+    used += 1;
+    labels[index] = label;
+    return { begin: index * 2, end: index * 2 + 1 };
+  };
+  return {
+    capacity,
+    get used() {
+      return used;
+    },
+    get anomalies() {
+      return anomalies;
+    },
+    renderSlot(label) {
+      const slot = take(label);
+      if (slot === void 0)
+        return void 0;
+      return {
+        querySet,
+        beginningOfPassWriteIndex: slot.begin,
+        endOfPassWriteIndex: slot.end
+      };
+    },
+    computeSlot(label) {
+      const slot = take(label);
+      if (slot === void 0)
+        return void 0;
+      return {
+        querySet,
+        beginningOfPassWriteIndex: slot.begin,
+        endOfPassWriteIndex: slot.end
+      };
+    },
+    resolve(encoder) {
+      if (used === 0)
+        return;
+      encoder.resolveQuerySet(querySet, 0, used * 2, resolveBuffer, 0);
+      encoder.copyBufferToBuffer(resolveBuffer, 0, staging, 0, used * 2 * 8);
+    },
+    async read() {
+      const out = /* @__PURE__ */ new Map();
+      if (used === 0)
+        return out;
+      await staging.mapAsync(GPUMapMode.READ, 0, used * 2 * 8);
+      const view = new BigInt64Array(staging.getMappedRange(0, used * 2 * 8).slice(0));
+      staging.unmap();
+      for (let i = 0; i < used; i += 1) {
+        const begin = view[i * 2] ?? 0n;
+        const end = view[i * 2 + 1] ?? 0n;
+        const label = labels[i] ?? `pass-${i}`;
+        const elapsed = Number(end - begin);
+        if (!Number.isFinite(elapsed) || elapsed < 0 || begin === 0n && end === 0n) {
+          anomalies += 1;
+          continue;
+        }
+        out.set(label, (out.get(label) ?? 0) + elapsed);
+      }
+      return out;
+    },
+    reset() {
+      used = 0;
+      labels.length = 0;
+    },
+    destroy() {
+      querySet.destroy();
+      resolveBuffer.destroy();
+      staging.destroy();
+    }
+  };
+}
+var PASS_LABEL = {
+  import: "backdrop-import",
+  chain: "blur-chain",
+  bodyBlur: "body-blur",
+  analysis: "analysis",
+  field: "group-field",
+  optics: "optics",
+  highlight: "highlight"
+};
+
+// ../renderer-webgpu/dist/wgsl/cross-check.js
+var CROSS_CHECK_SHAPE_FLOATS = 12;
+var CROSS_CHECK_WORKGROUP = 64;
+var WGSL_CROSS_CHECK_PASS = `struct CheckShape {
+  centre : vec2f,
+  half   : vec2f,
+  re     : f32,
+  k0     : f32,
+  k1     : f32,
+  k2     : f32,
+  k3     : f32,
+  k4     : f32,
+  _pad0  : f32,
+  _pad1  : f32,
+};
+
+/// point.xy = shape-local coordinates, point.z = shape index, point.w unused
+@group(0) @binding(0) var<storage, read> checkShapes : array<CheckShape>;
+@group(0) @binding(1) var<storage, read> checkPoints : array<vec4f>;
+@group(0) @binding(2) var<storage, read_write> outRsupn : array<f32>;
+@group(0) @binding(3) var<storage, read_write> outRsup  : array<f32>;
+@group(0) @binding(4) var<uniform> checkCount : vec4u;
+
+@compute @workgroup_size(${CROSS_CHECK_WORKGROUP})
+fn cs_cross_check(@builtin(global_invocation_id) gid : vec3u) {
+  let i = gid.x;
+  if (i >= checkCount.x) { return; }
+
+  let p = checkPoints[i];
+  let s = checkShapes[u32(p.z)];
+  let k = vec4f(s.k0, s.k1, s.k2, s.k3);
+  let local = p.xy - s.centre;
+
+  outRsupn[i] = sd_rsupn(local, s.half, s.re, k, s.k4);
+  outRsup[i]  = sd_rsup(local, s.half, s.re, k, s.k4);
+}`;
+
+// ../renderer-webgpu/dist/wgsl/backdrop.js
+var WGSL_IMPORT_PASS = `struct ImportUniforms {
+  m0     : vec4f,   // colour matrix row 0 (xyz), srcEncoded (w)
+  m1     : vec4f,   // row 1 (xyz), alphaMode (w)
+  m2     : vec4f,   // row 2 (xyz), unused (w)
+  fit    : vec4f,   // uv scale (xy), uv offset (zw) \u2014 the source's fit into the target
+};
+
+@group(0) @binding(0) var<uniform> iu : ImportUniforms;
+@group(0) @binding(1) var srcSampler : sampler;
+@group(0) @binding(2) var srcTexture : SRC_TEXTURE_TYPE;
+
+fn sample_src(uv : vec2f) -> vec4f {
+  return SRC_SAMPLE_EXPR;
+}
+
+@fragment
+fn fs_import(in : FullscreenOut) -> @location(0) vec4f {
+  let uv = in.uv * iu.fit.xy + iu.fit.zw;
+  var raw = sample_src(clamp(uv, vec2f(0.0), vec2f(1.0)));
+
+  let alphaMode = iu.m1.w;
+  var alpha = raw.a;
+  var colour = raw.rgb;
+
+  if (alphaMode > 1.5) {
+    alpha = 1.0;
+  } else if (alphaMode > 0.5) {
+    // Already unpremultiplied: nothing to undo.
+  } else {
+    // Premultiplied input \u2014 undo it before the non-linear decode. A fully
+    // transparent texel carries zero colour, so the floored divide returns zero
+    // there without a branch.
+    colour = colour / max(alpha, 1e-6);
+  }
+
+  if (iu.m0.w > 0.5) {
+    colour = srgb_to_linear(clamp(colour, vec3f(0.0), vec3f(1.0)));
+  }
+
+  // Colour-space conversion in linear light. Identity for sRGB sources.
+  colour = vec3f(dot(iu.m0.xyz, colour), dot(iu.m1.xyz, colour), dot(iu.m2.xyz, colour));
+
+  return vec4f(max(colour, vec3f(0.0)) * alpha, alpha);
+}`;
+function importPassSource(kind) {
+  const type = kind === "external" ? "texture_external" : "texture_2d<f32>";
+  const expr = kind === "external" ? "textureSampleBaseClampToEdge(srcTexture, srcSampler, uv)" : "textureSampleLevel(srcTexture, srcSampler, uv, 0.0)";
+  return WGSL_IMPORT_PASS.replace("SRC_TEXTURE_TYPE", type).replace("SRC_SAMPLE_EXPR", expr);
+}
+var WGSL_DOWNSAMPLE_PASS = `struct ChainUniforms {
+  texel : vec4f,   // 1/srcSize (xy), unused (zw)
+  params : vec4f,  // sigma in texels (x), direction (yz), unused (w)
+};
+
+@group(0) @binding(0) var<uniform> cu : ChainUniforms;
+@group(0) @binding(1) var chainSampler : sampler;
+@group(0) @binding(2) var chainTexture : texture_2d<f32>;
+
+fn tap(uv : vec2f, o : vec2f) -> vec4f {
+  return textureSampleLevel(chainTexture, chainSampler, uv + o * cu.texel.xy, 0.0);
+}
+
+@fragment
+fn fs_downsample(in : FullscreenOut) -> @location(0) vec4f {
+  let uv = in.uv;
+
+  let a = tap(uv, vec2f(-2.0,  2.0));
+  let b = tap(uv, vec2f( 0.0,  2.0));
+  let c = tap(uv, vec2f( 2.0,  2.0));
+  let d = tap(uv, vec2f(-2.0,  0.0));
+  let e = tap(uv, vec2f( 0.0,  0.0));
+  let f = tap(uv, vec2f( 2.0,  0.0));
+  let g = tap(uv, vec2f(-2.0, -2.0));
+  let h = tap(uv, vec2f( 0.0, -2.0));
+  let i = tap(uv, vec2f( 2.0, -2.0));
+  let j = tap(uv, vec2f(-1.0,  1.0));
+  let k = tap(uv, vec2f( 1.0,  1.0));
+  let l = tap(uv, vec2f(-1.0, -1.0));
+  let m = tap(uv, vec2f( 1.0, -1.0));
+
+  // Weights: the centre cross carries 0.5 across four inner taps, the corners
+  // and edges the remaining 0.5. Sums to exactly 1, so the chain neither gains
+  // nor loses energy \u2014 which is what keeps the analysis pass's luminance honest
+  // however many levels it reads through.
+  var out = (j + k + l + m) * 0.5 * 0.25;
+  out = out + (a + b + d + e) * 0.125 * 0.25;
+  out = out + (b + c + e + f) * 0.125 * 0.25;
+  out = out + (d + e + g + h) * 0.125 * 0.25;
+  out = out + (e + f + h + i) * 0.125 * 0.25;
+  return out;
+}
+
+/// Separable Gaussian, nine taps, run once horizontally and once vertically to
+/// take the nearest chain level up to the material's exact sigma.
+@fragment
+fn fs_blur(in : FullscreenOut) -> @location(0) vec4f {
+  let dir = cu.params.yz;
+  let sigma = max(cu.params.x, 1e-4);
+  let inv = -0.5 / (sigma * sigma);
+
+  var sum = vec4f(0.0);
+  var weight = 0.0;
+  for (var t = -4; t <= 4; t = t + 1) {
+    let ft = f32(t);
+    let w = exp(ft * ft * inv);
+    sum = sum + textureSampleLevel(chainTexture, chainSampler, in.uv + dir * ft * cu.texel.xy, 0.0) * w;
+    weight = weight + w;
+  }
+  return sum / weight;
+}`;
+
+// ../renderer-webgpu/dist/wgsl/field.js
+var WGSL_INSTANCE_STRUCT = `struct Instance {
+  centre : vec2f,   //  0  group-local CSS px
+  half   : vec2f,   //  8  half-extents of the field's OWN shape (the parent's, for a concentric child)
+  re     : f32,     // 16  corner reach
+  k0     : f32,     // 20
+  k1     : f32,     // 24
+  k2     : f32,     // 28
+  k3     : f32,     // 32
+  k4     : f32,     // 36
+  inset  : f32,     // 40  X8 rider 2: level-set offset. 0 for an ordinary surface.
+  thick  : f32,     // 44  material thickness, CSS px
+  press  : f32,     // 48  interaction channel value, 0..1
+  glow   : f32,     // 52  interaction channel value, 0..1
+  lensDepth : f32,  // 56  CPU-resolved lens depth in CSS px (material.ts), already scaled by the lensStrength channel
+  _pad   : f32,     // 60
+};`;
+var WGSL_FIELD_SAMPLE = `struct FieldSample {
+  d : f32,
+  g : vec2f,
+};`;
+var WGSL_RSUPN_GRAD = `fn sd_rsupn_grad(p : vec2f, half : vec2f, re : f32, k : vec4f, k4 : f32) -> FieldSample {
+  let q  = abs(p) - half + vec2f(re, re);
+  let c  = max(q, vec2f(0.0, 0.0));
+  let r2 = max(dot(c, c), 1e-20);
+  let inv = 1.0 / r2;
+  let rho = sqrt(r2);
+  let s2 = 2.0 * c.x * c.y * inv;
+  let c2 = (c.x * c.x - c.y * c.y) * inv;
+
+  // A = sum k_i s2^i, B = sum (i+2) k_i s2^i, C = sum (i+1)(i+2) k_i s2^i.
+  var accA = k4;
+  accA = accA * s2 + k.w;
+  accA = accA * s2 + k.z;
+  accA = accA * s2 + k.y;
+  accA = accA * s2 + k.x;
+
+  var accB = 6.0 * k4;
+  accB = accB * s2 + 5.0 * k.w;
+  accB = accB * s2 + 4.0 * k.z;
+  accB = accB * s2 + 3.0 * k.y;
+  accB = accB * s2 + 2.0 * k.x;
+
+  var accC = 30.0 * k4;
+  accC = accC * s2 + 20.0 * k.w;
+  accC = accC * s2 + 12.0 * k.z;
+  accC = accC * s2 + 6.0 * k.y;
+  accC = accC * s2 + 2.0 * k.x;
+
+  let R      = re * (1.0 + s2 * s2 * accA);
+  let dRds2  = re * s2 * accB;
+  let d2Rds2 = re * accC;
+  let dRdt   = dRds2 * (2.0 * c2);
+
+  let mm   = min(max(q.x, q.y), 0.0);
+  let base = rho + mm - R;
+  // Anchored at the contour radius, mirroring sd_rsupn: the normalization's
+  // slope is read at the foot of the Newton step, never at a sample radius
+  // inside the contour. See geometry's field.ts, "The normalization".
+  let atRho = rho >= R;
+  let w    = select(R, rho, atRho);
+  let g    = select(dRdt / R, dRdt * inv * rho, atRho);
+  let norm = sqrt(1.0 + g * g);
+  let n    = 1.0 / norm;
+
+  let ds2dcx = -2.0 * c.y * c2 * inv;
+  let ds2dcy =  2.0 * c.x * c2 * inv;
+  let dc2dcx =  2.0 * c.x * inv * (1.0 - c2);
+  let dc2dcy = -2.0 * c.y * inv * (1.0 + c2);
+
+  let drhodcx = c.x / rho;
+  let drhodcy = c.y / rho;
+
+  let dRdcx = dRds2 * ds2dcx;
+  let dRdcy = dRds2 * ds2dcy;
+
+  let dTermdcx = 2.0 * (d2Rds2 * ds2dcx * c2 + dRds2 * dc2dcx);
+  let dTermdcy = 2.0 * (d2Rds2 * ds2dcy * c2 + dRds2 * dc2dcy);
+
+  // w's derivative follows whichever of rho and R is larger. Exact across the
+  // switch because the switch locus is rho == R, the contour, where base == 0
+  // kills the only term the jump lives in.
+  let dwdcx = select(dRdcx, drhodcx, atRho);
+  let dwdcy = select(dRdcy, drhodcy, atRho);
+
+  let dgdcx = dTermdcx / w - (dRdt * dwdcx) / (w * w);
+  let dgdcy = dTermdcy / w - (dRdt * dwdcy) / (w * w);
+
+  let n3 = n * n * n;
+  let dddcx = (drhodcx - dRdcx) * n + base * (-g * n3 * dgdcx);
+  let dddcy = (drhodcy - dRdcy) * n + base * (-g * n3 * dgdcy);
+
+  let mx = select(0.0, 1.0, q.x > 0.0);
+  let my = select(0.0, 1.0, q.y > 0.0);
+  let inBox = max(q.x, q.y) <= 0.0;
+  let dmmdqx = select(0.0, 1.0, inBox && q.x >= q.y);
+  let dmmdqy = select(0.0, 1.0, inBox && q.y >  q.x);
+
+  let sx = select(1.0, -1.0, p.x < 0.0);
+  let sy = select(1.0, -1.0, p.y < 0.0);
+
+  var out : FieldSample;
+  out.d = base * n;
+  out.g = vec2f((dddcx * mx + n * dmmdqx) * sx, (dddcy * my + n * dmmdqy) * sy);
+  return out;
+}`;
+var WGSL_RSUP_GRAD = `fn sd_rsup_grad(p : vec2f, half : vec2f, re : f32, k : vec4f, k4 : f32) -> FieldSample {
+  let q  = abs(p) - half + vec2f(re, re);
+  let c  = max(q, vec2f(0.0, 0.0));
+  let r2 = max(dot(c, c), 1e-20);
+  let rho = sqrt(r2);
+  let s2 = 2.0 * c.x * c.y / r2;
+
+  var accA = k4;
+  accA = accA * s2 + k.w;
+  accA = accA * s2 + k.z;
+  accA = accA * s2 + k.y;
+  accA = accA * s2 + k.x;
+
+  var accB = 6.0 * k4;
+  accB = accB * s2 + 5.0 * k.w;
+  accB = accB * s2 + 4.0 * k.z;
+  accB = accB * s2 + 3.0 * k.y;
+  accB = accB * s2 + 2.0 * k.x;
+
+  let c2 = (c.x * c.x - c.y * c.y) / r2;
+  let R  = re * (1.0 + s2 * s2 * accA);
+
+  let sx = select(1.0, -1.0, p.x < 0.0);
+  let sy = select(1.0, -1.0, p.y < 0.0);
+
+  var out : FieldSample;
+  out.d = rho + min(max(q.x, q.y), 0.0) - R;
+
+  if (c.x <= 0.0 && c.y <= 0.0) {
+    // Straight-edge and deep-interior: the normal is the axis the box branch is
+    // measuring along.
+    out.g = select(vec2f(0.0, sy), vec2f(sx, 0.0), q.x > q.y);
+    return out;
+  }
+
+  let dRdt = re * s2 * accB * (2.0 * c2);
+  let rhoHat = c / rho;
+  let gg = dRdt / rho;
+  let nx = rhoHat.x + gg * rhoHat.y;
+  let ny = rhoHat.y - gg * rhoHat.x;
+  let len = max(length(vec2f(nx, ny)), 1e-20);
+  out.g = vec2f(sx * nx / len, sy * ny / len);
+  return out;
+}`;
+var WGSL_SMOOTH_UNION = `fn union_blend(a : f32, b : f32, u : vec3f) -> vec2f {
+  let neck = u.x;
+  let maxBulge = u.y;
+  let sep = max(u.z * 0.5, 1e-6);
+
+  let nearest = min(a, b);
+  let capped = min(neck, 4.0 * maxBulge);
+  let gate = 1.0 - smoothstep(0.0, sep, max(nearest, 0.0));
+  let k = capped * gate;
+
+  if (k <= 0.0) {
+    return vec2f(nearest, select(0.0, 1.0, a <= b));
+  }
+
+  let h = clamp(0.5 + 0.5 * (b - a) / k, 0.0, 1.0);
+  return vec2f(b + h * (a - b) - k * h * (1.0 - h), h);
+}`;
+var WGSL_FIELD_PASS = `struct FieldUniforms {
+  /// screen.xy = target size in device px, screen.z = CSS px per device px,
+  /// screen.w = coverage ramp width in CSS px
+  screen : vec4f,
+  /// neckWidth, maxBulge, separationThreshold, unused
+  unionP : vec4f,
+  counts : vec4u,
+};
+
+// Per-surface optical scalars ride through the union in 'aux': the group is one
+// field but its members are not one size, and carrying them per pixel is what
+// lets a 40 px button and a 320 px platter share a field pass and still lens by
+// their own depth \u2014 parent acceptance #2 inside a GlassEffectContainer.
+//   aux = (lensDepthPx, glow, thicknessPx, press)
+
+@group(0) @binding(0) var<uniform> fu : FieldUniforms;
+@group(0) @binding(1) var<storage, read> instances : array<Instance>;
+
+struct Member {
+  d   : f32,
+  g   : vec2f,
+  aux : vec4f,
+};
+
+fn eval_instance(i : u32, p : vec2f) -> Member {
+  let s = instances[i];
+  let k = vec4f(s.k0, s.k1, s.k2, s.k3);
+  // X8 rider 2 in one line: the child is the parent's field, shifted. There is
+  // no branch and no second path, so no caller can opt into the instantiated
+  // shape whose offset error the rider rules out.
+  let f = FIELD_FN(p - s.centre, s.half, s.re, k, s.k4);
+  var m : Member;
+  m.d = f.d + s.inset;
+  m.g = f.g;
+  m.aux = vec4f(s.lensDepth, s.glow, s.thick, s.press);
+  return m;
+}
+
+struct FieldOut {
+  @location(0) field : vec4f,
+  @location(1) aux   : vec4f,
+};
+
+@fragment
+fn fs_field(in : FullscreenOut) -> FieldOut {
+  // GROUP-LOCAL CSS px. The instance buffer's centres were already made relative
+  // to the group's rect on the CPU (f32 loses resolution at large magnitudes, so
+  // a field evaluated at viewport y = 40000 would quantise its own corner), and
+  // adding the origin back here would offset every shape by it twice.
+  let p = in.uv * fu.screen.xy * fu.screen.z;
+
+  var out : FieldOut;
+  let count = fu.counts.x;
+  if (count == 0u) {
+    // Large but FINITE: rgba16float overflows to +Inf past ~65504, and NaN
+    // coverage downstream is not reliably zero.
+    out.field = vec4f(65000.0, 0.0, -1.0, 0.0);
+    out.aux = vec4f(0.0);
+    return out;
+  }
+
+  var acc = eval_instance(0u, p);
+  var nearest = acc.d;
+  for (var i = 1u; i < count; i = i + 1u) {
+    let s = eval_instance(i, p);
+    let blend = union_blend(acc.d, s.d, fu.unionP.xyz);
+    let h = blend.y;
+    acc.d = blend.x;
+    acc.g = mix(s.g, acc.g, h);
+    acc.aux = mix(s.aux, acc.aux, h);
+    nearest = min(nearest, s.d);
+  }
+  // One clamp at the end of the fold, so |union - min| <= maxBulge holds for any
+  // member count and any order rather than per blend step.
+  acc.d = max(acc.d, nearest - fu.unionP.y);
+
+  let len = max(length(acc.g), 1e-6);
+  let normal = acc.g / len;
+  let coverage = clamp(0.5 - acc.d / max(fu.screen.w, 1e-6), 0.0, 1.0);
+
+  out.field = vec4f(acc.d, normal.x, normal.y, coverage);
+  out.aux = acc.aux;
+  return out;
+}`;
+function fieldPassSource(family) {
+  const kernels = family === "rsupn" ? [WGSL_RSUPN, WGSL_RSUPN_GRAD] : [WGSL_RSUP, WGSL_RSUP_GRAD];
+  const fn = family === "rsupn" ? "sd_rsupn_grad" : "sd_rsup_grad";
+  return [
+    WGSL_INSTANCE_STRUCT,
+    WGSL_FIELD_SAMPLE,
+    ...kernels,
+    WGSL_SMOOTH_UNION,
+    WGSL_FIELD_PASS.replace("FIELD_FN", fn)
+  ].join("\n\n");
+}
+var WGSL_FIELD_KERNELS = [
+  WGSL_INSTANCE_STRUCT,
+  WGSL_FIELD_SAMPLE,
+  WGSL_RSUPN,
+  WGSL_RSUP,
+  WGSL_RSUPN_GRAD,
+  WGSL_RSUP_GRAD,
+  WGSL_SMOOTH_UNION
+].join("\n\n");
+
+// ../renderer-webgpu/dist/wgsl/highlight.js
+var WGSL_HIGHLIGHT_PASS = `struct HighlightUniforms {
+  /// viewport size in device px (xy), CSS px per device px (z), unused (w)
+  screen : vec4f,
+  /// sweep position 0..1 (x), band width in radians (y), sweep gain (z), rim width px (w)
+  sweep : vec4f,
+  /// press point in viewport CSS px (xy), glow radius px (z), glow gain (w)
+  glow : vec4f,
+  /// highlight colour, linear light (xyz), unused (w)
+  colour : vec4f,
+  /// fieldSize.xy, fieldUpsampled (z), unused (w)
+  flags : vec4f,
+};
+
+@group(0) @binding(0) var<uniform> hu : HighlightUniforms;
+@group(0) @binding(1) var fieldTexture : texture_2d<f32>;
+@group(0) @binding(2) var auxTexture : texture_2d<f32>;
+@group(0) @binding(3) var fieldSampler : sampler;
+
+const TAU = 6.283185307179586;
+
+/// Shortest angular distance, so the band wraps continuously past the seam
+/// instead of stalling there for one revolution.
+fn angle_delta(a : f32, b : f32) -> f32 {
+  let raw = abs(a - b);
+  return min(raw, TAU - raw);
+}
+
+@fragment
+fn fs_highlight(in : FullscreenOut) -> @location(0) vec4f {
+  // Exact load nominally; filtered when the governor's resolution knob had the
+  // field rasterised below the group's rect. The sweep rides the rim, which is
+  // the one place a nearest read of a coarse field would show its grid.
+  var field : vec4f;
+  var aux : vec4f;
+  if (hu.flags.z > 0.5) {
+    field = textureSampleLevel(fieldTexture, fieldSampler, in.uv, 0.0);
+    aux = textureSampleLevel(auxTexture, fieldSampler, in.uv, 0.0);
+  } else {
+    let texel = vec2i(in.uv * hu.flags.xy);
+    field = textureLoad(fieldTexture, texel, 0);
+    aux = textureLoad(auxTexture, texel, 0);
+  }
+  let d = field.x;
+  let normal = field.yz;
+  let coverage = field.w;
+
+  if (coverage <= 0.0) {
+    return vec4f(0.0);
+  }
+
+  // Specular sweep: a travelling band in the rim's angular coordinate.
+  let rim = clamp(1.0 - abs(d) / max(hu.sweep.w, 1e-4), 0.0, 1.0);
+  let theta = atan2(normal.y, normal.x) + TAU * 0.5;
+  let centre = hu.sweep.x * TAU;
+  let width = max(hu.sweep.y, 1e-4);
+  let band = exp(-pow(angle_delta(theta, centre) / width, 2.0));
+  let sweep = rim * rim * band * hu.sweep.z;
+
+  // Press glow: radial, in CSS px, clipped by coverage so it cannot leak past
+  // the material's edge.
+  let posCss = in.position.xy * hu.screen.z;
+  let dist = length(posCss - hu.glow.xy);
+  let radial = clamp(1.0 - dist / max(hu.glow.z, 1e-4), 0.0, 1.0);
+  // 'aux.y' is the per-pixel glow channel, unioned in the field pass, so a group
+  // whose members glow independently does not need a pass each.
+  let press = radial * radial * hu.glow.w * aux.y;
+
+  let intensity = clamp(sweep + press, 0.0, 1.0) * coverage;
+  if (intensity <= 0.0) {
+    return vec4f(0.0);
+  }
+  return encode_output(hu.colour.rgb, intensity);
+}`;
+
+// ../renderer-webgpu/dist/wgsl/optics.js
+var WGSL_OPTICS_PASS = `struct OpticsUniforms {
+  /// viewport size in device px (xy), CSS px per device px (z), coverage ramp px (w)
+  screen : vec4f,
+  /// backdrop uv transform on viewport-normalised coords: scale (xy), offset (zw)
+  fit : vec4f,
+  /// refractionScale, bodyLodPerPx, rimLodBias, chainMaxLod
+  lens : vec4f,
+  /// fixed tint colour, linear light (xyz), tint alpha (w)
+  tint : vec4f,
+  /// adapted tint colour, linear light (xyz), adaptation strength (w)
+  adapt : vec4f,
+  /// rimWidthPx, rimAlpha, specularPower, specularGain
+  rim : vec4f,
+  /// light direction, unit (xy), shadowDepth (z), shadowAlpha (w)
+  light : vec4f,
+  /// hasBackdrop, fieldSize.xy, fieldUpsampled
+  flags : vec4f,
+};
+
+@group(0) @binding(0) var<uniform> ou : OpticsUniforms;
+@group(0) @binding(1) var fieldTexture : texture_2d<f32>;
+@group(0) @binding(2) var auxTexture : texture_2d<f32>;
+@group(0) @binding(3) var backdropSampler : sampler;
+@group(0) @binding(4) var backdropChain : texture_2d<f32>;
+@group(0) @binding(5) var backdropBody : texture_2d<f32>;
+@group(0) @binding(6) var fieldSampler : sampler;
+
+/// Rim proximity: 1 exactly on the contour, falling to 0 by 'width' on either
+/// side. Symmetric, so the rim is a band on the boundary rather than a plateau
+/// that keeps burning outward where coverage has already faded.
+fn rim_weight(d : f32, width : f32) -> f32 {
+  let t = clamp(1.0 - abs(d) / max(width, 1e-4), 0.0, 1.0);
+  return t * t;
+}
+
+@fragment
+fn fs_optics(in : FullscreenOut) -> @location(0) vec4f {
+  // Nominally the field is one texel per device pixel, so the read is an exact
+  // load and no filter touches the distance or the normal. Under the governor's
+  // 'refractionResolutionScale' the field was rasterised smaller than the group's
+  // rect, and then it has to be filtered: a nearest read would quantise the
+  // contour to the coarse grid and the rim would step along it.
+  var field : vec4f;
+  var aux : vec4f;
+  if (ou.flags.w > 0.5) {
+    field = textureSampleLevel(fieldTexture, fieldSampler, in.uv, 0.0);
+    aux = textureSampleLevel(auxTexture, fieldSampler, in.uv, 0.0);
+  } else {
+    let texel = vec2i(in.uv * ou.flags.yz);
+    field = textureLoad(fieldTexture, texel, 0);
+    aux = textureLoad(auxTexture, texel, 0);
+  }
+
+  let d = field.x;
+  let normal = field.yz;
+  let coverage = field.w;
+  if (coverage <= 0.0) {
+    return vec4f(0.0);
+  }
+
+  let viewport01 = in.position.xy / ou.screen.xy;
+  let viewportCss = ou.screen.xy * ou.screen.z;
+
+  // Per-pixel, unioned through the field pass. See the module note.
+  let lensDepth = max(aux.x, 1e-4);
+  // '-d' is depth inside the surface, so the profile runs 1 at the contour to 0
+  // at 'lensDepth' inward, and the square makes the falloff read as curvature
+  // rather than as a linear ramp.
+  let depth = clamp(-d / lensDepth, 0.0, 1.0);
+  let profile = (1.0 - depth) * (1.0 - depth);
+
+  let displaceCss = -normal * lensDepth * profile * ou.lens.x;
+  let refracted01 = viewport01 + displaceCss / viewportCss;
+
+  let straightUv = clamp(viewport01 * ou.fit.xy + ou.fit.zw, vec2f(0.0), vec2f(1.0));
+  let refractedUv = clamp(refracted01 * ou.fit.xy + ou.fit.zw, vec2f(0.0), vec2f(1.0));
+
+  let bodyLod = clamp(lensDepth * ou.lens.y, 0.0, ou.lens.w);
+  let lod = clamp(bodyLod - ou.lens.z * profile, 0.0, ou.lens.w);
+
+  var backdrop = vec3f(0.0);
+  if (ou.flags.x > 0.5) {
+    let lensSample = textureSampleLevel(backdropChain, backdropSampler, refractedUv, lod);
+    let bodySample = textureSampleLevel(backdropBody, backdropSampler, straightUv, 0.0);
+    // Premultiplied linear in, straight colour out: the material composites over
+    // whatever is behind it, so a partially transparent backdrop must not darken
+    // the glass.
+    let lensColour = lensSample.rgb / max(lensSample.a, 1e-6);
+    let bodyColour = bodySample.rgb / max(bodySample.a, 1e-6);
+    backdrop = mix(bodyColour, lensColour, profile);
+  }
+
+  // Adaptive tint. 'adapt.w' is the strength the accessibility policy and the
+  // group's analysis quality already agreed on; at 0 the fixed tint stands, which
+  // is what a 'hint' or 'none' group gets.
+  let tintColour = mix(ou.tint.rgb, ou.adapt.rgb, ou.adapt.w);
+  var colour = mix(backdrop, tintColour, ou.tint.w);
+
+  // Inner shadow: the material's own occlusion, deepest where the lens is
+  // strongest, which is what makes a thicker surface read as heavier.
+  colour = colour * (1.0 - profile * ou.light.z * ou.light.w);
+
+  // Rim and specular from the gradient. The rim is unlit ambient edge brightness;
+  // the specular term is the same edge lit from 'light.xy'.
+  let rw = rim_weight(d, ou.rim.x);
+  let facing = dot(normal, ou.light.xy);
+  let spec = pow(clamp(facing, 0.0, 1.0), max(ou.rim.z, 1e-3)) * ou.rim.w;
+  colour = colour + vec3f(rw * (ou.rim.y + spec));
+
+  return encode_output(max(colour, vec3f(0.0)), coverage);
+}`;
+
+// ../renderer-webgpu/dist/wgsl/prelude.js
+var WGSL_PRELUDE = `// vitrea:wgsl-marker
+// ---------------------------------------------------------------------------
+// X5 colour pipeline. Piecewise sRGB, matching color.ts channel for channel:
+// a golden regenerated against one and asserted against the other must not
+// drift by a code unit, so the 2.2-gamma approximation is not used anywhere.
+// ---------------------------------------------------------------------------
+
+fn srgb_to_linear(c : vec3f) -> vec3f {
+  let lo = c / 12.92;
+  let hi = pow((c + vec3f(0.055)) / 1.055, vec3f(2.4));
+  return select(hi, lo, c <= vec3f(0.04045));
+}
+
+fn linear_to_srgb(c : vec3f) -> vec3f {
+  let lo = c * 12.92;
+  let hi = 1.055 * pow(max(c, vec3f(0.0)), vec3f(1.0 / 2.4)) - vec3f(0.055);
+  return select(hi, lo, c <= vec3f(0.0031308));
+}
+
+/// Rec.709 weights on LINEAR light. Weighting encoded values would make the
+/// analysis pass measure something that is not energy.
+fn luminance(linear : vec3f) -> f32 {
+  return dot(linear, vec3f(0.2126, 0.7152, 0.0722));
+}
+
+/// The one output encoding: encode, then premultiply in the ENCODED space,
+/// because that is the space the browser composites a canvas in. Premultiplying
+/// in linear and encoding afterwards darkens every partially covered pixel.
+fn encode_output(linear : vec3f, alpha : f32) -> vec4f {
+  let a = clamp(alpha, 0.0, 1.0);
+  return vec4f(linear_to_srgb(linear) * a, a);
+}
+
+// ---------------------------------------------------------------------------
+// Fullscreen triangle. Three vertices, no vertex buffer, no index buffer: the
+// oversized triangle is clipped to the target and costs one fewer primitive
+// than a quad, and every pass here writes exactly one screen-space region.
+// ---------------------------------------------------------------------------
+
+struct FullscreenOut {
+  @builtin(position) position : vec4f,
+  @location(0)       uv       : vec2f,
+};
+
+@vertex
+fn vs_fullscreen(@builtin(vertex_index) index : u32) -> FullscreenOut {
+  // (-1,-1) (3,-1) (-1,3) in clip space; uv follows with y flipped so (0,0) is
+  // the target's top-left, matching texture and viewport conventions.
+  let x = f32((index << 1u) & 2u) * 2.0 - 1.0;
+  let y = f32(index & 2u) * 2.0 - 1.0;
+  var out : FullscreenOut;
+  out.position = vec4f(x, y, 0.0, 1.0);
+  out.uv = vec2f((x + 1.0) * 0.5, (1.0 - y) * 0.5);
+  return out;
+}
+`;
+
+// ../renderer-webgpu/dist/wgsl/index.js
+var withPrelude = (pass) => `${WGSL_PRELUDE}
+${pass}
+`;
+var fieldModule = (family) => withPrelude(fieldPassSource(family));
+var importModule = (kind) => withPrelude(importPassSource(kind));
+var chainModule = () => withPrelude(WGSL_DOWNSAMPLE_PASS);
+var analysisModule = () => withPrelude(WGSL_ANALYSIS_PASS);
+var opticsModule = () => withPrelude(WGSL_OPTICS_PASS);
+var highlightModule = () => withPrelude(WGSL_HIGHLIGHT_PASS);
+var crossCheckKernelModule = () => withPrelude([WGSL_FIELD_KERNELS, WGSL_CROSS_CHECK_PASS].join("\n\n"));
+function allShaderSource() {
+  return [
+    WGSL_PRELUDE,
+    fieldPassSource("rsupn"),
+    fieldPassSource("rsup"),
+    importPassSource("sampled"),
+    importPassSource("external"),
+    WGSL_DOWNSAMPLE_PASS,
+    WGSL_ANALYSIS_PASS,
+    WGSL_OPTICS_PASS,
+    WGSL_HIGHLIGHT_PASS
+  ].join("\n\n");
+}
+
+// ../renderer-webgpu/dist/passes.js
+var fieldUsage = () => GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING;
+var PREMULTIPLIED_OVER = {
+  color: { srcFactor: "one", dstFactor: "one-minus-src-alpha", operation: "add" },
+  alpha: { srcFactor: "one", dstFactor: "one-minus-src-alpha", operation: "add" }
+};
+function createPassRunner(context) {
+  const { device, pool, cache } = context;
+  const uniforms = /* @__PURE__ */ new Map();
+  const storages = /* @__PURE__ */ new Map();
+  const EMPTY_DISTANCE = 65e3;
+  const placeholder = device.createTexture({
+    label: "vitrea:placeholder",
+    size: { width: 1, height: 1, depthOrArrayLayers: 1 },
+    format: WORKING_TEXTURE_FORMAT,
+    usage: fieldUsage()
+  });
+  const uniformSlot = (key, floats) => {
+    let slot = uniforms.get(key);
+    if (slot === void 0) {
+      slot = createUniformSlot(device, floats, `vitrea:uniform:${key}`);
+      uniforms.set(key, slot);
+    }
+    return slot;
+  };
+  const storageSlot = (key) => {
+    let slot = storages.get(key);
+    if (slot === void 0) {
+      slot = createStorageSlot(device, 8 * INSTANCE_BYTES, `vitrea:instances:${key}`);
+      storages.set(key, slot);
+    }
+    return slot;
+  };
+  const fieldPipeline = (family) => cache.renderPipeline(pipelineKey.field(family, WORKING_TEXTURE_FORMAT), () => {
+    const module = cache.module(`module:field:${family}`, () => fieldModule(family));
+    return {
+      label: `vitrea:pipeline:field:${family}`,
+      layout: "auto",
+      vertex: { module, entryPoint: "vs_fullscreen" },
+      fragment: {
+        module,
+        entryPoint: "fs_field",
+        targets: [{ format: WORKING_TEXTURE_FORMAT }, { format: WORKING_TEXTURE_FORMAT }]
+      },
+      primitive: { topology: "triangle-list" }
+    };
+  });
+  const opticsPipeline = (format) => cache.renderPipeline(pipelineKey.optics(format, "premultiplied-over"), () => {
+    const module = cache.module("module:optics", opticsModule);
+    return {
+      label: "vitrea:pipeline:optics",
+      layout: "auto",
+      vertex: { module, entryPoint: "vs_fullscreen" },
+      fragment: {
+        module,
+        entryPoint: "fs_optics",
+        targets: [{ format, blend: PREMULTIPLIED_OVER }]
+      },
+      primitive: { topology: "triangle-list" }
+    };
+  });
+  const highlightPipeline = (format) => cache.renderPipeline(pipelineKey.highlight(format, "premultiplied-over"), () => {
+    const module = cache.module("module:highlight", highlightModule);
+    return {
+      label: "vitrea:pipeline:highlight",
+      layout: "auto",
+      vertex: { module, entryPoint: "vs_fullscreen" },
+      fragment: {
+        module,
+        entryPoint: "fs_highlight",
+        targets: [{ format, blend: PREMULTIPLIED_OVER }]
+      },
+      primitive: { topology: "triangle-list" }
+    };
+  });
+  const scoped = (pass, rect) => {
+    pass.setViewport(rect.x, rect.y, rect.width, rect.height, 0, 1);
+    pass.setScissorRect(rect.x, rect.y, rect.width, rect.height);
+  };
+  const placeholderView = placeholder.createView();
+  let timeline;
+  const timed = (label) => {
+    const slot = timeline?.renderSlot(label);
+    return slot === void 0 ? {} : { timestampWrites: slot };
+  };
+  return {
+    placeholderView,
+    fieldPass(encoder, args) {
+      const rectWidth = Math.max(1, Math.round(args.rectDevice.width));
+      const rectHeight = Math.max(1, Math.round(args.rectDevice.height));
+      const width = Math.max(1, Math.round(args.rectDevice.width * args.renderScale));
+      const height = Math.max(1, Math.round(args.rectDevice.height * args.renderScale));
+      const field = pool.acquire(poolKey.groupField(args.groupId), {
+        width,
+        height,
+        format: WORKING_TEXTURE_FORMAT,
+        usage: fieldUsage(),
+        label: `vitrea:group:${args.groupId}:field`
+      });
+      const aux = pool.acquire(poolKey.groupAux(args.groupId), {
+        width,
+        height,
+        format: WORKING_TEXTURE_FORMAT,
+        usage: fieldUsage(),
+        label: `vitrea:group:${args.groupId}:aux`
+      });
+      const slot = uniformSlot(`field:${args.groupId}`, 12);
+      slot.data[0] = rectWidth;
+      slot.data[1] = rectHeight;
+      slot.data[2] = args.cssPerDevice;
+      slot.data[3] = args.coverageRampCss * (rectWidth / width);
+      slot.data[4] = args.union.neckWidth;
+      slot.data[5] = args.union.maxBulge;
+      slot.data[6] = args.union.separationThreshold;
+      slot.data[7] = 0;
+      slot.data[9] = 0;
+      slot.data[10] = 0;
+      slot.data[11] = 0;
+      new Uint32Array(slot.data.buffer, slot.data.byteOffset + 32, 1)[0] = args.instanceCount;
+      slot.write();
+      const instances = storageSlot(args.groupId);
+      instances.ensure(Math.max(args.instanceCount, 1) * INSTANCE_BYTES);
+      instances.write(args.instances, Math.max(args.instanceCount, 1) * (INSTANCE_BYTES / 4));
+      const pipeline = fieldPipeline(args.family);
+      const pass = encoder.beginRenderPass({
+        label: `vitrea:pass:field:${args.groupId}`,
+        ...timed(PASS_LABEL.field),
+        colorAttachments: [
+          {
+            view: field.createView(),
+            loadOp: "clear",
+            storeOp: "store",
+            clearValue: { r: EMPTY_DISTANCE, g: 0, b: -1, a: 0 }
+          },
+          {
+            view: aux.createView(),
+            loadOp: "clear",
+            storeOp: "store",
+            clearValue: { r: 0, g: 0, b: 0, a: 0 }
+          }
+        ]
+      });
+      pass.setPipeline(pipeline);
+      pass.setBindGroup(0, device.createBindGroup({
+        layout: pipeline.getBindGroupLayout(0),
+        entries: [
+          { binding: 0, resource: { buffer: slot.buffer } },
+          { binding: 1, resource: { buffer: instances.buffer } }
+        ]
+      }));
+      pass.draw(3);
+      pass.end();
+      return {
+        field,
+        aux,
+        width,
+        height,
+        upsampled: width !== rectWidth || height !== rectHeight
+      };
+    },
+    opticsPass(encoder, args) {
+      const slot = uniformSlot(`optics:${args.groupId}`, 32);
+      const d = slot.data;
+      d[0] = args.viewportDevice[0];
+      d[1] = args.viewportDevice[1];
+      d[2] = args.cssPerDevice;
+      d[3] = args.coverageRampCss;
+      d[4] = args.fit[0];
+      d[5] = args.fit[1];
+      d[6] = args.fit[2];
+      d[7] = args.fit[3];
+      d[8] = args.refractionScale;
+      d[9] = args.bodyLodPerPx;
+      d[10] = args.rimLodBias;
+      d[11] = args.chainMaxLod;
+      d[12] = args.tint[0];
+      d[13] = args.tint[1];
+      d[14] = args.tint[2];
+      d[15] = args.tintAlpha;
+      d[16] = args.adaptTint[0];
+      d[17] = args.adaptTint[1];
+      d[18] = args.adaptTint[2];
+      d[19] = args.adaptStrength;
+      d[20] = args.rimWidth;
+      d[21] = args.rimAlpha;
+      d[22] = args.specularPower;
+      d[23] = args.specularGain;
+      d[24] = args.lightDirection[0];
+      d[25] = args.lightDirection[1];
+      d[26] = args.shadowDepth;
+      d[27] = args.shadowAlpha;
+      d[28] = args.backdrop === void 0 ? 0 : 1;
+      d[29] = args.fields.width;
+      d[30] = args.fields.height;
+      d[31] = args.fields.upsampled ? 1 : 0;
+      slot.write();
+      const chain = args.backdrop?.chain ?? placeholderView;
+      const body = args.backdrop?.body ?? placeholderView;
+      const pipeline = opticsPipeline(args.targetFormat);
+      const pass = encoder.beginRenderPass({
+        label: `vitrea:pass:optics:${args.groupId}`,
+        ...timed(PASS_LABEL.optics),
+        colorAttachments: [{ view: args.target, loadOp: "load", storeOp: "store" }]
+      });
+      pass.setPipeline(pipeline);
+      scoped(pass, args.rectDevice);
+      pass.setBindGroup(0, device.createBindGroup({
+        layout: pipeline.getBindGroupLayout(0),
+        entries: [
+          { binding: 0, resource: { buffer: slot.buffer } },
+          { binding: 1, resource: args.fields.field.createView() },
+          { binding: 2, resource: args.fields.aux.createView() },
+          { binding: 3, resource: context.chainSampler },
+          { binding: 4, resource: chain },
+          { binding: 5, resource: body },
+          // Linear, no mips: the field targets have one level, and this is only
+          // read at all when the governor shrank them below the group's rect.
+          { binding: 6, resource: context.flatSampler }
+        ]
+      }));
+      pass.draw(3);
+      pass.end();
+    },
+    highlightPass(encoder, args) {
+      const slot = uniformSlot(`highlight:${args.groupId}`, 20);
+      const d = slot.data;
+      d[0] = args.viewportDevice[0];
+      d[1] = args.viewportDevice[1];
+      d[2] = args.cssPerDevice;
+      d[3] = 0;
+      d[4] = args.sweep;
+      d[5] = args.sweepBandRadians;
+      d[6] = args.sweepGain;
+      d[7] = args.rimWidth;
+      d[8] = args.pressPointCss[0];
+      d[9] = args.pressPointCss[1];
+      d[10] = args.glowRadiusCss;
+      d[11] = args.glowGain;
+      d[12] = args.colour[0];
+      d[13] = args.colour[1];
+      d[14] = args.colour[2];
+      d[15] = 0;
+      d[16] = args.fields.width;
+      d[17] = args.fields.height;
+      d[18] = args.fields.upsampled ? 1 : 0;
+      d[19] = 0;
+      slot.write();
+      const pipeline = highlightPipeline(args.targetFormat);
+      const pass = encoder.beginRenderPass({
+        label: `vitrea:pass:highlight:${args.groupId}`,
+        ...timed(PASS_LABEL.highlight),
+        colorAttachments: [{ view: args.target, loadOp: "load", storeOp: "store" }]
+      });
+      pass.setPipeline(pipeline);
+      scoped(pass, args.rectDevice);
+      pass.setBindGroup(0, device.createBindGroup({
+        layout: pipeline.getBindGroupLayout(0),
+        entries: [
+          { binding: 0, resource: { buffer: slot.buffer } },
+          { binding: 1, resource: args.fields.field.createView() },
+          { binding: 2, resource: args.fields.aux.createView() },
+          { binding: 3, resource: context.flatSampler }
+        ]
+      }));
+      pass.draw(3);
+      pass.end();
+    },
+    clearPass(encoder, target) {
+      const pass = encoder.beginRenderPass({
+        label: "vitrea:pass:clear",
+        colorAttachments: [
+          {
+            view: target,
+            loadOp: "clear",
+            storeOp: "store",
+            clearValue: { r: 0, g: 0, b: 0, a: 0 }
+          }
+        ]
+      });
+      pass.end();
+    },
+    setTimeline(next) {
+      timeline = next;
+    },
+    forget(groupId) {
+      pool.release(poolKey.groupField(groupId));
+      pool.release(poolKey.groupAux(groupId));
+      storages.get(groupId)?.destroy();
+      storages.delete(groupId);
+      for (const key of [`field:${groupId}`, `optics:${groupId}`, `highlight:${groupId}`]) {
+        uniforms.get(key)?.buffer.destroy();
+        uniforms.delete(key);
+      }
+    },
+    destroy() {
+      for (const slot of uniforms.values())
+        slot.buffer.destroy();
+      uniforms.clear();
+      for (const slot of storages.values())
+        slot.destroy();
+      storages.clear();
+      placeholder.destroy();
+    }
+  };
+}
+var CANVAS_FORMAT = OUTPUT_TEXTURE_FORMAT;
+
+// ../renderer-webgpu/dist/pyramid-plan.js
+var MIN_LEVEL_EXTENT = 8;
+var MAX_CHAIN_LEVELS = 12;
+var ANALYSIS_TARGET_EXTENT = 96;
+function planPyramid(sourceWidth, sourceHeight, policy) {
+  const scale = Math.max(policy.scale, 1e-3);
+  let width = Math.max(1, Math.round(sourceWidth * scale));
+  let height = Math.max(1, Math.round(sourceHeight * scale));
+  const cap = Math.max(MIN_LEVEL_EXTENT, Math.floor(policy.maxDimension));
+  const longest = Math.max(width, height);
+  if (longest > cap) {
+    const shrink = cap / longest;
+    width = Math.max(1, Math.round(width * shrink));
+    height = Math.max(1, Math.round(height * shrink));
+  }
+  const levels = [{ width, height }];
+  while (levels.length < MAX_CHAIN_LEVELS) {
+    const previous = levels[levels.length - 1];
+    const next = {
+      width: Math.max(1, previous.width >> 1),
+      height: Math.max(1, previous.height >> 1)
+    };
+    if (Math.min(next.width, next.height) < MIN_LEVEL_EXTENT)
+      break;
+    if (next.width === previous.width && next.height === previous.height)
+      break;
+    levels.push(next);
+  }
+  let analysisLevel = 0;
+  let bestDistance = Number.POSITIVE_INFINITY;
+  for (let i = 0; i < levels.length; i += 1) {
+    const level = levels[i];
+    const shorter = Math.min(level.width, level.height);
+    const distance = Math.abs(Math.log2(shorter / ANALYSIS_TARGET_EXTENT));
+    if (distance < bestDistance) {
+      bestDistance = distance;
+      analysisLevel = i;
+    }
+  }
+  return {
+    width,
+    height,
+    levelCount: levels.length,
+    maxLod: levels.length - 1,
+    analysisLevel,
+    levels
+  };
+}
+var CHAIN_SIGMA_AT_LEVEL_1 = 1.2;
+function bodyBlurPlan(sigmaPx, plan) {
+  if (sigmaPx <= 0)
+    return { level: 0, residualSigmaTexels: 0 };
+  const sigmaAt = (level2) => level2 === 0 ? 0 : CHAIN_SIGMA_AT_LEVEL_1 * Math.pow(2, level2 - 1);
+  let level = 0;
+  for (let i = 1; i < plan.levelCount; i += 1) {
+    if (sigmaAt(i) > sigmaPx)
+      break;
+    level = i;
+  }
+  const covered = sigmaAt(level);
+  const residualLevel0 = Math.sqrt(Math.max(sigmaPx * sigmaPx - covered * covered, 0));
+  return { level, residualSigmaTexels: residualLevel0 / Math.pow(2, level) };
+}
+
+// ../renderer-webgpu/dist/rebuild-ledger.js
+function createRebuildLedger() {
+  const perFrame = /* @__PURE__ */ new Map();
+  let frameId;
+  let rebuilds = 0;
+  let refused = 0;
+  let clean = 0;
+  let peak = 0;
+  return {
+    beginFrame(next) {
+      if (frameId === next)
+        return;
+      frameId = next;
+      perFrame.clear();
+    },
+    get frameId() {
+      return frameId;
+    },
+    claim(sourceId) {
+      const already = perFrame.get(sourceId) ?? 0;
+      if (already > 0) {
+        refused += 1;
+        return false;
+      }
+      const count = already + 1;
+      perFrame.set(sourceId, count);
+      peak = Math.max(peak, count);
+      rebuilds += 1;
+      return true;
+    },
+    recordClean() {
+      clean += 1;
+    },
+    countInFrame(sourceId) {
+      return perFrame.get(sourceId) ?? 0;
+    },
+    get rebuilds() {
+      return rebuilds;
+    },
+    get refusedDuplicates() {
+      return refused;
+    },
+    get skippedClean() {
+      return clean;
+    },
+    get peakPerSourcePerFrame() {
+      return peak;
+    }
+  };
+}
+
+// ../renderer-webgpu/dist/pyramid.js
+var chainUsage = () => GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING;
+function createPyramidStore(context) {
+  const { device, pool, cache } = context;
+  const resources = /* @__PURE__ */ new Map();
+  const uniforms = /* @__PURE__ */ new Map();
+  const readbacks = /* @__PURE__ */ new Map();
+  const pendingRelease = [];
+  const pendingStats = /* @__PURE__ */ new Map();
+  const pendingMaps = [];
+  let timeline;
+  const timedRender = (label) => {
+    const slot = timeline?.renderSlot(label);
+    return slot === void 0 ? {} : { timestampWrites: slot };
+  };
+  const timedCompute = (label) => {
+    const slot = timeline?.computeSlot(label);
+    return slot === void 0 ? {} : { timestampWrites: slot };
+  };
+  let frameId = -1;
+  let reallocations = 0;
+  const ledger = createRebuildLedger();
+  const uniformSlot = (key, floats) => {
+    let slot = uniforms.get(key);
+    if (slot === void 0) {
+      slot = createUniformSlot(device, floats, `vitrea:uniform:${key}`);
+      uniforms.set(key, slot);
+    }
+    return slot;
+  };
+  const importPipeline = (kind) => cache.renderPipeline(pipelineKey.import(kind, WORKING_TEXTURE_FORMAT), () => ({
+    label: `vitrea:pipeline:import:${kind}`,
+    layout: "auto",
+    vertex: {
+      module: cache.module(`module:import:${kind}`, () => importModule(kind)),
+      entryPoint: "vs_fullscreen"
+    },
+    fragment: {
+      module: cache.module(`module:import:${kind}`, () => importModule(kind)),
+      entryPoint: "fs_import",
+      targets: [{ format: WORKING_TEXTURE_FORMAT }]
+    },
+    primitive: { topology: "triangle-list" }
+  }));
+  const chainPipeline = (entry) => cache.renderPipeline(pipelineKey.chain(entry, WORKING_TEXTURE_FORMAT), () => ({
+    label: `vitrea:pipeline:chain:${entry}`,
+    layout: "auto",
+    vertex: {
+      module: cache.module("module:chain", chainModule),
+      entryPoint: "vs_fullscreen"
+    },
+    fragment: {
+      module: cache.module("module:chain", chainModule),
+      entryPoint: entry,
+      targets: [{ format: WORKING_TEXTURE_FORMAT }]
+    },
+    primitive: { topology: "triangle-list" }
+  }));
+  const analysisPipeline = () => cache.computePipeline(pipelineKey.analysis(), () => ({
+    label: "vitrea:pipeline:analysis",
+    layout: "auto",
+    compute: {
+      module: cache.module("module:analysis", analysisModule),
+      entryPoint: "cs_analysis"
+    }
+  }));
+  const liveResources = (sourceId) => {
+    const target = resources.get(sourceId);
+    if (target === void 0)
+      return void 0;
+    if (pool.peek(poolKey.backdropChain(sourceId)) !== target.chain)
+      return void 0;
+    if (pool.peek(poolKey.backdropBody(sourceId)) !== target.body)
+      return void 0;
+    return target;
+  };
+  const mipView = (texture, level) => texture.createView({ baseMipLevel: level, mipLevelCount: 1, dimension: "2d" });
+  function allocate(sourceId, plan, bodyLevel, sizeEpoch, builtEpoch) {
+    const existing = resources.get(sourceId);
+    const bodyWidth = (plan.levels[bodyLevel] ?? plan.levels[0]).width;
+    const bodyHeight = (plan.levels[bodyLevel] ?? plan.levels[0]).height;
+    const chain = pool.acquire(poolKey.backdropChain(sourceId), {
+      width: plan.width,
+      height: plan.height,
+      format: WORKING_TEXTURE_FORMAT,
+      usage: chainUsage(),
+      mipLevelCount: plan.levelCount,
+      label: `vitrea:pyramid:${sourceId}:chain`
+    });
+    const body = pool.acquire(poolKey.backdropBody(sourceId), {
+      width: bodyWidth,
+      height: bodyHeight,
+      format: WORKING_TEXTURE_FORMAT,
+      usage: chainUsage(),
+      label: `vitrea:pyramid:${sourceId}:body`
+    });
+    let stats = existing?.stats;
+    if (stats === void 0) {
+      stats = device.createBuffer({
+        label: `vitrea:pyramid:${sourceId}:stats`,
+        size: ANALYSIS_STATS_FLOATS * 4,
+        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC
+      });
+    }
+    if (existing === void 0 || existing.chain !== chain || existing.body !== body) {
+      reallocations += 1;
+    }
+    const next = {
+      sourceId,
+      plan,
+      chain,
+      body,
+      stats,
+      sizeEpoch,
+      builtEpoch
+    };
+    resources.set(sourceId, next);
+    return next;
+  }
+  function runImport(encoder, sourceId, frame, chain) {
+    const kind = frame.binding.kind;
+    const pipeline = importPipeline(kind);
+    const slot = uniformSlot(`import:${sourceId}`, 16);
+    const matrix = importColorMatrix(frame.colorSpace);
+    slot.data[0] = matrix[0];
+    slot.data[1] = matrix[1];
+    slot.data[2] = matrix[2];
+    slot.data[3] = frame.encoded ? 1 : 0;
+    slot.data[4] = matrix[3];
+    slot.data[5] = matrix[4];
+    slot.data[6] = matrix[5];
+    slot.data[7] = alphaNormalisationMode(frame.alphaMode);
+    slot.data[8] = matrix[6];
+    slot.data[9] = matrix[7];
+    slot.data[10] = matrix[8];
+    slot.data[11] = 0;
+    slot.data[12] = 1;
+    slot.data[13] = 1;
+    slot.data[14] = 0;
+    slot.data[15] = 0;
+    slot.write();
+    const entries = [
+      { binding: 0, resource: { buffer: slot.buffer } },
+      { binding: 1, resource: context.flatSampler },
+      {
+        binding: 2,
+        resource: frame.binding.kind === "external" ? frame.binding.texture : frame.binding.view
+      }
+    ];
+    const pass = encoder.beginRenderPass({
+      label: `vitrea:pass:import:${sourceId}`,
+      ...timedRender(PASS_LABEL.import),
+      colorAttachments: [
+        { view: mipView(chain, 0), loadOp: "clear", storeOp: "store", clearValue: { r: 0, g: 0, b: 0, a: 0 } }
+      ]
+    });
+    pass.setPipeline(pipeline);
+    pass.setBindGroup(0, device.createBindGroup({ layout: pipeline.getBindGroupLayout(0), entries }));
+    pass.draw(3);
+    pass.end();
+  }
+  function runChain(encoder, sourceId, plan, chain) {
+    const pipeline = chainPipeline("fs_downsample");
+    for (let level = 1; level < plan.levelCount; level += 1) {
+      const source = plan.levels[level - 1];
+      const slot = uniformSlot(`chain:${sourceId}:${level}`, 8);
+      slot.data[0] = 1 / source.width;
+      slot.data[1] = 1 / source.height;
+      slot.data[2] = 0;
+      slot.data[3] = 0;
+      slot.data[4] = 0;
+      slot.data[5] = 0;
+      slot.data[6] = 0;
+      slot.data[7] = 0;
+      slot.write();
+      const pass = encoder.beginRenderPass({
+        label: `vitrea:pass:downsample:${sourceId}:${level}`,
+        ...timedRender(PASS_LABEL.chain),
+        colorAttachments: [
+          { view: mipView(chain, level), loadOp: "clear", storeOp: "store", clearValue: { r: 0, g: 0, b: 0, a: 0 } }
+        ]
+      });
+      pass.setPipeline(pipeline);
+      pass.setBindGroup(0, device.createBindGroup({
+        layout: pipeline.getBindGroupLayout(0),
+        entries: [
+          { binding: 0, resource: { buffer: slot.buffer } },
+          { binding: 1, resource: context.flatSampler },
+          { binding: 2, resource: mipView(chain, level - 1) }
+        ]
+      }));
+      pass.draw(3);
+      pass.end();
+    }
+  }
+  function runBodyBlur(encoder, sourceId, plan, chain, body, level, residualSigmaTexels) {
+    const pipeline = chainPipeline("fs_blur");
+    const size = plan.levels[level] ?? plan.levels[0];
+    const scratch = pool.acquire(poolKey.backdropBodyScratch(sourceId), {
+      width: size.width,
+      height: size.height,
+      format: WORKING_TEXTURE_FORMAT,
+      usage: chainUsage(),
+      label: `vitrea:pyramid:${sourceId}:body-scratch`
+    });
+    const stages = [
+      { target: scratch, source: mipView(chain, level), dir: [1, 0], tag: "h" },
+      { target: body, source: scratch.createView(), dir: [0, 1], tag: "v" }
+    ];
+    for (const stage of stages) {
+      const slot = uniformSlot(`body:${sourceId}:${stage.tag}`, 8);
+      slot.data[0] = 1 / size.width;
+      slot.data[1] = 1 / size.height;
+      slot.data[2] = 0;
+      slot.data[3] = 0;
+      slot.data[4] = residualSigmaTexels;
+      slot.data[5] = stage.dir[0];
+      slot.data[6] = stage.dir[1];
+      slot.data[7] = 0;
+      slot.write();
+      const pass = encoder.beginRenderPass({
+        label: `vitrea:pass:body-blur-${stage.tag}:${sourceId}`,
+        ...timedRender(PASS_LABEL.bodyBlur),
+        colorAttachments: [
+          { view: stage.target.createView(), loadOp: "clear", storeOp: "store", clearValue: { r: 0, g: 0, b: 0, a: 0 } }
+        ]
+      });
+      pass.setPipeline(pipeline);
+      pass.setBindGroup(0, device.createBindGroup({
+        layout: pipeline.getBindGroupLayout(0),
+        entries: [
+          { binding: 0, resource: { buffer: slot.buffer } },
+          { binding: 1, resource: context.flatSampler },
+          { binding: 2, resource: stage.source }
+        ]
+      }));
+      pass.draw(3);
+      pass.end();
+    }
+  }
+  function runAnalysis(encoder, sourceId, plan, chain, stats) {
+    const pipeline = analysisPipeline();
+    const level = plan.levels[plan.analysisLevel] ?? plan.levels[0];
+    const slot = uniformSlot(`analysis:${sourceId}`, 8);
+    slot.data[0] = ANALYSIS_GRID;
+    slot.data[1] = ANALYSIS_GRID;
+    slot.data[2] = plan.analysisLevel;
+    slot.data[3] = 1 / (ANALYSIS_GRID - 1);
+    slot.data[4] = 1 / level.width;
+    slot.data[5] = 1 / level.height;
+    slot.data[6] = 0;
+    slot.data[7] = 0;
+    slot.write();
+    const pass = encoder.beginComputePass({
+      label: `vitrea:pass:analysis:${sourceId}`,
+      ...timedCompute(PASS_LABEL.analysis)
+    });
+    pass.setPipeline(pipeline);
+    pass.setBindGroup(0, device.createBindGroup({
+      layout: pipeline.getBindGroupLayout(0),
+      entries: [
+        { binding: 0, resource: { buffer: slot.buffer } },
+        { binding: 1, resource: context.flatSampler },
+        { binding: 2, resource: chain.createView() },
+        { binding: 3, resource: { buffer: stats } }
+      ]
+    }));
+    pass.dispatchWorkgroups(1);
+    pass.end();
+  }
+  return {
+    instrumentation: {
+      get rebuilds() {
+        return ledger.rebuilds;
+      },
+      get refusedDuplicates() {
+        return ledger.refusedDuplicates;
+      },
+      get skippedClean() {
+        return ledger.skippedClean;
+      },
+      get reallocations() {
+        return reallocations;
+      },
+      rebuildsInFrame(sourceId) {
+        return ledger.countInFrame(sourceId);
+      },
+      get peakRebuildsPerSourcePerFrame() {
+        return ledger.peakPerSourcePerFrame;
+      }
+    },
+    /** The ledger the invariant is asserted against. See `rebuild-ledger.ts`. */
+    ledger,
+    beginFrame(next) {
+      frameId = next;
+      ledger.beginFrame(next);
+    },
+    setTimeline(next) {
+      timeline = next;
+    },
+    build(request, provider, encoder) {
+      const existing = liveResources(request.sourceId);
+      if (existing !== void 0 && existing.builtEpoch >= request.epoch && !provider.isDirty()) {
+        ledger.recordClean();
+        return { status: "clean", resources: existing };
+      }
+      if (!ledger.claim(request.sourceId)) {
+        return { status: "duplicate" };
+      }
+      let frame;
+      try {
+        frame = provider.acquire({ id: frameId, timeMs: 0 });
+      } catch (error) {
+        return {
+          status: "unavailable",
+          reason: error instanceof Error ? error.message : String(error)
+        };
+      }
+      pendingRelease.push(provider);
+      const plan = planPyramid(frame.width, frame.height, request.resolution);
+      const [viewportW, viewportH] = request.viewportCss;
+      const cover = viewportW > 0 && viewportH > 0 ? Math.max(frame.width / viewportW, frame.height / viewportH) : 1;
+      const planScale = frame.width > 0 ? plan.width / frame.width : 1;
+      const bodyPlan = bodyBlurPlan(request.bodySigmaCss * cover * planScale, plan);
+      const target = allocate(request.sourceId, plan, bodyPlan.level, frame.sizeEpoch, request.epoch);
+      runImport(encoder, request.sourceId, frame, target.chain);
+      runChain(encoder, request.sourceId, plan, target.chain);
+      runBodyBlur(encoder, request.sourceId, plan, target.chain, target.body, bodyPlan.level, bodyPlan.residualSigmaTexels);
+      runAnalysis(encoder, request.sourceId, plan, target.chain, target.stats);
+      provider.markImported();
+      return { status: "built", resources: target };
+    },
+    releaseAcquired() {
+      while (pendingRelease.length > 0) {
+        const provider = pendingRelease.shift();
+        try {
+          provider?.release();
+        } catch {
+        }
+      }
+    },
+    afterSubmit() {
+      while (pendingMaps.length > 0) {
+        const sourceId = pendingMaps.shift();
+        if (sourceId === void 0)
+          continue;
+        const slot = readbacks.get(sourceId);
+        if (slot === void 0)
+          continue;
+        const staging = slot.staging;
+        pendingStats.set(sourceId, (async () => {
+          try {
+            await staging.mapAsync(GPUMapMode.READ);
+            const values = new Float32Array(staging.getMappedRange().slice(0));
+            staging.unmap();
+            return statsFromBuffer(values);
+          } catch {
+            return void 0;
+          } finally {
+            slot.inFlight = false;
+          }
+        })());
+      }
+    },
+    resources(sourceId) {
+      return liveResources(sourceId);
+    },
+    requestStats(sourceId, encoder) {
+      const target = liveResources(sourceId);
+      if (target === void 0)
+        return false;
+      let readback = readbacks.get(sourceId);
+      if (readback === void 0) {
+        readback = {
+          staging: device.createBuffer({
+            label: `vitrea:pyramid:${sourceId}:stats-staging`,
+            size: ANALYSIS_STATS_FLOATS * 4,
+            usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST
+          }),
+          inFlight: false
+        };
+        readbacks.set(sourceId, readback);
+      }
+      if (readback.inFlight)
+        return false;
+      encoder.copyBufferToBuffer(target.stats, 0, readback.staging, 0, ANALYSIS_STATS_FLOATS * 4);
+      readback.inFlight = true;
+      pendingMaps.push(sourceId);
+      return true;
+    },
+    async collectStats() {
+      const out = /* @__PURE__ */ new Map();
+      const entries = [...pendingStats];
+      pendingStats.clear();
+      for (const [sourceId, promise] of entries) {
+        const stats = await promise;
+        if (stats !== void 0)
+          out.set(sourceId, stats);
+      }
+      return out;
+    },
+    forget(sourceId) {
+      pool.release(poolKey.backdropChain(sourceId));
+      pool.release(poolKey.backdropBody(sourceId));
+      pool.release(poolKey.backdropBodyScratch(sourceId));
+      resources.get(sourceId)?.stats.destroy();
+      resources.delete(sourceId);
+      readbacks.get(sourceId)?.staging.destroy();
+      readbacks.delete(sourceId);
+      pendingStats.delete(sourceId);
+      const queued = pendingMaps.indexOf(sourceId);
+      if (queued >= 0)
+        pendingMaps.splice(queued, 1);
+    },
+    destroy() {
+      for (const sourceId of [...resources.keys()])
+        this.forget(sourceId);
+      for (const slot of uniforms.values())
+        slot.buffer.destroy();
+      uniforms.clear();
+      pendingRelease.length = 0;
+      pendingMaps.length = 0;
+    }
+  };
+}
+var ANALYSIS_DISPATCH = { workgroupSize: ANALYSIS_WORKGROUP, workgroups: 1 };
+
+// ../renderer-webgpu/dist/renderer.js
+var OPTICS_PASS_ID = "vitrea.optics";
+var HIGHLIGHT_PASS_ID = "vitrea.highlight";
+var FIELD_PASS_ID = "vitrea.field";
+var BACKDROP_PASS_ID = "vitrea.backdrop";
+var ANALYSIS_PASS_ID = "vitrea.analysis";
+var RENDERER_PASS_IDS = [
+  BACKDROP_PASS_ID,
+  ANALYSIS_PASS_ID,
+  FIELD_PASS_ID,
+  OPTICS_PASS_ID,
+  HIGHLIGHT_PASS_ID
+];
+var NOMINAL_MATERIAL_POLICY = {
+  glass: "material",
+  frost: "nominal",
+  refraction: "nominal",
+  occlusion: "nominal",
+  border: "nominal",
+  ambientTint: "nominal",
+  foreground: "adaptive"
+};
+function createWebGPURenderer(options = {}) {
+  const providers = /* @__PURE__ */ new Map();
+  const groups = /* @__PURE__ */ new Map();
+  const adaptation = /* @__PURE__ */ new Map();
+  const lastReadbackAt = /* @__PURE__ */ new Map();
+  let accessibility = NOMINAL_MATERIAL_POLICY;
+  let material = withMaterialOverrides(DEFAULT_MATERIAL_PROFILE, options.materialProfile ?? {});
+  let viewport = options.viewport ?? {
+    widthCss: 0,
+    heightCss: 0,
+    devicePixelRatio: 1
+  };
+  let context;
+  let builtGeneration;
+  let store;
+  let runner;
+  let framesDrawn = 0;
+  let generations = 0;
+  let lastFrameTimeMs;
+  let targets;
+  let pendingEncoder;
+  let pendingRebuilds = 0;
+  let pendingUnbuilt = [];
+  let unbuiltFrameId;
+  const recordUnbuilt = (frameId, ids) => {
+    if (unbuiltFrameId !== frameId) {
+      unbuiltFrameId = frameId;
+      pendingUnbuilt = [];
+    }
+    for (const id of ids)
+      if (!pendingUnbuilt.includes(id))
+        pendingUnbuilt.push(id);
+  };
+  const governor = createGovernor({
+    ...options.familyCVerified === void 0 ? {} : { familyCVerified: options.familyCVerified }
+  });
+  const dropContext = () => {
+    store?.destroy();
+    runner?.destroy();
+    context?.destroy();
+    store = void 0;
+    runner = void 0;
+    context = void 0;
+    pendingEncoder = void 0;
+  };
+  const host = createDeviceHost({
+    ...options.reacquire === void 0 ? {} : { reacquire: options.reacquire },
+    ...options.onReplacementNeeded === void 0 ? {} : { onReplacementNeeded: options.onReplacementNeeded },
+    onStatusChange: (status) => {
+      if (status.generation !== generations)
+        generations = status.generation;
+      options.onDeviceStatusChange?.(status);
+    }
+  });
+  host.addTeardownHook(() => {
+    dropContext();
+    adaptation.clear();
+    lastReadbackAt.clear();
+  });
+  const ensureContext = () => {
+    const device = host.requireDevice();
+    const generation = host.status.generation;
+    if (context === void 0 || context.generation !== generation) {
+      const superseded = builtGeneration;
+      dropContext();
+      context = createGpuContext(device, generation);
+      builtGeneration = generation;
+      store = createPyramidStore(context);
+      runner = createPassRunner(context);
+      if (superseded !== void 0 && superseded !== generation) {
+        for (const provider of providers.values()) {
+          if (provider.generation !== generation)
+            provider.invalidate(generation, device);
+        }
+      }
+    }
+    return {
+      context,
+      store,
+      runner
+    };
+  };
+  const adaptationFor = (sourceId) => {
+    let state = adaptation.get(sourceId);
+    if (state === void 0) {
+      state = createAdaptationState(void 0, material);
+      adaptation.set(sourceId, state);
+    }
+    return state;
+  };
+  const coverFit = (sourceWidth, sourceHeight) => {
+    const viewportAspect = viewport.heightCss > 0 ? viewport.widthCss / viewport.heightCss : 1;
+    const sourceAspect = sourceHeight > 0 ? sourceWidth / sourceHeight : 1;
+    if (sourceAspect > viewportAspect) {
+      const scaleX = viewportAspect / sourceAspect;
+      return [scaleX, 1, (1 - scaleX) / 2, 0];
+    }
+    const scaleY = sourceAspect / viewportAspect;
+    return [1, scaleY, 0, (1 - scaleY) / 2];
+  };
+  const unionOf = (input) => input.union ?? DEFAULT_GROUP_UNION;
+  const variantOf = (input) => input.variant ?? "regular";
+  const stateOf = (input, resolution) => {
+    const resolved = resolution?.groups.find((group) => group.groupId === input.groupId);
+    if (resolved === void 0) {
+      return { refraction: input.refraction, analysisExact: input.analysisExact };
+    }
+    return {
+      refraction: resolved.state.refraction,
+      analysisExact: resolved.state.analysis === "exact"
+    };
+  };
+  function rebuildRequests(explicit) {
+    if (explicit !== void 0)
+      return explicit;
+    const sampled = /* @__PURE__ */ new Set();
+    for (const entry of groups.values()) {
+      const id = entry.input.backdropSourceId;
+      if (id !== void 0)
+        sampled.add(id);
+    }
+    const requests = [];
+    for (const sourceId of sampled) {
+      const provider = providers.get(sourceId);
+      if (provider === void 0 || !provider.isDirty())
+        continue;
+      requests.push({
+        sourceId,
+        // Standalone, every dirty acquire is its own epoch: there is no core
+        // keeping the books, so a monotonically rising number is the honest
+        // stand-in and it keeps `build`'s clean-skip from firing spuriously.
+        epoch: framesDrawn + 1,
+        resolution: { scale: 1, maxDimension: 2048 },
+        groupIds: [...groups.values()].filter((entry) => entry.input.backdropSourceId === sourceId).map((entry) => entry.input.groupId)
+      });
+    }
+    return requests;
+  }
+  function runRebuilds(encoder, requests, frameTimeMs) {
+    const { store: pyramids } = ensureContext();
+    let built = 0;
+    const unbuilt = [];
+    for (const request of requests) {
+      const provider = providers.get(request.sourceId);
+      if (provider === void 0) {
+        unbuilt.push(request.sourceId);
+        continue;
+      }
+      const variant = variantOf([...groups.values()].find((entry) => entry.input.backdropSourceId === request.sourceId)?.input ?? { });
+      const optics = opticsUnderPolicy(material.optics[variant], accessibility, material);
+      const outcome = pyramids.build({
+        sourceId: request.sourceId,
+        epoch: request.epoch,
+        resolution: request.resolution,
+        bodySigmaCss: optics.blurSigma,
+        viewportCss: [viewport.widthCss, viewport.heightCss]
+      }, provider, encoder);
+      if (outcome.status === "built")
+        built += 1;
+      else if (outcome.status === "unavailable")
+        unbuilt.push(request.sourceId);
+    }
+    const cadence = governor.knobs.adaptationCadenceHz;
+    for (const sourceId of providers.keys()) {
+      if (pyramids.resources(sourceId) === void 0)
+        continue;
+      if (!readbackDue(lastReadbackAt.get(sourceId), frameTimeMs, cadence))
+        continue;
+      if (pyramids.requestStats(sourceId, encoder))
+        lastReadbackAt.set(sourceId, frameTimeMs);
+    }
+    return { built, unbuilt };
+  }
+  function drawGroups(encoder, resolution) {
+    const { store: pyramids, runner: passes } = ensureContext();
+    const active = targets;
+    if (active === void 0) {
+      throw rendererError("pass-input", "No render targets are set. Call setTargets() (or pass views to drawFrame) before drawing.");
+    }
+    const dpr = Math.max(viewport.devicePixelRatio, 1e-3);
+    const cssPerDevice = 1 / dpr;
+    const viewportDevice = [
+      Math.max(1, Math.round(viewport.widthCss * dpr)),
+      Math.max(1, Math.round(viewport.heightCss * dpr))
+    ];
+    const skipped = [];
+    let drawn = 0;
+    for (const entry of groups.values()) {
+      const input = entry.input;
+      if (input.surfaces.length === 0)
+        continue;
+      let surfaces;
+      try {
+        surfaces = resolveSurfaces(input, governor.knobs.fieldFamily, material);
+      } catch (error) {
+        skipped.push({
+          groupId: input.groupId,
+          reason: error instanceof Error ? error.message : String(error)
+        });
+        continue;
+      }
+      const union = unionOf(input);
+      const snapped = snapRectToDevicePixels(groupFieldRect(surfaces, union), dpr);
+      const rectDevice = clipFieldRectToCanvas(snapped, dpr, viewportDevice);
+      if (rectDevice === void 0)
+        continue;
+      const packed = packInstances(surfaces, [
+        rectDevice.x * cssPerDevice,
+        rectDevice.y * cssPerDevice
+      ]);
+      const fields = passes.fieldPass(encoder, {
+        groupId: input.groupId,
+        family: governor.knobs.fieldFamily,
+        rectDevice,
+        cssPerDevice,
+        coverageRampCss: cssPerDevice,
+        // Ladder rungs 2 and 3 turn this down; rung 0 and 1 leave it at 1, which
+        // is the extent the group's rect already had.
+        renderScale: governor.knobs.refractionResolutionScale,
+        instances: packed.data,
+        instanceCount: packed.count,
+        union
+      });
+      const state = stateOf(input, resolution);
+      const policy = resolution?.accessibility.material ?? accessibility;
+      const variant = variantOf(input);
+      const optics = opticsUnderPolicy(material.optics[variant], policy, material);
+      const refraction = effectiveRefraction(accessibilityRefractionCap(policy), state.refraction);
+      const refractionScale = material.refractionScale[refraction];
+      const sourceId = input.backdropSourceId;
+      const pyramid = sourceId === void 0 ? void 0 : pyramids.resources(sourceId);
+      const adapt = sourceId === void 0 ? void 0 : adaptationFor(sourceId).values;
+      passes.opticsPass(encoder, {
+        groupId: input.groupId,
+        target: active.optics,
+        targetFormat: active.format,
+        rectDevice,
+        fields,
+        viewportDevice,
+        cssPerDevice,
+        coverageRampCss: cssPerDevice,
+        fit: pyramid === void 0 ? [1, 1, 0, 0] : coverFit(pyramid.plan.width, pyramid.plan.height),
+        refractionScale,
+        bodyLodPerPx: material.lensBodyLodPerPx,
+        rimLodBias: material.lensRimLodBias,
+        chainMaxLod: pyramid?.plan.maxLod ?? 0,
+        tint: optics.tint,
+        tintAlpha: optics.tintAlpha,
+        adaptTint: adapt?.tint ?? optics.tint,
+        adaptStrength: adapt?.observed === true ? adaptationStrength(policy, state.analysisExact, material) : 0,
+        rimWidth: optics.rimWidth,
+        rimAlpha: optics.rimAlpha,
+        specularPower: optics.specularPower,
+        specularGain: optics.specularGain,
+        lightDirection: material.lightDirection,
+        shadowDepth: optics.shadowDepth,
+        shadowAlpha: optics.shadowAlpha,
+        backdrop: pyramid === void 0 || policy.glass === "none" ? void 0 : {
+          chain: pyramid.chain.createView(),
+          body: pyramid.body.createView()
+        }
+      });
+      if (active.highlight !== void 0) {
+        const lead = surfaces.reduce((best, surface) => surface.channels.glow > best.channels.glow ? surface : best, surfaces[0]);
+        passes.highlightPass(encoder, {
+          groupId: input.groupId,
+          target: active.highlight,
+          targetFormat: active.format,
+          rectDevice,
+          fields,
+          viewportDevice,
+          cssPerDevice,
+          sweep: lead.channels.sweep,
+          sweepBandRadians: material.sweepBandRadians,
+          // Reduced Motion removes shimmer travel outright rather than freezing it.
+          sweepGain: policy.glass === "none" ? 0 : material.sweepGain,
+          rimWidth: optics.rimWidth,
+          pressPointCss: lead.channels.pressPoint ?? lead.centre,
+          glowRadiusCss: material.glowRadiusCss,
+          glowGain: material.glowGain,
+          colour: optics.highlight
+        });
+      }
+      drawn += 1;
+    }
+    return { groupsDrawn: drawn, rebuilds: pendingRebuilds, skipped, unbuilt: [...pendingUnbuilt] };
+  }
+  return {
+    backend: "webgpu",
+    get ready() {
+      return host.status.device !== void 0 && host.status.deviceHealth === "ok";
+    },
+    passes: RENDERER_PASS_IDS,
+    shaderSource: allShaderSource(),
+    get deviceStatus() {
+      return host.status;
+    },
+    get capabilityInput() {
+      return host.capabilityInput;
+    },
+    governor,
+    get unbuiltSources() {
+      return pendingUnbuilt;
+    },
+    get instrumentation() {
+      const pool = context?.pool.stats;
+      const cache = context?.cache.stats;
+      return {
+        pyramid: store?.instrumentation ?? {
+          rebuilds: 0,
+          refusedDuplicates: 0,
+          skippedClean: 0,
+          reallocations: 0,
+          rebuildsInFrame: () => 0,
+          peakRebuildsPerSourcePerFrame: 0
+        },
+        texturePool: {
+          live: pool?.live ?? 0,
+          created: pool?.created ?? 0,
+          destroyed: pool?.destroyed ?? 0
+        },
+        pipelines: {
+          renderPipelines: cache?.renderPipelines ?? 0,
+          computePipelines: cache?.computePipelines ?? 0
+        },
+        framesDrawn,
+        deviceGenerations: generations
+      };
+    },
+    attachDevice(device, ownership) {
+      host.attach(device, ownership ?? options.ownership ?? (options.device === device ? "app" : "vitrea"));
+    },
+    replaceDevice(device) {
+      host.replaceDevice(device);
+    },
+    markWebGPUUnavailable(reason) {
+      host.markUnavailable(reason);
+    },
+    registerBackdrop(provider) {
+      if (providers.has(provider.id)) {
+        throw rendererError("source-identity", `Backdrop source "${provider.id}" is already registered. Unregister it first, or register the replacement under a new id.`, provider.id);
+      }
+      providers.set(provider.id, provider);
+    },
+    unregisterBackdrop(sourceId) {
+      const provider = providers.get(sourceId);
+      if (provider === void 0)
+        return;
+      provider.destroy();
+      providers.delete(sourceId);
+      store?.forget(sourceId);
+      adaptation.delete(sourceId);
+      lastReadbackAt.delete(sourceId);
+    },
+    backdrop(sourceId) {
+      return providers.get(sourceId);
+    },
+    setViewport(next) {
+      const changed = next.widthCss !== viewport.widthCss || next.heightCss !== viewport.heightCss || next.devicePixelRatio !== viewport.devicePixelRatio;
+      viewport = next;
+      if (!changed)
+        return;
+      context?.pool.bumpSizeEpoch();
+    },
+    get viewport() {
+      return viewport;
+    },
+    setGroup(input) {
+      groups.set(input.groupId, { input });
+    },
+    removeGroup(groupId) {
+      groups.delete(groupId);
+      runner?.forget(groupId);
+    },
+    setAccessibility(policy) {
+      accessibility = policy;
+    },
+    setMaterialProfile(patch) {
+      material = withMaterialOverrides(DEFAULT_MATERIAL_PROFILE, patch);
+      adaptation.clear();
+    },
+    get materialProfile() {
+      return material;
+    },
+    setTargets(next) {
+      targets = {
+        optics: next.optics,
+        ...next.highlight === void 0 ? {} : { highlight: next.highlight },
+        format: next.format ?? OUTPUT_TEXTURE_FORMAT
+      };
+    },
+    drawFrame(args) {
+      const { context: gpu, store: pyramids, runner: passes } = ensureContext();
+      targets = {
+        optics: args.optics,
+        ...args.highlight === void 0 ? {} : { highlight: args.highlight },
+        format: args.format ?? OUTPUT_TEXTURE_FORMAT
+      };
+      pyramids.beginFrame(args.frame.id);
+      pyramids.setTimeline(args.timing);
+      passes.setTimeline(args.timing);
+      const encoder = gpu.device.createCommandEncoder({
+        label: `vitrea:frame:${args.frame.id}`
+      });
+      let result;
+      try {
+        const rebuilt = runRebuilds(encoder, rebuildRequests(args.rebuild), args.frame.timeMs);
+        pendingRebuilds = rebuilt.built;
+        recordUnbuilt(args.frame.id, rebuilt.unbuilt);
+        if (args.clear !== false) {
+          passes.clearPass(encoder, args.optics);
+          if (args.highlight !== void 0)
+            passes.clearPass(encoder, args.highlight);
+        }
+        result = drawGroups(encoder, args.resolution);
+        args.timing?.resolve(encoder);
+        gpu.device.queue.submit([encoder.finish()]);
+        pyramids.afterSubmit();
+      } finally {
+        pyramids.releaseAcquired();
+      }
+      const delta = lastFrameTimeMs === void 0 ? 0 : args.frame.timeMs - lastFrameTimeMs;
+      lastFrameTimeMs = args.frame.timeMs;
+      if (delta > 0) {
+        for (const state of adaptation.values())
+          state.advance(delta);
+      }
+      framesDrawn += 1;
+      pyramids.setTimeline(void 0);
+      passes.setTimeline(void 0);
+      return result;
+    },
+    frameParticipant() {
+      return {
+        id: "vitrea.renderer-webgpu",
+        write: (frameContext) => {
+          if (host.status.device === void 0 || host.status.deviceHealth !== "ok")
+            return;
+          const { context: gpu, store: pyramids, runner: passes } = ensureContext();
+          pyramids.beginFrame(frameContext.frame.id);
+          pyramids.setTimeline(void 0);
+          passes.setTimeline(void 0);
+          pendingEncoder = gpu.device.createCommandEncoder({
+            label: `vitrea:frame:${frameContext.frame.id}`
+          });
+          try {
+            const rebuilt = runRebuilds(pendingEncoder, frameContext.consumeDirtyBackdropSources(), frameContext.frame.timeMs);
+            pendingRebuilds = rebuilt.built;
+            recordUnbuilt(frameContext.frame.id, rebuilt.unbuilt);
+          } catch (error) {
+            pendingEncoder = void 0;
+            pyramids.releaseAcquired();
+            throw error;
+          }
+        },
+        render: (frameContext) => {
+          const encoder = pendingEncoder;
+          pendingEncoder = void 0;
+          if (encoder === void 0 || context === void 0)
+            return;
+          const passes = runner;
+          const pyramids = store;
+          try {
+            if (targets !== void 0) {
+              passes.clearPass(encoder, targets.optics);
+              if (targets.highlight !== void 0)
+                passes.clearPass(encoder, targets.highlight);
+              drawGroups(encoder, frameContext.resolution);
+            }
+            context.device.queue.submit([encoder.finish()]);
+            pyramids.afterSubmit();
+          } finally {
+            pyramids.releaseAcquired();
+          }
+          const delta = lastFrameTimeMs === void 0 ? 0 : frameContext.frame.timeMs - lastFrameTimeMs;
+          lastFrameTimeMs = frameContext.frame.timeMs;
+          if (delta > 0) {
+            for (const state of adaptation.values())
+              state.advance(delta);
+          }
+          framesDrawn += 1;
+        }
+      };
+    },
+    async collectAdaptation() {
+      if (store === void 0)
+        return 0;
+      const stats = await store.collectStats();
+      for (const [sourceId, value] of stats) {
+        const state = adaptationFor(sourceId);
+        if (state.values.observed)
+          state.observe(value);
+        else
+          state.reset(value);
+      }
+      return stats.size;
+    },
+    destroy() {
+      for (const provider of providers.values())
+        provider.destroy();
+      providers.clear();
+      groups.clear();
+      adaptation.clear();
+      lastReadbackAt.clear();
+      pendingUnbuilt = [];
+      unbuiltFrameId = void 0;
+      builtGeneration = void 0;
+      dropContext();
+      host.destroy();
+    }
+  };
+}
+
+export { ADAPTIVE_LUMINANCE_HIGH, ADAPTIVE_LUMINANCE_LOW, ADAPTIVE_TINT_DARK, ADAPTIVE_TINT_LIGHT, ANALYSIS_DISPATCH, ANALYSIS_GRID, ANALYSIS_PASS_ID, ANALYSIS_STATS_FLOATS, ANALYSIS_TARGET_EXTENT, ANALYSIS_WORKGROUP, BACKDROP_ALPHA_MODES, BACKDROP_COLOR_SPACES, BACKDROP_KINDS, BACKDROP_PASS_ID, CANVAS_FORMAT, CHAIN_SIGMA_AT_LEVEL_1, CROSS_CHECK_SHAPE_FLOATS, CROSS_CHECK_WORKGROUP, DEFAULT_MATERIAL_PROFILE, FAMILY_C_CROSS_CHECK, FIELD_PASS_ID, GOVERNOR_LADDER, HIGHLIGHT_PASS_ID, IDLE_CHANNELS, INCREASED_OCCLUSION_LIFT, INSTANCE_BYTES, INSTANCE_FLOATS, LENS_BODY_LOD_PER_PX, LENS_RIM_LOD_BIAS, LENS_SIZE_GAIN_MAX, LENS_SPAN_MAX, LENS_SPAN_MIN, LUMINANCE_WEIGHTS, MATERIAL_OPTICS, MATERIAL_VARIANTS, MAX_CHAIN_LEVELS, MIN_LEVEL_EXTENT, NOMINAL_GOVERNOR, NOMINAL_MATERIAL_POLICY, OPTICS_PASS_ID, OUTPUT_TEXTURE_FORMAT, PASS_LABEL, REFRACTION_LADDER, REFRACTION_SCALE, RENDERER_ERROR_CODES, RENDERER_PASS_IDS, RendererError, SUPPORTED_APP_TEXTURE_FORMATS, WGSL_ANALYSIS_PASS, WGSL_CROSS_CHECK_PASS, WGSL_DOWNSAMPLE_PASS, WGSL_FIELD_KERNELS, WGSL_FIELD_PASS, WGSL_FIELD_SAMPLE, WGSL_HIGHLIGHT_PASS, WGSL_IMPORT_PASS, WGSL_INSTANCE_STRUCT, WGSL_OPTICS_PASS, WGSL_PRELUDE, WGSL_RSUPN_GRAD, WGSL_RSUP_GRAD, WGSL_SMOOTH_UNION, WORKING_TEXTURE_FORMAT, ZERO_STATS, accessibilityRefractionCap, adaptationStrength, adaptiveTint, allShaderSource, alphaNormalisationMode, analysisModule, bodyBlurPlan, bodyLod, chainModule, clipFieldRectToCanvas, createAdaptationState, createAppTextureProvider, createCopyProvider, createDeviceHost, createGovernor, createGpuContext, createGradientProvider, createPassRunner, createPipelineCache, createPyramidStore, createRebuildLedger, createStorageSlot, createTexturePool, createTimingCollector, createUniformSlot, createVideoProvider, createWebGPURenderer, crossCheckKernelModule, displayP3ToSrgbLinear, effectiveRefraction, encodeOutput, encodeOutputBytes, fieldModule, fieldPassSource, groupFieldRect, highlightModule, importColorMatrix, importModule, importPassSource, lensDepthPx, lensSizeGain, linearGradientStops, linearToSrgb, linearToSrgbChannel, occlusionAlphaUnderPolicy, opticsModule, opticsUnderPolicy, packInstances, pipelineKey, planPyramid, poolKey, readbackDue, refractionRank, relativeLuminance, rendererError, resolveSurfaces, snapRectToDevicePixels, srgbToLinear, srgbToLinearChannel, statsFromBuffer, supportsTimestamps, validateAppTexture, withMaterialOverrides };
+//# sourceMappingURL=dist-FGJI5LQM.js.map
+//# sourceMappingURL=dist-FGJI5LQM.js.map