@vibecook/ice 0.14.0 → 0.15.0-desk.2

package/dist/{chunk-ZPUPBULB.js → chunk-52GMQ2BN.js}

@@ -19,6 +19,7 @@ import {
   LAYER_IDLE_MS,
   MARKS,
   MAT_GRID,
+  MISSING,
   MatUniforms,
   NOISE_SIZE,
   NO_GLYPHS,
@@ -75,7 +76,7 @@ import {
   solveFlightStart,
   spring,
   tilted
-} from "./chunk-BA7XJC27.js";
+} from "./chunk-K4HUZAYJ.js";
 import {
   BLEND_OVER,
   bindGroup,
@@ -136,6 +137,7 @@ import {
   defineQuery,
   defineWidget,
   departedCameraOf,
+  frameParent,
   gateVerdict,
   heldEntity,
   menuActionsFor,
@@ -153,13 +155,435 @@ import {
   trayTakeProps,
   widgetSpawnInits,
   widgetTypeFor
-} from "./chunk-DYK6KNLG.js";
+} from "./chunk-PFJN3XN2.js";
 import {
   cubicBezierEase,
   specimenFit,
   trayScrollMax
 } from "./chunk-JS6PG6YD.js";
 
+// ../desk/src/faults.ts
+var KIND_STRIKES = 3;
+var KIND_MISSING = -1;
+function faultText(err) {
+  const lines = (err instanceof Error ? err.message : typeof err === "object" && err !== null && "message" in err ? String(err.message) : String(err)).split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
+  return (lines.length > 1 && lines[0]?.startsWith("WGSL ") ? `${lines[0]} ${lines[1]}` : lines[0]) ?? "refused";
+}
+function createKindFaults() {
+  const missing = /* @__PURE__ */ new Set();
+  const strikes = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Set();
+  let list = [];
+  const go = (kind, reason) => {
+    missing.add(kind);
+    faults.size = missing.size;
+    const fault = { kind, reason };
+    list = [...list, fault];
+    console.error(`[ice] desk: the kind "${kind}" is MISSING \u2014 ${reason}. Its objects are drawn as missing and nothing of it is called again (petition I24).`);
+    for (const l of [...listeners]) l(fault);
+  };
+  const faults = {
+    size: 0,
+    missing: (kind) => missing.size > 0 && missing.has(kind),
+    refuse(kind, reason) {
+      if (missing.has(kind)) return;
+      go(kind, reason);
+    },
+    strike(kind, call, err, entity) {
+      if (missing.has(kind)) return false;
+      const n = (strikes.get(kind) ?? 0) + 1;
+      strikes.set(kind, n);
+      const on = entity === void 0 ? "" : ` on entity ${entity}`;
+      if (n < KIND_STRIKES) {
+        console.warn(`[ice] desk: the kind "${kind}" threw in its \`${call}\`${on} \u2014 strike ${n} of ${KIND_STRIKES}; the frame goes on without it`, err);
+        return false;
+      }
+      go(kind, `its \`${call}\` threw${on} (strike ${n} of ${KIND_STRIKES}): ${faultText(err)}`);
+      return true;
+    },
+    strikes: (kind) => strikes.get(kind) ?? 0,
+    list: () => list,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+  return faults;
+}
+
+// ../desk/src/missing/layout.ts
+var MissingFace = defineStruct("MissingFace", [
+  ["rect", "vec4f"],
+  // centre x, y; half extents x, y — world units
+  ["ink", "vec4f"],
+  // the ink (rgb), the object's fade (w)
+  ["mix", "vec4f"],
+  // the wash's, the hatching's and the edge's alpha
+  ["shape", "vec4f"]
+  // the corner (world units); the hatching's pitch and weight, the edge's weight (CSS px)
+]);
+var isMissingRecord = (r) => typeof r === "object" && r !== null && r.missing === true;
+var INKS = { light: rgb(MISSING.ink.light), dark: rgb(MISSING.ink.dark) };
+function missingFace(rect, theme, fade = 1) {
+  return { missing: true, cx: rect.cx, cy: rect.cy, hx: Math.abs(rect.w) / 2, hy: Math.abs(rect.h) / 2, ink: INKS[theme.name] ?? INKS.light, fade };
+}
+var NONE = { rect: [0, 0, 0, 0], ink: [0, 0, 0, 0], mix: [0, 0, 0, 0], shape: [0, 0, 0, 0] };
+function missingValues(r) {
+  if (!isMissingRecord(r)) return NONE;
+  return {
+    rect: [r.cx, r.cy, r.hx, r.hy],
+    ink: [r.ink[0], r.ink[1], r.ink[2], r.fade],
+    mix: [MISSING.wash, MISSING.hatch, MISSING.edge, 0],
+    shape: [MISSING.corner, MISSING.pitch, MISSING.weight, MISSING.edgeWeight]
+  };
+}
+function missingHit(g, wx, wy) {
+  return Math.abs(wx - g.cx) <= Math.abs(g.w) / 2 && Math.abs(wy - g.cy) <= Math.abs(g.h) / 2 ? "content" : null;
+}
+
+// ../desk/src/engine/records.ts
+var DEFAULT_MAX = 65536;
+var GAP = 4;
+var NONE2 = { aux: 0, blockN: 0 };
+function createRecordStore(opts) {
+  const { device, def, label, pack } = opts;
+  const max = opts.max ?? DEFAULT_MAX;
+  const blocksDef = opts.blocks;
+  const per = blocksDef?.per ?? 0;
+  let capacity = Math.max(1, Math.min(opts.capacity, max));
+  let cpu = def.alloc(capacity);
+  let gpu = storageBuffer(device, def.size * capacity, label);
+  let blockCpu = blocksDef ? blocksDef.def.alloc(capacity * per) : null;
+  let blockGpu = blocksDef ? storageBuffer(device, blocksDef.def.size * capacity * per, blocksDef.label) : null;
+  let orderCpu = new Uint32Array(capacity);
+  let orderGpu = storageBuffer(device, 4 * capacity, `${label} order`);
+  let version = 0;
+  let grown = 0;
+  const byKey = /* @__PURE__ */ new Map();
+  let bySlot = new Array(capacity).fill(null);
+  const free = [];
+  let next = 0;
+  let gen = 0;
+  let lastKeys = null;
+  let prevOrder = [];
+  let count = 0;
+  const dirty = [];
+  let written = 0;
+  let bytes = 0;
+  let orderWrites = 0;
+  const grow = () => {
+    if (capacity >= max) throw new Error(`${label}: ${capacity} record slots is the most this store grows to`);
+    const was = capacity;
+    capacity = Math.min(capacity * 2, max);
+    const nextCpu = def.alloc(capacity);
+    new Uint8Array(nextCpu.bytes).set(new Uint8Array(cpu.bytes));
+    cpu = nextCpu;
+    gpu.destroy();
+    gpu = storageBuffer(device, def.size * capacity, label);
+    if (blocksDef && blockCpu && blockGpu) {
+      const nextBlocks = blocksDef.def.alloc(capacity * per);
+      new Uint8Array(nextBlocks.bytes).set(new Uint8Array(blockCpu.bytes));
+      blockCpu = nextBlocks;
+      blockGpu.destroy();
+      blockGpu = storageBuffer(device, blocksDef.def.size * capacity * per, blocksDef.label);
+    }
+    const nextOrder = new Uint32Array(capacity);
+    nextOrder.set(orderCpu);
+    orderCpu = nextOrder;
+    orderGpu.destroy();
+    orderGpu = storageBuffer(device, 4 * capacity, `${label} order`);
+    const nextBySlot = new Array(capacity).fill(null);
+    for (let i = 0; i < was; i++) nextBySlot[i] = bySlot[i] ?? null;
+    bySlot = nextBySlot;
+    version += 1;
+    grown += 1;
+  };
+  let grew = false;
+  const alloc = () => {
+    const reused = free.pop();
+    if (reused !== void 0) return reused;
+    if (next === capacity) {
+      grow();
+      grew = true;
+    }
+    return next++;
+  };
+  const release = (ent) => {
+    byKey.delete(ent.key);
+    bySlot[ent.slot] = null;
+    free.push(ent.slot);
+  };
+  const resetAll = () => {
+    bySlot.fill(null);
+    byKey.clear();
+    free.length = 0;
+    next = 0;
+  };
+  const packInto = (ent, record, aux) => {
+    ent.record = record;
+    ent.aux = aux;
+    ent.blockN = pack(record, aux, cpu, ent.slot, blockCpu, ent.slot * per);
+    dirty.push(ent.slot);
+  };
+  const runs = () => {
+    dirty.sort((a, b) => a - b);
+    const out = [];
+    for (const s of dirty) {
+      const last = out[out.length - 1];
+      if (last !== void 0 && s <= last[1] + 1 + GAP) {
+        if (s > last[1]) last[1] = s;
+      } else out.push([s, s]);
+    }
+    return out;
+  };
+  const upload = (n, orderMoved) => {
+    let rewriteOrder = orderMoved;
+    if (grew) {
+      grew = false;
+      if (next > 0) {
+        device.queue.writeBuffer(gpu, 0, cpu.bytes, 0, next * def.size);
+        bytes += next * def.size;
+      }
+      if (blocksDef && blockCpu && blockGpu && next > 0) {
+        device.queue.writeBuffer(blockGpu, 0, blockCpu.bytes, 0, next * per * blocksDef.def.size);
+        bytes += next * per * blocksDef.def.size;
+      }
+      written += dirty.length;
+      dirty.length = 0;
+      rewriteOrder = true;
+    } else if (dirty.length > 0) {
+      for (const [a, b] of runs()) {
+        const n0 = b - a + 1;
+        device.queue.writeBuffer(gpu, a * def.size, cpu.bytes, a * def.size, n0 * def.size);
+        bytes += n0 * def.size;
+      }
+      if (blocksDef && blockCpu && blockGpu) {
+        const bsize = blocksDef.def.size;
+        for (const s of dirty) {
+          const ent = bySlot[s];
+          if (!ent || ent.blockN === 0) continue;
+          device.queue.writeBuffer(blockGpu, s * per * bsize, blockCpu.bytes, s * per * bsize, ent.blockN * bsize);
+          bytes += ent.blockN * bsize;
+        }
+      }
+      written += dirty.length;
+      dirty.length = 0;
+    }
+    if (rewriteOrder) {
+      if (n > 0) device.queue.writeBuffer(orderGpu, 0, orderCpu, 0, n);
+      orderWrites += 1;
+      prevOrder = Array.from(orderCpu.subarray(0, n));
+    }
+  };
+  return {
+    get records() {
+      return gpu;
+    },
+    get order() {
+      return orderGpu;
+    },
+    get blocks() {
+      return blockGpu;
+    },
+    get version() {
+      return version;
+    },
+    prepare(records, keys, aux) {
+      gen += 1;
+      const n = records.length;
+      let orderChanged = n !== prevOrder.length;
+      if (keys === void 0) {
+        resetAll();
+        lastKeys = null;
+        for (let i = 0; i < n; i++) {
+          const slot = alloc();
+          const ent = { key: -0.5 - i, slot, record: void 0, aux: 0, gen, blockN: 0 };
+          bySlot[slot] = ent;
+          packInto(ent, records[i], aux ? aux(i) : 0);
+          if (!orderChanged && prevOrder[i] !== slot) orderChanged = true;
+          orderCpu[i] = slot;
+        }
+      } else {
+        if (keys.length !== n) throw new Error(`${label}: ${keys.length} keys for ${n} records`);
+        if (lastKeys === null) resetAll();
+        const same = lastKeys !== null && lastKeys.length === n && lastKeys.every((k, i) => k === keys[i]);
+        for (let i = 0; i < n; i++) {
+          const key = keys[i];
+          let ent = byKey.get(key);
+          if (ent === void 0) {
+            const slot = alloc();
+            ent = { key, slot, record: void 0, aux: 0, gen, blockN: 0 };
+            byKey.set(key, ent);
+            bySlot[slot] = ent;
+          }
+          ent.gen = gen;
+          const a = aux ? aux(i) : 0;
+          if (ent.record !== records[i] || ent.aux !== a) packInto(ent, records[i], a);
+          if (!orderChanged && prevOrder[i] !== ent.slot) orderChanged = true;
+          orderCpu[i] = ent.slot;
+        }
+        if (!same) {
+          if (lastKeys !== null) for (const k of lastKeys) {
+            const ent = byKey.get(k);
+            if (ent !== void 0 && ent.gen !== gen) release(ent);
+          }
+          lastKeys = keys.slice();
+        }
+      }
+      upload(n, orderChanged);
+      count = n;
+      return n;
+    },
+    slotAt: (i) => i < count ? orderCpu[i] : -1,
+    entryAt(i) {
+      if (i >= count) return NONE2;
+      const ent = bySlot[orderCpu[i]];
+      return ent === null || ent === void 0 ? NONE2 : { aux: ent.aux, blockN: ent.blockN };
+    },
+    invalidate() {
+      for (const ent of byKey.values()) ent.record = void 0;
+    },
+    stats: () => ({ written, bytes, orderWrites, slots: next - free.length, capacity, grown }),
+    dispose() {
+      gpu.destroy();
+      orderGpu.destroy();
+      blockGpu?.destroy();
+      byKey.clear();
+    }
+  };
+}
+
+// ../desk/src/missing/shaders.ts
+var MISSING_SHADER_FILES = { entry: "missing/missing-pass.wgsl" };
+function missingShaders(text2 = shaderText) {
+  return kitWgsl(["view", "portal", "sdf"], {
+    structs: [MissingFace],
+    entry: { label: MISSING_SHADER_FILES.entry, text: text2(MISSING_SHADER_FILES).entry }
+  }, text2);
+}
+
+// ../desk/src/missing/pass.ts
+var BLEND_PREMUL = {
+  color: { srcFactor: "one", dstFactor: "one-minus-src-alpha", operation: "add" },
+  alpha: { srcFactor: "one", dstFactor: "one-minus-src-alpha", operation: "add" }
+};
+var MAX_FACES = 65536;
+var NO_RECORDS = { written: 0, bytes: 0, orderWrites: 0, slots: 0, capacity: 0, grown: 0 };
+var MissingPass = class _MissingPass {
+  name = "desk/missing";
+  store = null;
+  group = null;
+  boundStore = -1;
+  boundAssets = -1;
+  count = 0;
+  device;
+  shared;
+  mat;
+  constructor(device, shared, mat) {
+    this.device = device;
+    this.shared = shared;
+    this.mat = mat;
+  }
+  /**
+   * The root's pass on `mat`, made NOW (no await — a quarantine asks for it mid-frame): its layout and its one pipeline (it is lit by
+   * nothing — the same in every slot). The desk's own WGSL, composed from the host's text; WebGPU compiles it before its first draw.
+   */
+  static make(device, format, mat, text2) {
+    const layout = bindLayout(device, [
+      { binding: 0, stages: ["vertex", "fragment"], buffer: "uniform" },
+      { binding: 1, stages: ["vertex", "fragment"], buffer: "read-only-storage" },
+      { binding: 2, stages: ["vertex"], buffer: "read-only-storage" }
+    ], "desk/missing");
+    const shader = compose(missingShaders(text2));
+    const module = device.createShaderModule({ code: shader.code, label: shader.label });
+    const pipeline = device.createRenderPipeline({
+      label: "desk/missing",
+      layout: device.createPipelineLayout({ bindGroupLayouts: [layout] }),
+      vertex: { module, entryPoint: "vs" },
+      fragment: { module, entryPoint: "fs", targets: [{ format, blend: BLEND_PREMUL }] },
+      primitive: { topology: "triangle-list" }
+    });
+    return new _MissingPass(device, { layout, pipeline }, mat);
+  }
+  /** A slot's own faces on the shared pipeline, through `mat`'s view block. */
+  spawn(mat) {
+    return new _MissingPass(this.device, this.shared, mat);
+  }
+  prepare(_encoder, _slot, records, extra) {
+    if (records.length === 0 && this.store === null) {
+      this.count = 0;
+      return 0;
+    }
+    this.store ??= createRecordStore({
+      device: this.device,
+      def: MissingFace,
+      capacity: 16,
+      max: MAX_FACES,
+      label: "desk/missing",
+      pack: (r, _aux, into, slot) => {
+        into.set(missingValues(r), slot);
+        return 0;
+      }
+    });
+    this.count = this.store.prepare(records.length > MAX_FACES ? records.slice(0, MAX_FACES) : records, extra?.keys !== void 0 && extra.keys.length > MAX_FACES ? extra.keys.slice(0, MAX_FACES) : extra?.keys);
+    this.rebind();
+    return this.count;
+  }
+  rebind() {
+    const store = this.store;
+    if (store === null || this.group !== null && this.boundStore === store.version && this.boundAssets === this.mat.assetVersion) return;
+    this.group = bindGroup(this.device, this.shared.layout, [this.mat.view, store.records, store.order], "desk/missing");
+    this.boundStore = store.version;
+    this.boundAssets = this.mat.assetVersion;
+  }
+  drawRange(pass, first, end) {
+    const hi = Math.min(end, this.count);
+    if (first >= hi || this.group === null) return;
+    pass.setPipeline(this.shared.pipeline);
+    pass.setBindGroup(0, this.group);
+    pass.draw(6, hi - first, 0, first);
+  }
+  /** The store's counters (a rig's witness) — nothing until the slot's first face. */
+  records() {
+    return this.store?.stats() ?? NO_RECORDS;
+  }
+  dispose() {
+    this.store?.dispose();
+    this.store = null;
+    this.group = null;
+  }
+};
+function missingFaces(device, format, mat, text2) {
+  let root = null;
+  return {
+    spawn: (m) => {
+      root ??= MissingPass.make(device, format, mat, text2);
+      return root.spawn(m);
+    },
+    get made() {
+      return root !== null;
+    },
+    dispose: () => {
+      root?.dispose();
+      root = null;
+    }
+  };
+}
+
+// ../desk/src/missing/object.ts
+var MISSING_KIND = "desk.missing";
+var MISSING_OBJECT = {
+  name: MISSING_KIND,
+  stratum: "things",
+  reach: 0,
+  create: async (device, format, mat) => MissingPass.make(device, format, mat),
+  resolve: (ctx) => ctx.rect,
+  record: (g, ctx) => missingFace(g, ctx.theme, ctx.flux.fade),
+  hit: (g, wx, wy) => missingHit(g, wx, wy)
+};
+
 // ../desk/src/kind.ts
 var STRATA = ["pads", "sheets", "things"];
 
@@ -231,9 +655,9 @@ function band(stretch) {
   const a = Math.abs(stretch);
   return Math.sign(stretch) * B * (1 - 1 / (1 + a * DRAWER.band.c / B));
 }
-function scrollRange(vw, vh, bottom) {
+function scrollRange(vw, vh, bottom, foot = 0) {
   const { h } = drawerSize(vw, vh);
-  return trayScrollMax(bottom, h, DRAWER.pitch);
+  return trayScrollMax(bottom, h - foot, DRAWER.pitch);
 }
 
 // ../desk/src/tray/lattice.ts
@@ -346,7 +770,7 @@ var TrayUniforms = defineStruct("TrayUniforms", [
   ["accessory", "vec4f"],
   // K5a: the accessories' powder coat, linear, and their shadows' strength on the board
   ["fade", "vec4f"]
-  // the content's fade under the header (design-018 §4, R4): its band F, the clear header H above it, CSS px; —, —
+  // the content's fade under the header (design-018 §4, R4): its band F, the clear header H above it, CSS px; a host's foot inset (I21; 0 none); —
 ]);
 var TrayAccessoryStruct = defineStruct("TrayAccessory", [
   ["box", "vec4f"],
@@ -373,7 +797,7 @@ function trayShaders(text2) {
 }
 
 // ../desk/src/card/card.ts
-var BLEND_PREMUL = {
+var BLEND_PREMUL2 = {
   color: { srcFactor: "one", dstFactor: "one-minus-src-alpha", operation: "add" },
   alpha: { srcFactor: "one", dstFactor: "one-minus-src-alpha", operation: "add" }
 };
@@ -541,8 +965,8 @@ async function buildCard(device, format, kinds) {
     const module = await compile(device, compose(cardShaders(kinds)));
     const pl = device.createPipelineLayout({ bindGroupLayouts: [layout] });
     const [pipeline, litPipeline] = await Promise.all([
-      renderPipeline(device, { label: "card/flat", layout: pl, module, format, blend: BLEND_PREMUL }),
-      renderPipeline(device, { label: "card/flat, lit from elsewhere", layout: pl, module, format, blend: BLEND_PREMUL, constants: { LIT_ELSEWHERE: 1 } })
+      renderPipeline(device, { label: "card/flat", layout: pl, module, format, blend: BLEND_PREMUL2 }),
+      renderPipeline(device, { label: "card/flat, lit from elsewhere", layout: pl, module, format, blend: BLEND_PREMUL2, constants: { LIT_ELSEWHERE: 1 } })
     ]);
     return { ok: true, layout, pipeline, litPipeline };
   } catch (e) {
@@ -709,13 +1133,21 @@ var CardPass = class _CardPass {
   }
 };
 
+// ../desk/src/missing/slots.ts
+function swapToMissing(s, name, faces) {
+  const k = s.kinds.get(name);
+  if (k === void 0 || faces === void 0) return void 0;
+  s.kinds.set(name, { name, stratum: k.stratum, pass: faces.spawn(s.mat) });
+  return k.pass;
+}
+
 // ../desk/src/hold/focus.ts
 var HoldUniformsStruct = defineStruct("HoldUniforms", [
   ["texel", "vec4f"],
   ["mix", "vec4f"]
 ]);
 var KAWASE = { levels: 2, offsetPerTexel: 0.25 };
-var BLEND_PREMUL2 = {
+var BLEND_PREMUL3 = {
   color: { srcFactor: "one", dstFactor: "one-minus-src-alpha", operation: "add" },
   alpha: { srcFactor: "one", dstFactor: "one-minus-src-alpha", operation: "add" }
 };
@@ -763,7 +1195,7 @@ var HoldPass = class _HoldPass {
       renderPipeline(device, { label: "hold/down", layout: pl, module, fragment: "fs_down", format }),
       renderPipeline(device, { label: "hold/up", layout: pl, module, fragment: "fs_up", format }),
       renderPipeline(device, { label: "hold/desk", layout: pl, module, fragment: "fs_desk", format }),
-      renderPipeline(device, { label: "hold/hand", layout: pl, module, fragment: "fs_hand", format, blend: BLEND_PREMUL2 })
+      renderPipeline(device, { label: "hold/hand", layout: pl, module, fragment: "fs_hand", format, blend: BLEND_PREMUL3 })
     ]);
     return new _HoldPass(device, format, layout, pipes);
   }
@@ -1472,7 +1904,7 @@ function selectionBox(frames) {
 }
 
 // ../desk/src/marks/pass.ts
-var BLEND_PREMUL3 = {
+var BLEND_PREMUL4 = {
   color: { srcFactor: "one", dstFactor: "one-minus-src-alpha", operation: "add" },
   alpha: { srcFactor: "one", dstFactor: "one-minus-src-alpha", operation: "add" }
 };
@@ -1512,7 +1944,7 @@ var MarksPass = class _MarksPass {
       { binding: 3, stages: ["fragment"], sampler: "filtering" }
     ], "marks");
     const pl = device.createPipelineLayout({ label: "marks", bindGroupLayouts: [layout] });
-    const pipeline = await renderPipeline(device, { label: "marks", layout: pl, module, format, blend: BLEND_PREMUL3 });
+    const pipeline = await renderPipeline(device, { label: "marks", layout: pl, module, format, blend: BLEND_PREMUL4 });
     return new _MarksPass(device, mat, pipeline, layout);
   }
   /**
@@ -1791,12 +2223,22 @@ function carryView(pose, rect) {
 }
 
 // ../desk/src/tray/specimens.ts
-function faceClip(rect, vh) {
+function recordOf(kind, ctx, faults) {
+  if (faults === void 0) return kind.record(kind.resolve(ctx), ctx);
+  if (faults.missing(kind.name)) return missingFace(ctx.rect, ctx.theme, ctx.flux.fade);
+  try {
+    return kind.record(kind.resolve(ctx), ctx);
+  } catch (err) {
+    faults.strike(kind.name, "record", err, ctx.entity);
+    return void 0;
+  }
+}
+function faceClip(rect, vh, foot = 0) {
   const a = DRAWER.arris;
   const x0 = rect.x + a;
   const x1 = rect.x + rect.w - a;
   const y0 = rect.y + a + DRAWER.header;
-  const y1 = Math.max(vh, rect.y + rect.h) + DRAWER.radius;
+  const y1 = foot > 0 ? rect.y + rect.h - foot : Math.max(vh, rect.y + rect.h) + DRAWER.radius;
   return { cx: (x0 + x1) / 2, cy: (y0 + y1) / 2, hx: (x1 - x0) / 2, hy: (y1 - y0) / 2, r: DRAWER.radius - a };
 }
 function trayGrid(grid) {
@@ -1813,7 +2255,7 @@ function specimenFrames(specimens, drawn, env) {
   const P = DRAWER.pitch;
   const grid = trayGrid(env.grid);
   const { width, height, dpr } = env.view;
-  const face2 = faceClip(drawn.rect, height);
+  const face2 = faceClip(drawn.rect, height, drawn.foot);
   for (const s of specimens) {
     const x0 = drawn.rect.x + s.rect.x;
     const y0 = drawn.rect.y + s.rect.y - drawn.scroll;
@@ -1839,7 +2281,8 @@ function specimenFrames(specimens, drawn, env) {
       ...s.local !== void 0 ? { local: s.local } : {},
       ...s.asset !== void 0 ? { asset: s.asset } : {}
     };
-    const record = s.kind.record(s.kind.resolve(ctx), ctx);
+    const record = recordOf(s.kind, ctx, env.faults);
+    if (record === void 0) continue;
     const hx = x0 + s.rect.w / 2;
     const hy = s.accessory === "shelf" ? y0 + s.rect.h : y0;
     out.push({
@@ -1917,7 +2360,8 @@ function carriedFrame(pose, src, env) {
     dt: 0,
     ...src.local !== void 0 ? { local: src.local } : {}
   };
-  const record = src.kind.record(src.kind.resolve(ctx), ctx);
+  const record = recordOf(src.kind, ctx, env.faults);
+  if (record === void 0) return void 0;
   const x0 = (r.x - v.camX) * v.zoom;
   const y0 = (r.y - v.camY) * v.zoom;
   return {
@@ -1934,7 +2378,7 @@ function carriedFrame(pose, src, env) {
   };
 }
 function facePresent(drawn, vh) {
-  return { opacity: 1, portal: faceClip(drawn.rect, vh) };
+  return { opacity: 1, portal: faceClip(drawn.rect, vh, drawn.foot) };
 }
 var TraySlots = class {
   device;
@@ -1972,7 +2416,7 @@ var TraySlots = class {
       const mat = this.root.mat.spawn();
       void program.create(this.device, this.format, mat).then((pass) => {
         this.making.delete(type);
-        if (this.disposed) {
+        if (this.disposed || this.root.kinds.get(kind)?.pass !== own.pass) {
           pass.dispose();
           mat.dispose();
           return;
@@ -2012,6 +2456,19 @@ var TraySlots = class {
     for (const s of this.slots.values()) for (const k of s.kinds.values()) t = Math.min(t, k.pass.idleAt?.(ms) ?? Number.POSITIVE_INFINITY);
     return t;
   }
+  /**
+   * Kind `name` went MISSING (petition I24 — the ground's quarantine): its entry in every slot made so far becomes the desk's missing
+   * faces on the slot's mat (a slot made from now on spawns the root's entry, which is already the face's). Returns the passes the
+   * entries held; the ground lets them go.
+   */
+  quarantine(name, faces) {
+    const gone = [];
+    for (const s of this.slots.values()) {
+      const p = swapToMissing(s, name, faces);
+      if (p !== void 0) gone.push(p);
+    }
+    return gone;
+  }
   /** The slots made so far (a rig's witness). */
   get size() {
     return this.slots.size;
@@ -2027,7 +2484,7 @@ var TraySlots = class {
 };
 
 // ../desk/src/tray/pass.ts
-var BLEND_PREMUL4 = {
+var BLEND_PREMUL5 = {
   color: { srcFactor: "one", dstFactor: "one-minus-src-alpha", operation: "add" },
   alpha: { srcFactor: "one", dstFactor: "one-minus-src-alpha", operation: "add" }
 };
@@ -2082,6 +2539,8 @@ var TrayPass = class _TrayPass {
   sent = false;
   /** The quads the last prepare laid: 0 while the drawer is shut (p 0) — then it draws nothing. */
   quads = 0;
+  /** A host's foot inset this frame (I21): the veil lays a second quad, over the foot, in its one draw. */
+  foot = 0;
   group = null;
   boundAssets = -1;
   last = null;
@@ -2115,9 +2574,9 @@ var TrayPass = class _TrayPass {
     ], "tray/pegboard");
     const pl = device.createPipelineLayout({ label: "tray/pegboard", bindGroupLayouts: [layout] });
     const pipelines = await Promise.all([
-      renderPipeline(device, { label: "tray/pegboard", layout: pl, module, format, blend: BLEND_PREMUL4 }),
-      renderPipeline(device, { label: "tray/pegboard/accessories", layout: pl, module, format, blend: BLEND_PREMUL4, fragment: "fs_accessory" }),
-      renderPipeline(device, { label: "tray/pegboard/veil", layout: pl, module, format, blend: BLEND_PREMUL4, vertex: "vs_veil", fragment: "fs_veil" })
+      renderPipeline(device, { label: "tray/pegboard", layout: pl, module, format, blend: BLEND_PREMUL5 }),
+      renderPipeline(device, { label: "tray/pegboard/accessories", layout: pl, module, format, blend: BLEND_PREMUL5, fragment: "fs_accessory" }),
+      renderPipeline(device, { label: "tray/pegboard/veil", layout: pl, module, format, blend: BLEND_PREMUL5, vertex: "vs_veil", fragment: "fs_veil" })
     ]);
     return new _TrayPass(device, mat, pipelines, layout);
   }
@@ -2131,8 +2590,10 @@ var TrayPass = class _TrayPass {
     const p = Math.min(Math.max(inputs.p, 0), 1);
     const rect = drawerRect(view.width, view.height, p);
     const { rowBase, frac } = carry(inputs.scroll, P);
+    const foot = inputs.foot !== void 0 && inputs.foot > 0 ? inputs.foot : 0;
+    this.foot = foot;
     if (p <= 0) {
-      this.last = { rect, rowBase, frac, dim: 0, accessories: [] };
+      this.last = { rect, rowBase, frac, dim: 0, accessories: [], ...foot > 0 ? { foot } : {} };
       this.quads = 0;
       return 0;
     }
@@ -2165,7 +2626,7 @@ var TrayPass = class _TrayPass {
       keepFine: [keep(fp, 210), keep(fp, 42), keep(fp, 105), 0],
       keepEdge: [keep(fp, 9), keep(fp, 18), keep(fp, 36), 0],
       accessory: [...T.accessory, T.accessoryShadow],
-      fade: [DRAWER.fade, DRAWER.header, 0, 0]
+      fade: [DRAWER.fade, DRAWER.header, foot, 0]
     };
     this.tray.set(values);
     const gobo = grid.mat.gobo;
@@ -2182,7 +2643,7 @@ var TrayPass = class _TrayPass {
     this.sent = true;
     const accessories = (inputs.specimens ?? []).map(accessoryOf);
     this.layAccessories(accessories);
-    this.last = { rect, rowBase, frac, dim, accessories };
+    this.last = { rect, rowBase, frac, dim, accessories, ...foot > 0 ? { foot } : {} };
     this.quads = 1;
     return 1;
   }
@@ -2242,13 +2703,13 @@ var TrayPass = class _TrayPass {
   /**
    * THE VEIL (design-018 rev 5) — LAST, over everything the drawer holds (the caller left the scissor on the whole view): the plain board
    * whole in the header and fading out over its ramp, so what hangs there and the holes behind it fade into the board together — a
-   * specimen never turns see-through over a hole. One quad.
+   * specimen never turns see-through over a hole. One quad — and with a host's foot (I21) a second, over the foot, in the same draw.
    */
   drawVeil(pass) {
     if (this.quads === 0) return;
     pass.pushDebugGroup("tray/pegboard/veil");
     this.bind(pass, this.veilPipeline);
-    pass.draw(6, 1, 0, 0);
+    pass.draw(this.foot > 0 ? 12 : 6, 1, 0, 0);
     pass.popDebugGroup();
   }
   /** What the last prepare laid (a rig's witness). */
@@ -2265,26 +2726,127 @@ var TrayPass = class _TrayPass {
 
 // ../desk/src/ground.ts
 var visible = (p) => (p?.opacity ?? 1) > 0;
-async function createSlotSet(device, format, mat, programs) {
+function checkPrograms(programs) {
   const names = /* @__PURE__ */ new Set();
   for (const p of programs) {
     if (!p.name) throw new Error("ground: a kind needs a name \u2014 it is the kind's key in every slot");
+    if (p.name === MISSING_KIND) throw new Error(`ground: the kind name "${MISSING_KIND}" is the desk's own \u2014 the missing face's (petition I24)`);
     if (names.has(p.name)) throw new Error(`ground: two kinds are named "${p.name}" \u2014 a kind's name is its key in every slot`);
     if (!STRATA.includes(p.stratum)) throw new Error(`ground: kind "${p.name}" lies in no stratum the ground draws ("${p.stratum}"; ${STRATA.join(", ")})`);
     names.add(p.name);
   }
-  const [passes, cards] = await Promise.all([Promise.all(programs.map((p) => p.create(device, format, mat))), createCardShared(device, format, programs)]);
+}
+var SCOPES = ["validation", "out-of-memory", "internal"];
+var watched = (device) => typeof device.pushErrorScope === "function";
+var pushScopes = (device) => {
+  if (watched(device)) for (const f of SCOPES) device.pushErrorScope(f);
+};
+function popScopes(device) {
+  if (!watched(device)) return Promise.resolve(null);
+  const popped = SCOPES.map(() => device.popErrorScope());
+  return Promise.all(popped).then((errors) => errors.find((e) => e !== null) ?? null);
+}
+var settle = (p) => {
+  try {
+    return Promise.resolve(p()).then((value) => ({ value }), (error) => ({ error }));
+  } catch (error) {
+    return Promise.resolve({ error });
+  }
+};
+function letGo(name, pass) {
+  try {
+    pass.dispose();
+  } catch (err) {
+    console.error(`desk: the kind "${name}"'s pass threw in its dispose`, err);
+  }
+}
+async function createKindPasses(device, format, mat, programs, onError) {
+  pushScopes(device);
+  const made = programs.map((p) => {
+    pushScopes(device);
+    const created = settle(() => p.create(device, format, mat));
+    return { created, own: popScopes(device) };
+  });
+  const first = await Promise.all(made.map(async (m) => ({ created: await m.created, own: await m.own })));
+  const window2 = await popScopes(device);
+  const passes = [];
+  const faults = [];
+  const refuse = (p, why) => {
+    faults.push({ kind: p.name, reason: why });
+  };
+  const threw = (err) => `refused at create \u2014 ${faultText(err)}`;
+  const raised = (err) => `refused at create \u2014 a GPU error while its pass was made: ${faultText(err)}`;
+  first.forEach(({ created, own }, i) => {
+    const p = programs[i];
+    if ("error" in created) {
+      passes.push(void 0);
+      refuse(p, threw(created.error));
+      return;
+    }
+    if (own !== null) {
+      passes.push(void 0);
+      letGo(p.name, created.value);
+      refuse(p, raised(own));
+      return;
+    }
+    passes.push(created.value);
+  });
+  if (window2 !== null) {
+    let found = false;
+    for (let i = 0; i < programs.length; i++) {
+      const p = programs[i];
+      const had = passes[i];
+      if (had === void 0) continue;
+      letGo(p.name, had);
+      pushScopes(device);
+      const again = await settle(() => p.create(device, format, mat));
+      const own = await popScopes(device);
+      if ("error" in again) {
+        passes[i] = void 0;
+        found = true;
+        refuse(p, threw(again.error));
+        continue;
+      }
+      if (own !== null) {
+        passes[i] = void 0;
+        found = true;
+        letGo(p.name, again.value);
+        refuse(p, raised(own));
+        continue;
+      }
+      passes[i] = again.value;
+    }
+    if (!found) onError?.(window2);
+  }
+  faults.sort((a, b) => programs.findIndex((p) => p.name === a.kind) - programs.findIndex((p) => p.name === b.kind));
+  return { passes, faults };
+}
+function slotSetOf(device, mat, programs, made, missing, cards) {
   const kinds = /* @__PURE__ */ new Map();
   for (let i = 0; i < programs.length; i++) {
     const p = programs[i];
-    kinds.set(p.name, { name: p.name, stratum: p.stratum, pass: passes[i], ...p.composite ? { composite: true } : {} });
+    const pass = made.passes[i];
+    kinds.set(p.name, pass === void 0 ? { name: p.name, stratum: p.stratum, pass: missing.spawn(mat) } : { name: p.name, stratum: p.stratum, pass, ...p.composite ? { composite: true } : {} });
   }
-  return cards === null ? { mat, kinds } : { mat, kinds, card: new CardPass(device, cards, mat, kinds) };
+  const card = cards === null ? void 0 : new CardPass(device, cards, mat, kinds);
+  return { mat, kinds, missing, ...card !== void 0 ? { card } : {}, ...made.faults.length > 0 ? { faults: made.faults } : {} };
+}
+var standing = (programs, made) => programs.filter((_, i) => made.passes[i] !== void 0);
+var unattributed = (e) => {
+  console.error("desk: a GPU error while the kinds were made, no kind's alone \u2014", e.message);
+};
+async function createSlotSet(device, format, mat, programs, onError = unattributed) {
+  checkPrograms(programs);
+  const made = await createKindPasses(device, format, mat, programs, onError);
+  const cards = await createCardShared(device, format, standing(programs, made));
+  return slotSetOf(device, mat, programs, made, missingFaces(device, format, mat), cards);
 }
 var SlotPool = class {
   slots = [];
   used = 0;
   root;
+  /** False once a kind the card composes went missing (petition I24 — `Ground.quarantine`): every slot's card, spawned or yet to be, is off. */
+  cardOn = true;
   constructor(root) {
     this.root = root;
   }
@@ -2298,10 +2860,15 @@ var SlotPool = class {
       const kinds = /* @__PURE__ */ new Map();
       for (const k of this.root.kinds.values()) kinds.set(k.name, { name: k.name, stratum: k.stratum, pass: k.pass.spawn(mat), ...k.composite ? { composite: true } : {} });
       const card = this.root.card?.spawn(mat, kinds);
+      if (card !== void 0 && !this.cardOn) card.on = false;
       this.slots.push(card === void 0 ? { mat, kinds } : { mat, kinds, card });
     }
     return this.slots[this.used++];
   }
+  /** Every slot spawned so far (a quarantine walks them). */
+  each(fn) {
+    for (const s of this.slots) fn(s);
+  }
   /** Slots spawned so far — the churn instrument. */
   get size() {
     return this.slots.length;
@@ -2421,7 +2988,13 @@ function prepareFrame(encoder, root, pool, inputs, grid = DEFAULT_GRID, target,
     }
     const indexOf = [];
     for (const o of objects) {
-      const list = records.get(o.kind);
+      let list = records.get(o.kind);
+      if (!list && o.kind === MISSING_KIND && root.missing !== void 0) {
+        s.kinds.set(MISSING_KIND, { name: MISSING_KIND, stratum: "things", pass: root.missing.spawn(s.mat) });
+        list = [];
+        records.set(MISSING_KIND, list);
+        keys.set(MISSING_KIND, []);
+      }
       if (!list) throw new Error(`ground: no kind "${o.kind}" is registered (${[...s.kinds.keys()].join(", ") || "none"})`);
       indexOf.push(list.length);
       list.push(o.record);
@@ -2459,7 +3032,7 @@ function prepareFrame(encoder, root, pool, inputs, grid = DEFAULT_GRID, target,
     for (const k of s.kinds.values()) {
       const list = records.get(k.name) ?? [];
       if (list.length === 0) {
-        drawn.push([k.name, 0]);
+        if (k.name !== MISSING_KIND) drawn.push([k.name, 0]);
         continue;
       }
       const own = root.kinds.get(k.name);
@@ -2511,7 +3084,7 @@ function prepareFrame(encoder, root, pool, inputs, grid = DEFAULT_GRID, target,
   const tray = [];
   const specimens = inputs.tray?.specimens;
   if (specimens !== void 0 && specimens.length > 0 && traySlots !== void 0 && inputs.tray !== void 0) {
-    const present = facePresent({ rect: trayRectOf(inputs), scroll: inputs.tray.scroll }, inputs.view.height);
+    const present = facePresent({ rect: trayRectOf(inputs), scroll: inputs.tray.scroll, ...inputs.tray.foot !== void 0 ? { foot: inputs.tray.foot } : {} }, inputs.view.height);
     for (const f of specimens) {
       const slot = traySlots.get(f.type, f.kind);
       if (slot === void 0) continue;
@@ -2550,7 +3123,7 @@ function drawTray(pass, size, dpr, tray, slots, marks, carried) {
   if (rect !== void 0) {
     for (const s of slots ?? []) drawSlot(pass, size, dpr, { ...s, bare: true });
     if (marks !== null && marks.tagCount > 0) {
-      const [x, y, w, h] = scissorOf({ opacity: 1, portal: faceBox(rect, size.h / dpr) }, dpr, size);
+      const [x, y, w, h] = scissorOf({ opacity: 1, portal: faceBox(rect, size.h / dpr, tray.laid?.foot ?? 0) }, dpr, size);
       if (w > 0 && h > 0) {
         pass.setScissorRect(x, y, w, h);
         marks.drawTags(pass);
@@ -2564,13 +3137,27 @@ function drawTray(pass, size, dpr, tray, slots, marks, carried) {
     pass.setScissorRect(0, 0, size.w, size.h);
   }
 }
-function faceBox(rect, vh) {
+function faceBox(rect, vh, foot) {
   const x0 = rect.x + DRAWER.arris;
   const x1 = rect.x + rect.w - DRAWER.arris;
   const y0 = rect.y + DRAWER.arris + DRAWER.header;
-  const y1 = Math.max(vh, rect.y + rect.h);
+  const y1 = foot > 0 ? rect.y + rect.h - foot : Math.max(vh, rect.y + rect.h);
   return { cx: (x0 + x1) / 2, cy: (y0 + y1) / 2, hx: (x1 - x0) / 2, hy: (y1 - y0) / 2, r: 0 };
 }
+function encodeFrame(encoder, passes, inputs, into, target) {
+  const { root, pool, grid, marks, tray, traySlots } = passes;
+  const trayed = inputs.tray !== void 0 && tray !== null ? tray.prepare(inputs.view, inputs.theme, inputs.grid ?? grid, inputs.mat, inputs.tray) : 0;
+  const prepared = prepareFrame(encoder, root, pool, inputs, grid, target, inputs.tray !== void 0 ? traySlots ?? void 0 : void 0);
+  const marked = marks !== null ? marks.prepare(inputs.marks, trayed > 0 && tray !== null ? { view: inputs.view, tags: tagsOf(inputs.tray), night: inputs.theme.matLight.night } : void 0) : 0;
+  const bg = inputs.theme.canvasBg;
+  const size = into.size();
+  const pass = beginPass(encoder, into.view(), [bg[0], bg[1], bg[2], 1], "ground");
+  const drawn = drawFrame(pass, size, inputs.view.dpr, prepared.incoming, prepared.outgoing);
+  if (marked > 0) marks?.draw(pass);
+  if ((trayed > 0 || prepared.carried !== void 0) && tray !== null) drawTray(pass, size, inputs.view.dpr, tray, prepared.tray, marks, prepared.carried);
+  pass.end();
+  return { stats: { ...drawn.incoming, kinds: prepared.kinds, outgoing: drawn.outgoing, portals: prepared.portals, ...prepared.dropped ? { dropped: prepared.dropped } : {} }, prepared, marked };
+}
 var Ground = class _Ground {
   device;
   surface;
@@ -2598,6 +3185,8 @@ var Ground = class _Ground {
   }
   /** The drops last said, by kind (D7). */
   dropSaid = /* @__PURE__ */ new Map();
+  /** The kinds MISSING on this ground (petition I24): refused at create, or quarantined since — their entries draw the missing face. */
+  missing = /* @__PURE__ */ new Set();
   constructor(device, surface2, root, marks, hold, tray, programs) {
     this.device = device;
     this.surface = surface2;
@@ -2608,21 +3197,68 @@ var Ground = class _Ground {
     this.tray = tray;
     this.pool = new SlotPool(root);
     this.traySlots = tray === null ? null : new TraySlots(device, surface2.format, root, programs);
+    for (const f of root.faults ?? []) this.missing.add(f.kind);
   }
+  /**
+   * The mat first (every kind's pass is made on it), then every kind's pass in its own error scope (`createKindPasses` — a kind refused
+   * there is MISSING from the start: `faults()`, petition I24), then — once the kinds' window has closed, so nothing of theirs is taken
+   * for a kind's — the card over the kinds that stood, the marks, the hand and the tray, together. The missing faces are made only when
+   * one is asked for (a kind refused here, a quarantine, an object with no kind).
+   */
   static async create(opts) {
     const surf = opts.surface;
     const mat = await CuttingMat.create(opts.device, surf.format, opts.mat);
-    const root = await createSlotSet(opts.device, surf.format, mat, opts.kinds);
-    const [marks, hold, tray] = await Promise.all([
+    checkPrograms(opts.kinds);
+    const made = await createKindPasses(opts.device, surf.format, mat, opts.kinds, opts.onError ?? unattributed);
+    const [cards, marks, hold, tray] = await Promise.all([
+      createCardShared(opts.device, surf.format, standing(opts.kinds, made)),
       opts.marks === void 0 ? null : MarksPass.create(opts.device, surf.format, opts.marks, mat),
       opts.hold === void 0 ? null : HoldPass.create(opts.device, surf.format, opts.hold),
       opts.tray === void 0 ? null : TrayPass.create(opts.device, surf.format, opts.tray, mat)
     ]);
-    return new _Ground(opts.device, surf, root, marks, hold, tray, opts.kinds);
+    return new _Ground(opts.device, surf, slotSetOf(opts.device, mat, opts.kinds, made, missingFaces(opts.device, surf.format, mat), cards), marks, hold, tray, opts.kinds);
   }
-  /** The root's pass of the kind registered as `name` (undefined if none) — a host reaches its kind's own API through it: the note's ink pages, the whiteboard's rasters. */
+  /**
+   * The root's pass of the kind registered as `name` (undefined if none, or MISSING — petition I24: nothing of a missing kind is reached
+   * again) — a host reaches its kind's own API through it: the note's ink pages, the whiteboard's rasters.
+   */
   pass(name) {
-    return this.root.kinds.get(name)?.pass;
+    return this.missing.has(name) ? void 0 : this.root.kinds.get(name)?.pass;
+  }
+  /** The kinds REFUSED when this ground was made (petition I24): each its name and why. Quarantines since are the layer's word. */
+  faults() {
+    return this.root.faults ?? [];
+  }
+  /**
+   * THE QUARANTINE (petition I24): kind `name` is MISSING from now on — its entry in every slot this ground holds (the root, the pool's,
+   * the tray's) becomes a spawn of that slot's missing face, under its name and in its stratum, and the passes it had are disposed (the
+   * pool's and the tray's first; the root's — whose shared resources go with it — last; a dispose that throws is said and passed). A
+   * kind the flat card composes turns the card off in every slot, for good (K7b's own A/B door: each material kind then draws its own
+   * runs — the card's pixels, more draws): its resources leave the card's bind group, and no draw may reach them. The next frame draws
+   * the kind's objects in the missing face (the builder makes their records so); one already made for its own pass is drawn as nothing.
+   * A kind already missing, or none of that name: nothing.
+   */
+  quarantine(name) {
+    if (this.missing.has(name) || !this.root.kinds.has(name)) return;
+    this.missing.add(name);
+    if (this.root.card?.materialOf(name) !== void 0) {
+      this.root.card.on = false;
+      this.pool.cardOn = false;
+      this.pool.each((s) => {
+        if (s.card !== void 0) s.card.on = false;
+      });
+    }
+    const faces = this.root.missing;
+    const gone = [];
+    this.pool.each((s) => {
+      const p = swapToMissing(s, name, faces);
+      if (p !== void 0) gone.push(p);
+    });
+    gone.push(...this.traySlots?.quarantine(name, faces) ?? []);
+    const root = swapToMissing(this.root, name, faces);
+    if (root !== void 0) gone.push(root);
+    for (const p of gone) letGo(name, p);
+    if (this.heldCache.stamp !== null) this.heldCache.stamp = "";
   }
   /** Size the canvas to its CSS box; returns the CSS size and dpr the frame should use. (A host may size the canvas itself instead.) */
   fit(maxDpr = 2) {
@@ -2637,17 +3273,18 @@ var Ground = class _Ground {
       for (const k of this.root.kinds.values()) k.pass.endHold?.();
     }
     const encoder = this.device.createCommandEncoder({ label: "ground" });
-    const trayed = inputs.tray !== void 0 && this.tray !== null ? this.tray.prepare(inputs.view, inputs.theme, inputs.grid ?? this.grid, inputs.mat, inputs.tray) : 0;
-    const prepared = prepareFrame(encoder, this.root, this.pool, inputs, this.grid, void 0, inputs.tray !== void 0 ? this.traySlots ?? void 0 : void 0);
-    const marked = this.marks !== null ? this.marks.prepare(inputs.marks, trayed > 0 && this.tray !== null ? { view: inputs.view, tags: tagsOf(inputs.tray), night: inputs.theme.matLight.night } : void 0) : 0;
-    const bg = inputs.theme.canvasBg;
-    const pass = beginPass(encoder, this.surface.view(), [bg[0], bg[1], bg[2], 1], "ground");
-    const drawn = drawFrame(pass, this.surface.size(), inputs.view.dpr, prepared.incoming, prepared.outgoing);
-    if (marked > 0) this.marks?.draw(pass);
-    if ((trayed > 0 || prepared.carried !== void 0) && this.tray !== null) drawTray(pass, this.surface.size(), inputs.view.dpr, this.tray, prepared.tray, this.marks, prepared.carried);
-    pass.end();
+    const { stats } = encodeFrame(encoder, this, inputs, this.surface);
     this.device.queue.submit([encoder.finish()]);
-    return this.said({ ...drawn.incoming, kinds: prepared.kinds, outgoing: drawn.outgoing, portals: prepared.portals, ...prepared.dropped ? { dropped: prepared.dropped } : {} });
+    return this.said(stats);
+  }
+  /**
+   * THE CAPTURE DOOR's GPU half (petition I23; `captureFrame`): `inputs` — the last frame's, as `render` took them — drawn once
+   * more into a readable texture at the view's dpr × `scale`, `rect` (CSS px of the view) read back. The swap chain is not touched,
+   * no frame is drawn, nothing is kept: the still and its readback buffer are made for the call and destroyed after it. Undefined
+   * when the device is lost mid-copy, or the rect lies off the view.
+   */
+  capture(inputs, opts = {}) {
+    return captureFrame(this.device, this, this.surface.format, inputs, this.heldCache, opts);
   }
   /** A kind whose cap turns objects away is an ERROR on the host's console (D7): said when the drop begins and again if it grows. */
   said(stats) {
@@ -2659,12 +3296,13 @@ var Ground = class _Ground {
     for (const kind of [...this.dropSaid.keys()]) if (!(kind in now)) this.dropSaid.delete(kind);
     return stats;
   }
-  /** The pool's slots, then the root's kinds in reverse registration order, then the mat. */
+  /** The pool's slots, then the root's kinds in reverse registration order (a missing kind's face among them), its missing face, then the mat. */
   dispose() {
     this.pool.dispose();
     this.traySlots?.dispose();
     this.root.card?.dispose();
     for (const k of [...this.root.kinds.values()].reverse()) k.pass.dispose();
+    this.root.missing?.dispose();
     this.marks?.dispose();
     this.hold?.dispose();
     this.tray?.dispose();
@@ -2687,7 +3325,7 @@ function tagsOf(tray) {
   const P = DRAWER.pitch;
   return (tray?.specimens ?? []).map((f) => ({ label: f.label, x: (f.screen.x0 + f.screen.x1) / 2, y: f.screen.y1 + (f.accessory === "shelf" ? 0.24 * P : 0) + 0.45 * P }));
 }
-function renderHeldFrame(device, hold, root, pool, grid, into, inputs, held, cache) {
+function renderHeldFrame(device, hold, root, pool, grid, into, inputs, held, cache, label = "hold") {
   const size = into.size();
   const dpr = inputs.view.dpr;
   const bg = inputs.theme.canvasBg;
@@ -2695,29 +3333,104 @@ function renderHeldFrame(device, hold, root, pool, grid, into, inputs, held, cac
   if (remade || cache.stamp !== held.stamp) {
     cache.stamp = held.stamp;
     cache.copies += 1;
-    const encoder2 = device.createCommandEncoder({ label: "hold/copy" });
+    const encoder2 = device.createCommandEncoder({ label: `${label}/copy` });
     const { held: _held, marks: _marks, ...rest } = inputs;
     const copy = { ...rest, view: { ...inputs.view, dpr: dpr / 2 } };
     const prepared = prepareFrame(encoder2, root, pool, copy, grid, "copy");
-    const pass2 = beginPass(encoder2, hold.desk.view, [bg[0], bg[1], bg[2], 1], "hold/copy");
+    const pass2 = beginPass(encoder2, hold.desk.view, [bg[0], bg[1], bg[2], 1], `${label}/copy`);
     const drawn = drawFrame(pass2, { w: hold.desk.width, h: hold.desk.height }, dpr / 2, prepared.incoming, prepared.outgoing);
     pass2.end();
     hold.blur(encoder2, held.blur * dpr / 2);
     device.queue.submit([encoder2.finish()]);
     cache.stats = { ...drawn.incoming, kinds: prepared.kinds, outgoing: drawn.outgoing, portals: prepared.portals, ...prepared.dropped ? { dropped: prepared.dropped } : {} };
   }
-  const encoder = device.createCommandEncoder({ label: "hold" });
+  const encoder = device.createCommandEncoder({ label });
   const handInputs = { view: held.view, grid: held.grid, objects: [held.object, ...held.riders ?? []], theme: { ...inputs.theme, matLight: held.light } };
   const hand = prepareFrame(encoder, root, pool, handInputs, held.grid, "hand");
-  const handPass = beginPass(encoder, hold.hand.view, [0, 0, 0, 0], "hold/hand");
+  const handPass = beginPass(encoder, hold.hand.view, [0, 0, 0, 0], `${label}/hand`);
   drawSlot(handPass, size, dpr, { ...hand.incoming, bare: true });
   handPass.end();
-  const pass = beginPass(encoder, into.view(), [bg[0], bg[1], bg[2], 1], "hold");
+  const pass = beginPass(encoder, into.view(), [bg[0], bg[1], bg[2], 1], label);
   hold.composite(pass, { e: held.e, dim: held.dim, saturate: held.filter.saturate, brightness: held.filter.brightness });
   pass.end();
   device.queue.submit([encoder.finish()]);
   return cache.stats ?? { k0: 0, fade: 0, wind: false, kinds: hand.kinds, outgoing: null, portals: 0 };
 }
+var captureNumber = (what, v, positive) => {
+  if (typeof v !== "number" || !Number.isFinite(v) || positive && v <= 0) throw new Error(`capture: ${what} must be a ${positive ? "positive " : ""}finite number (got ${String(v)})`);
+  return v;
+};
+function checkCapture(opts) {
+  captureNumber("scale", opts.scale ?? 1, true);
+  const r = opts.rect;
+  if (r === void 0) return;
+  captureNumber("rect.x", r.x, false);
+  captureNumber("rect.y", r.y, false);
+  captureNumber("rect.width", r.width, false);
+  captureNumber("rect.height", r.height, false);
+}
+function scaledInputs(inputs, scale) {
+  if (scale === 1) return inputs;
+  const dprOf = (v) => ({ ...v, dpr: v.dpr * scale });
+  const slotOf = (s) => ({ ...s, view: dprOf(s.view), ...s.portals !== void 0 ? { portals: s.portals.map(slotOf) } : {} });
+  const { outgoing, held, marks, tray } = inputs;
+  return {
+    ...slotOf(inputs),
+    ...outgoing !== void 0 ? { outgoing: slotOf(outgoing) } : {},
+    ...held !== void 0 ? { held: { ...held, view: dprOf(held.view) } } : {},
+    ...marks !== void 0 ? { marks: { ...marks, view: dprOf(marks.view) } } : {},
+    ...tray !== void 0 ? { tray: { ...tray, ...tray.specimens !== void 0 ? { specimens: tray.specimens.map((f) => ({ ...f, view: dprOf(f.view) })) } : {}, ...tray.carried !== void 0 ? { carried: tray.carried.map((f) => ({ ...f, view: dprOf(f.view) })) } : {} } } : {}
+  };
+}
+async function captureFrame(device, passes, format, inputs, cache, opts = {}) {
+  checkCapture(opts);
+  const frame = scaledInputs(inputs, opts.scale ?? 1);
+  const dpr = frame.view.dpr;
+  const size = { w: Math.max(1, Math.round(frame.view.width * dpr)), h: Math.max(1, Math.round(frame.view.height * dpr)) };
+  let box2 = { x: 0, y: 0, w: size.w, h: size.h };
+  const r = opts.rect;
+  if (r !== void 0) {
+    const x0 = Math.max(0, Math.round(r.x * dpr));
+    const y0 = Math.max(0, Math.round(r.y * dpr));
+    const x1 = Math.min(size.w, Math.round((r.x + r.width) * dpr));
+    const y1 = Math.min(size.h, Math.round((r.y + r.height) * dpr));
+    box2 = { x: x0, y: y0, w: x1 - x0, h: y1 - y0 };
+    if (box2.w <= 0 || box2.h <= 0) return void 0;
+  }
+  const still = new Target(device, { format, label: "capture/still", readable: true }, size.w, size.h);
+  const into = { view: () => still.view, size: () => size };
+  const rowBytes = Math.ceil(box2.w * 4 / 256) * 256;
+  const readback = device.createBuffer({ label: "capture/readback", size: rowBytes * box2.h, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ });
+  try {
+    const copy = (encoder) => {
+      encoder.copyTextureToBuffer({ texture: still.texture, origin: [box2.x, box2.y] }, { buffer: readback, bytesPerRow: rowBytes }, [box2.w, box2.h]);
+    };
+    if (frame.held !== void 0 && frame.held.e > 0 && passes.hold !== null) {
+      renderHeldFrame(device, passes.hold, passes.root, passes.pool, passes.grid, into, frame, frame.held, cache, "capture");
+      const encoder = device.createCommandEncoder({ label: "capture/read" });
+      copy(encoder);
+      device.queue.submit([encoder.finish()]);
+    } else {
+      const encoder = device.createCommandEncoder({ label: "capture" });
+      encodeFrame(encoder, passes, frame, into, "capture");
+      copy(encoder);
+      device.queue.submit([encoder.finish()]);
+    }
+    try {
+      await readback.mapAsync(GPUMapMode.READ);
+    } catch {
+      return void 0;
+    }
+    const padded = new Uint8Array(readback.getMappedRange());
+    const bytes = new Uint8Array(new ArrayBuffer(box2.w * box2.h * 4));
+    for (let y = 0; y < box2.h; y++) bytes.set(padded.subarray(y * rowBytes, y * rowBytes + box2.w * 4), y * box2.w * 4);
+    readback.unmap();
+    return { width: box2.w, height: box2.h, format, bytes };
+  } finally {
+    readback.destroy();
+    still.dispose();
+  }
+}
 
 // ../desk/src/mat/tilt.ts
 function secondOrder(f = 1, z = 0.3, r = 2, value = [0, 0]) {
@@ -3303,12 +4016,38 @@ function createDeskBuilder(world, opts) {
   const S = opts.springs ?? SPRINGS;
   const rungCtx = { entity: NO_ENTITY, rect: { cx: 0, cy: 0, w: 0, h: 0 }, props: {}, zoom: 1, dpr: 1, local: void 0, px: 0 };
   const locals = opts.locals;
+  const faults = opts.faults;
   const forget = (kind, e) => {
     locals?.get(kind.name)?.forget?.(e);
   };
+  const drawerOf = (kind) => kind === MISSING_OBJECT || faults?.missing(kind.name) === true ? MISSING_OBJECT : kind;
+  const fault = (kind, call, err, e) => {
+    if (faults === void 0) throw err;
+    faults.strike(kind.name, call, err, e);
+  };
+  const kindless = /* @__PURE__ */ new Set();
+  const mounted = /* @__PURE__ */ new Set();
+  for (const w of opts.objects) {
+    const k = objectKindOf(w);
+    if (k !== void 0) mounted.add(k.name);
+  }
+  const unmounted = /* @__PURE__ */ new Set();
+  const veilers = [];
+  const veilerNames = [];
+  const liftedBy = (st, e) => {
+    const local = locals?.get(st.kind.name);
+    if (local?.lifted === void 0) return false;
+    try {
+      return local.lifted(e) === true;
+    } catch (err) {
+      fault(st.kind, "lifted", err, e);
+      return false;
+    }
+  };
   const ghostS = (opts.ghostMs ?? GHOST_MS) / 1e3;
   const marginPx = opts.marginPx ?? MARGIN_PX;
   const redressMs = opts.redressMs ?? REDRESS_MS;
+  const reserves = opts.hold ?? HOLD;
   const order = createSiblingOrderIndex(world);
   const states = /* @__PURE__ */ new Map();
   const ghosts = /* @__PURE__ */ new Map();
@@ -3418,7 +4157,7 @@ function createDeskBuilder(world, opts) {
     const h = world.readField(e, Size, "h") ?? 0;
     st.rect = rectOf({ x, y }, { w, h });
     const props = {};
-    for (const g of st.widget.groups) {
+    for (const g of st.widget?.groups ?? []) {
       const v = world.get(e, g.component);
       if (v !== void 0) for (const name of Object.keys(g.fields)) props[name] = v[name];
     }
@@ -3443,13 +4182,28 @@ function createDeskBuilder(world, opts) {
     const id3 = world.get(e, PrefabId)?.id;
     if (typeof id3 !== "string") return void 0;
     const widget = widgetTypeFor(world, id3);
-    const kind = objectKindOf(widget);
-    if (widget === void 0 || kind === void 0) return void 0;
+    let kind = objectKindOf(widget);
+    if (kind !== void 0 && faults !== void 0 && !mounted.has(kind.name)) {
+      if (!unmounted.has(id3)) {
+        unmounted.add(id3);
+        console.warn(`[ice] desk: the type "${id3}" has a kind ("${kind.name}") this desk was not mounted with \u2014 a desk's kinds are compiled at its mount, and a type registered after it adds none: its objects are drawn as missing; remount to draw it (petition I25)`);
+      }
+      kind = MISSING_OBJECT;
+    }
+    if (kind === void 0) {
+      if (faults === void 0) return void 0;
+      kind = MISSING_OBJECT;
+      if (!kindless.has(id3)) {
+        kindless.add(id3);
+        console.warn(`[ice] desk: the type "${id3}" has no kind on this desk \u2014 its objects are drawn as missing (petition I24)`);
+      }
+    }
     meet(kind);
     const insert = world.has(e, InsertGhost);
     const st = {
       kind,
       widget,
+      face: false,
       rect: { cx: 0, cy: 0, w: 0, h: 0 },
       props: {},
       selected: false,
@@ -3490,7 +4244,7 @@ function createDeskBuilder(world, opts) {
     if (st === void 0) return void 0;
     if (st.dirty) refresh(e, st);
     if (had === void 0 && landing.length > 0 && !st.insert) {
-      const i = landing.findIndex((l2) => l2.type === st.widget.type && Math.abs(l2.rect.cx - st.rect.cx) < 0.5 && Math.abs(l2.rect.cy - st.rect.cy) < 0.5);
+      const i = landing.findIndex((l2) => l2.type === st.widget?.type && Math.abs(l2.rect.cx - st.rect.cx) < 0.5 && Math.abs(l2.rect.cy - st.rect.cy) < 0.5);
       const l = landing[i];
       if (l !== void 0) {
         st.lift = l.lift;
@@ -3532,25 +4286,38 @@ function createDeskBuilder(world, opts) {
   const frameGridOf = (frame, root, looks) => {
     if (frame === void 0 || !world.isAlive(frame) || !world.hasTag(frame, Container)) return root;
     const st = stateOf(frame);
-    if (st === void 0 || st.kind.insideGrid === void 0) return root;
-    return st.kind.insideGrid({ props: st.props, look: looks.get(st.kind.name) }, root);
+    const kind = st === void 0 ? void 0 : drawerOf(st.kind);
+    if (st === void 0 || kind?.insideGrid === void 0) return root;
+    try {
+      return kind.insideGrid({ props: st.props, look: looks.get(kind.name) }, root);
+    } catch (err) {
+      fault(kind, "insideGrid", err, frame);
+      return root;
+    }
   };
   const navFace = (container, cam) => {
     const st = stateOf(container);
-    if (st === void 0 || st.kind.face === void 0) return void 0;
-    let G;
-    if (st.seen === seq && st.geometry !== null && st.slot === "root") G = st.geometry;
-    else {
-      const grid = lastGrid;
-      const theme = lastTheme;
-      if (grid === void 0 || theme === void 0) return void 0;
-      const vp = world.getResource(Viewport);
-      const view2 = { camX: cam.x, camY: cam.y, zoom: cam.zoom, width: vp?.w ?? 0, height: vp?.h ?? 0, dpr: vp?.dpr ?? 1 };
-      const local = locals?.get(st.kind.name);
-      const ctx = { entity: container, rect: st.rect, props: st.props, flux: FLUX_REST, look: lastLooks?.get(st.kind.name), theme, lamp: lampOf(grid.mat.plane), view: view2, grid, dt: 0, ...local !== void 0 ? { local } : {} };
-      G = st.kind.resolve(ctx);
+    const kind = st === void 0 ? void 0 : drawerOf(st.kind);
+    if (st === void 0 || kind?.face === void 0) return void 0;
+    let face2;
+    try {
+      let G;
+      if (st.seen === seq && st.geometry !== null && st.slot === "root" && !st.face) G = st.geometry;
+      else {
+        const grid = lastGrid;
+        const theme = lastTheme;
+        if (grid === void 0 || theme === void 0) return void 0;
+        const vp = world.getResource(Viewport);
+        const view2 = { camX: cam.x, camY: cam.y, zoom: cam.zoom, width: vp?.w ?? 0, height: vp?.h ?? 0, dpr: vp?.dpr ?? 1 };
+        const local = locals?.get(kind.name);
+        const ctx = { entity: container, rect: st.rect, props: st.props, flux: FLUX_REST, look: lastLooks?.get(kind.name), theme, lamp: lampOf(grid.mat.plane), view: view2, grid, dt: 0, ...local !== void 0 ? { local } : {} };
+        G = kind.resolve(ctx);
+      }
+      face2 = kind.face(G);
+    } catch (err) {
+      fault(kind, "face", err, container);
+      return void 0;
     }
-    const face2 = st.kind.face(G);
     if (face2 === void 0) return void 0;
     const vpSize = viewportOf();
     const view = insideViewOfFace(face2, st.kind.faceLaw?.radius ?? 0, contentOf(container), cam, vpSize, FIT, PORTAL_GATE);
@@ -3657,10 +4424,17 @@ function createDeskBuilder(world, opts) {
         for (const c of childrenOf(e)) {
           if (chips.length >= cap) break;
           const cst = stateOf(c);
-          if (cst === void 0 || cst.kind.chip === void 0) continue;
+          const ckind = cst === void 0 ? void 0 : drawerOf(cst.kind);
+          if (cst === void 0 || ckind?.chip === void 0) continue;
           const cctx = contextOf(c, cst, insideView, insideGrid, insideLamp, false);
           work.resolved += 1;
-          const chip = cst.kind.chip(cst.kind.resolve(cctx), cctx);
+          let chip;
+          try {
+            chip = ckind.chip(ckind.resolve(cctx), cctx);
+          } catch (err) {
+            fault(ckind, "chip", err, c);
+            continue;
+          }
           if (chip === null) continue;
           const finish = finishOf(chip.finish, finishes);
           if (finish === void 0) {
@@ -3671,28 +4445,32 @@ function createDeskBuilder(world, opts) {
         }
         return chips;
       };
-      const insideOf = (e, st, G, ctx, slotCam, slotGrid) => {
-        const face2 = st.kind.face?.(G);
+      const insideOf = (e, st, kind, G, ctx, slotCam, slotGrid) => {
+        const face2 = kind.face?.(G);
         if (face2 === void 0) {
           st.inside = null;
           st.content = null;
           return void 0;
         }
         const content = contentOf(e);
-        const view = insideViewOfFace(face2, st.kind.faceLaw?.radius ?? 0, content, slotCam, vpSize, FIT, PORTAL_GATE);
+        const view = insideViewOfFace(face2, kind.faceLaw?.radius ?? 0, content, slotCam, vpSize, FIT, PORTAL_GATE);
         st.inside = view;
         st.content = content;
         return { content, view, chips: chipsOf(e, st, ctx, view, slotGrid) };
       };
-      const checkReuse = (e, st, view, slotGrid, slotLamp, springs, give, slotCam) => {
+      const checkReuse = (e, st, kind, view, slotGrid, slotLamp, springs, give, slotCam) => {
         const r = st.rect;
         const drawn = give === 0 ? r : { ...r, cx: r.cx + give / slotCam.zoom };
         const ctx = contextOf(e, st, view, slotGrid, slotLamp, springs, drawn);
-        const G = st.kind.resolve(ctx);
-        const face2 = st.kind.face?.(G);
-        const inside = face2 === void 0 ? void 0 : { content: st.content, view: st.inside, chips: chipsOf(e, st, ctx, st.inside, slotGrid) };
-        const R = st.kind.record(G, inside === void 0 ? ctx : { ...ctx, inside });
-        if (!sameRecord(R, st.record)) mismatches += 1;
+        try {
+          const G = kind.resolve(ctx);
+          const face2 = kind.face?.(G);
+          const inside = face2 === void 0 ? void 0 : { content: st.content, view: st.inside, chips: chipsOf(e, st, ctx, st.inside, slotGrid) };
+          const R = kind.record(G, inside === void 0 ? ctx : { ...ctx, inside });
+          if (!sameRecord(R, st.record)) mismatches += 1;
+        } catch (err) {
+          fault(kind, "record", err, e);
+        }
       };
       const buildSlot = (members, slotCam, slotGrid, slot, depth, skip, redressOut2) => {
         const slotLamp = lampOf(slotGrid.mat.plane);
@@ -3729,9 +4507,11 @@ function createDeskBuilder(world, opts) {
             st.inside = null;
             continue;
           }
+          const kind = (faults?.size ?? 0) === 0 ? st.kind : drawerOf(st.kind);
+          const face2 = kind === MISSING_OBJECT;
           const r = st.rect;
-          const hx = r.w / 2 + st.kind.reach;
-          const hy = r.h / 2 + st.kind.reach;
+          const hx = r.w / 2 + kind.reach;
+          const hy = r.h / 2 + kind.reach;
           if (r.cx + hx < x0 || r.cx - hx > x1 || r.cy + hy < y0 || r.cy - hy > y1) {
             st.geometry = null;
             st.record = null;
@@ -3741,60 +4521,87 @@ function createDeskBuilder(world, opts) {
           }
           const give = slot === "root" ? marks.giveOf(e) : 0;
           const fluxMoved = springs ? stepSprings(e, st) : false;
-          const kind = st.kind;
           const fresh = st.record === null || st.geometry === null;
-          let remake = fresh || st.stale || remakeAll || fluxMoved || prevSlot !== slot || give !== st.give || kind.composite === true || restless?.has(kind.name) === true;
+          let remake = fresh || st.stale || remakeAll || fluxMoved || prevSlot !== slot || give !== st.give || st.face !== face2 || kind.composite === true || restless?.has(kind.name) === true;
           if (fresh) work.fresh += 1;
           if (restless?.has(kind.name) === true) work.restless += 1;
-          if (!remake && (redpr || slotCam.zoom !== st.zoom)) {
-            if (kind.rung !== void 0) {
-              if (rungOf(kind, e, st, slotCam) !== st.rung) {
-                remake = true;
-                work.rerung += 1;
-              } else st.zoom = slotCam.zoom;
-            } else if (kind.rezoom === true) {
-              remake = true;
-              work.rezoomed += 1;
-            }
-          }
           let G;
           let R;
-          if (!remake) {
-            G = st.geometry;
-            R = st.record;
-            work.reused += 1;
-            if (kind.face !== void 0) {
-              const face2 = kind.face(G);
-              st.inside = face2 === void 0 ? null : insideViewOfFace(face2, st.kind.faceLaw?.radius ?? 0, st.content, slotCam, vpSize, FIT, PORTAL_GATE);
+          let call = "rung";
+          try {
+            if (!remake && (redpr || slotCam.zoom !== st.zoom)) {
+              if (kind.rung !== void 0) {
+                if (rungOf(kind, e, st, slotCam) !== st.rung) {
+                  remake = true;
+                  work.rerung += 1;
+                } else st.zoom = slotCam.zoom;
+              } else if (kind.rezoom === true) {
+                remake = true;
+                work.rezoomed += 1;
+              }
             }
-            if (verifying) checkReuse(e, st, view, slotGrid, slotLamp, springs, give, slotCam);
-          } else {
-            const drawn = give === 0 ? r : { ...r, cx: r.cx + give / slotCam.zoom };
-            const ctx = contextOf(e, st, view, slotGrid, slotLamp, springs, drawn);
-            work.resolved += 1;
-            G = kind.resolve(ctx);
-            const inside = insideOf(e, st, G, ctx, slotCam, slotGrid);
-            work.recorded += 1;
-            R = kind.record(G, inside === void 0 ? ctx : { ...ctx, inside });
-            const landed = locals?.get(kind.name)?.landed?.(e) ?? 0;
-            if (landed !== st.landed) {
-              st.landed = landed;
-              deskLanded = true;
+            if (!remake) {
+              G = st.geometry;
+              R = st.record;
+              work.reused += 1;
+              if (kind.face !== void 0) {
+                call = "face";
+                const shown = kind.face(G);
+                st.inside = shown === void 0 ? null : insideViewOfFace(shown, kind.faceLaw?.radius ?? 0, st.content, slotCam, vpSize, FIT, PORTAL_GATE);
+              }
+              if (verifying) checkReuse(e, st, kind, view, slotGrid, slotLamp, springs, give, slotCam);
+            } else {
+              const drawn = give === 0 ? r : { ...r, cx: r.cx + give / slotCam.zoom };
+              const ctx = contextOf(e, st, view, slotGrid, slotLamp, springs, drawn);
+              work.resolved += 1;
+              call = "resolve";
+              G = kind.resolve(ctx);
+              call = "face";
+              const inside = insideOf(e, st, kind, G, ctx, slotCam, slotGrid);
+              work.recorded += 1;
+              call = "record";
+              R = kind.record(G, inside === void 0 ? ctx : { ...ctx, inside });
+              call = "landed";
+              const landed = face2 ? 0 : locals?.get(kind.name)?.landed?.(e) ?? 0;
+              if (landed !== st.landed) {
+                st.landed = landed;
+                deskLanded = true;
+              }
+              call = "rung";
+              const rung = kind.rung === void 0 ? 0 : rungOf(kind, e, st, slotCam);
+              call = "frame";
+              const markRow = slot === "root" ? { entity: e, frame: kind.frame?.(G) ?? rectFrame(drawn), rect: { x0: r.cx - r.w / 2, y0: r.cy - r.h / 2, x1: r.cx + r.w / 2, y1: r.cy + r.h / 2 }, selected: st.selected, locked: st.locked, grabbed: st.grabbed, resizable: st.resizable } : null;
+              st.geometry = G;
+              st.record = R;
+              st.stale = false;
+              st.give = give;
+              st.zoom = slotCam.zoom;
+              st.rung = rung;
+              st.face = face2;
+              st.markRow = markRow;
             }
-            st.geometry = G;
-            st.record = R;
-            st.stale = false;
-            st.give = give;
-            st.zoom = slotCam.zoom;
-            st.rung = kind.rung === void 0 ? 0 : rungOf(kind, e, st, slotCam);
-            st.markRow = slot === "root" ? { entity: e, frame: kind.frame?.(G) ?? rectFrame(drawn), rect: { x0: r.cx - r.w / 2, y0: r.cy - r.h / 2, x1: r.cx + r.w / 2, y1: r.cy + r.h / 2 }, selected: st.selected, locked: st.locked, grabbed: st.grabbed, resizable: st.resizable } : null;
+          } catch (err) {
+            st.geometry = null;
+            st.record = null;
+            st.inside = null;
+            st.markRow = null;
+            st.stale = true;
+            fault(kind, call, err, e);
+            continue;
           }
           const at2 = rows2.length;
-          rows2.push({ entity: e, kind: kind.name, record: R, band: st.band });
+          rows2.push({ entity: e, kind: st.kind.name, record: R, band: st.band });
           if (slot === "root" && st.markRow !== null) markRows.push(st.markRow);
           const iv = st.inside;
           if (iv !== null && portalsOn && depth < PORTAL_DEPTH && e !== skip && iv.presence > 0) {
-            cands.push({ at: at2, e, view: iv, grid: kind.insideGrid?.({ props: st.props, look: looks.get(kind.name) }, slotGrid) ?? slotGrid });
+            let inner = slotGrid;
+            try {
+              inner = kind.insideGrid?.({ props: st.props, look: looks.get(kind.name) }, slotGrid) ?? slotGrid;
+            } catch (err) {
+              fault(kind, "insideGrid", err, e);
+              continue;
+            }
+            cands.push({ at: at2, e, view: iv, grid: inner });
           }
         }
         cands.sort((a, b) => b.view.clip.hx * b.view.clip.hy - a.view.clip.hx * a.view.clip.hy);
@@ -3833,14 +4640,30 @@ function createDeskBuilder(world, opts) {
           else redressOut = { frame: redress.frame, from: redress.from, u };
         }
       }
-      const veilers = [];
-      if (locals !== void 0) {
-        for (const local of locals.values()) if (local.veils !== void 0) veilers.push(local);
+      veilers.length = 0;
+      veilerNames.length = 0;
+      if (locals !== void 0) for (const name of locals.keys()) {
+        const local = locals.get(name);
+        if (local.veils !== void 0) {
+          veilers.push(local);
+          veilerNames.push(name);
+        }
       }
-      const veiledNow = { has: (e) => {
-        for (let i = 0; i < veilers.length; i++) if (veilers[i].veils?.().has(e) === true) return true;
-        return false;
-      } };
+      const veiledNow = {
+        has: (e) => {
+          for (let i = 0; i < veilers.length; i++) {
+            const name = veilerNames[i];
+            if (faults?.missing(name) === true) continue;
+            try {
+              if (veilers[i].veils?.().has(e) === true) return true;
+            } catch (err) {
+              if (faults === void 0) throw err;
+              faults.strike(name, "veils", err, e);
+            }
+          }
+          return false;
+        }
+      };
       const handRiders = /* @__PURE__ */ new Set();
       const heldNow = heldEntity(world);
       if (heldNow !== void 0) {
@@ -3859,7 +4682,7 @@ function createDeskBuilder(world, opts) {
       let heldBuild;
       if (hand !== null) {
         const hst = world.isAlive(hand.entity) ? stateOf(hand.entity) : void 0;
-        const binding = hst?.kind.open;
+        const binding = hst === void 0 || drawerOf(hst.kind) === MISSING_OBJECT ? void 0 : hst.kind.open;
         if (hst === void 0 || binding === void 0) hand = null;
         else {
           const pin = bopts.hold;
@@ -3884,59 +4707,79 @@ function createDeskBuilder(world, opts) {
           }
           if (hand.dir < 0 && hand.p >= 1) hand = null;
           else if (hand.e > 0) {
-            const extentLocal = binding.extent({ rect: hst.rect, props: hst.props });
-            const angle = numberProp(hst.props, "angle", 0);
-            const ox = extentLocal.cx - hst.rect.cx;
-            const oy = extentLocal.cy - hst.rect.cy;
-            const ca = Math.cos(angle);
-            const sa = Math.sin(angle);
-            const extentWorld = { cx: hst.rect.cx + ca * ox - sa * oy, cy: hst.rect.cy + sa * ox + ca * oy, w: extentLocal.w, h: extentLocal.h };
-            const face2 = binding.spread === true ? binding.page?.({ entity: hand.entity, local: locals?.get(hst.kind.name) }) ?? 0 : 0;
-            const target = readingTarget(extentLocal, vpSize, binding.spread === true, face2);
-            const user = world.get(hand.entity, HeldView) ?? HELD_USER_REST;
-            const pose = heldPose(homePose(extentWorld, angle, cam), target, user, hand.e);
-            const { cam: heldCam, grow } = heldCamera(pose, hst.rect, extentLocal, cam.zoom, binding.pose === "eye", vpSize);
-            const heldView = { camX: heldCam.x, camY: heldCam.y, zoom: heldCam.zoom, width: vp.width, height: vp.height, dpr: vp.dpr };
-            const heldGrid = { ...frameGrid, mat: { ...frameGrid.mat, gobo: { ...frameGrid.mat.gobo, opacity: 0 } } };
-            const base = contextOf(hand.entity, hst, heldView, heldGrid, lampOf(heldGrid.mat.plane), false);
-            const props = typeof hst.props.angle === "number" ? { ...hst.props, angle: pose.angle } : hst.props;
-            const snap = pin !== void 0 || bopts.freeze === true;
-            const hctx = { ...base, props, held: { e: hand.e, open: openTarget, grow, snap } };
-            work.resolved += 1;
-            work.recorded += 1;
-            const G = hst.kind.resolve(hctx);
-            const R = hst.kind.record(G, hctx);
-            hst.geometry = G;
-            hst.record = R;
-            hst.stale = true;
-            hst.inside = null;
-            hst.slot = "root";
-            hst.seen = seq;
-            const openness = binding.openness?.(hctx);
-            hand.openness = openness ?? 0;
-            const settledNow = pin !== void 0 ? hand.e >= 1 : hand.dir > 0 && hand.p >= 1;
-            const coverMoving = openness !== void 0 && (openTarget ? openness < 1 - 1e-3 : openness > 1e-3);
-            if (pin === void 0 && (hand.dir < 0 || hand.p < 1 || coverMoving)) live = true;
-            const riders = [];
-            const typeId = world.get(hand.entity, PrefabId)?.id;
-            for (const rider of typeof typeId === "string" ? widgetTypeFor(world, typeId)?.riders?.(world, hand.entity) ?? [] : []) {
-              const rst = veiledNow.has(rider) ? void 0 : stateOf(rider);
-              if (rst === void 0) continue;
-              const rctx = contextOf(rider, rst, heldView, heldGrid, lampOf(heldGrid.mat.plane), false);
+            try {
+              const extentLocal = binding.extent({ rect: hst.rect, props: hst.props });
+              const angle = numberProp(hst.props, "angle", 0);
+              const ox = extentLocal.cx - hst.rect.cx;
+              const oy = extentLocal.cy - hst.rect.cy;
+              const ca = Math.cos(angle);
+              const sa = Math.sin(angle);
+              const extentWorld = { cx: hst.rect.cx + ca * ox - sa * oy, cy: hst.rect.cy + sa * ox + ca * oy, w: extentLocal.w, h: extentLocal.h };
+              const face2 = binding.spread === true ? binding.page?.({ entity: hand.entity, local: locals?.get(hst.kind.name) }) ?? 0 : 0;
+              const target = readingTarget(extentLocal, vpSize, binding.spread === true, face2, reserves);
+              const user = world.get(hand.entity, HeldView) ?? HELD_USER_REST;
+              const pose = heldPose(homePose(extentWorld, angle, cam), target, user, hand.e);
+              const { cam: heldCam, grow } = heldCamera(pose, hst.rect, extentLocal, cam.zoom, binding.pose === "eye", vpSize);
+              const heldView = { camX: heldCam.x, camY: heldCam.y, zoom: heldCam.zoom, width: vp.width, height: vp.height, dpr: vp.dpr };
+              const heldGrid = { ...frameGrid, mat: { ...frameGrid.mat, gobo: { ...frameGrid.mat.gobo, opacity: 0 } } };
+              const base = contextOf(hand.entity, hst, heldView, heldGrid, lampOf(heldGrid.mat.plane), false);
+              const props = typeof hst.props.angle === "number" ? { ...hst.props, angle: pose.angle } : hst.props;
+              const snap = pin !== void 0 || bopts.freeze === true;
+              const hctx = { ...base, props, held: { e: hand.e, open: openTarget, grow, snap } };
               work.resolved += 1;
               work.recorded += 1;
-              riders.push({ kind: rst.kind.name, record: rst.kind.record(rst.kind.resolve(rctx), rctx), key: rider });
-              handRiders.add(rider);
+              const G = hst.kind.resolve(hctx);
+              const R = hst.kind.record(G, hctx);
+              hst.geometry = G;
+              hst.record = R;
+              hst.stale = true;
+              hst.inside = null;
+              hst.slot = "root";
+              hst.seen = seq;
+              const openness = binding.openness?.(hctx);
+              hand.openness = openness ?? 0;
+              const settledNow = pin !== void 0 ? hand.e >= 1 : hand.dir > 0 && hand.p >= 1;
+              const coverMoving = openness !== void 0 && (openTarget ? openness < 1 - 1e-3 : openness > 1e-3);
+              if (pin === void 0 && (hand.dir < 0 || hand.p < 1 || coverMoving)) live = true;
+              const riders = [];
+              const typeId = world.get(hand.entity, PrefabId)?.id;
+              for (const rider of typeof typeId === "string" ? widgetTypeFor(world, typeId)?.riders?.(world, hand.entity) ?? [] : []) {
+                const rst = veiledNow.has(rider) ? void 0 : stateOf(rider);
+                if (rst === void 0) continue;
+                const rkind = drawerOf(rst.kind);
+                const rctx = contextOf(rider, rst, heldView, heldGrid, lampOf(heldGrid.mat.plane), false);
+                work.resolved += 1;
+                work.recorded += 1;
+                let record;
+                try {
+                  record = rkind.record(rkind.resolve(rctx), rctx);
+                } catch (err) {
+                  fault(rkind, "record", err, rider);
+                  continue;
+                }
+                riders.push({ kind: rst.kind.name, record, key: rider });
+                handRiders.add(rider);
+              }
+              heldBuild = {
+                entity: hand.entity,
+                e: hand.e,
+                settled: settledNow,
+                landing: hand.dir < 0,
+                frame: { ...heldFrame(pose, extentLocal, target.single, face2), settled: settledNow },
+                inputs: { object: { kind: hst.kind.name, record: R, key: hand.entity }, ...riders.length > 0 ? { riders } : {}, view: heldView, grid: heldGrid, e: hand.e, ...heldFocus(hand.e, vpSize, theme) },
+                deskSeq
+              };
+            } catch (err) {
+              const held = hand?.entity;
+              hst.geometry = null;
+              hst.record = null;
+              hst.inside = null;
+              hst.stale = true;
+              hand = null;
+              heldBuild = void 0;
+              handRiders.clear();
+              fault(hst.kind, "record", err, held);
             }
-            heldBuild = {
-              entity: hand.entity,
-              e: hand.e,
-              settled: settledNow,
-              landing: hand.dir < 0,
-              frame: { ...heldFrame(pose, extentLocal, target.single, face2), settled: settledNow },
-              inputs: { object: { kind: hst.kind.name, record: R, key: hand.entity }, ...riders.length > 0 ? { riders } : {}, view: heldView, grid: heldGrid, e: hand.e, ...heldFocus(hand.e, vpSize, theme) },
-              deskSeq
-            };
           }
         }
       }
@@ -3947,7 +4790,7 @@ function createDeskBuilder(world, opts) {
       dirtyStates.clear();
       if (locals !== void 0) {
         const check = (e, st) => {
-          const v = !st.grabbed && locals.get(st.kind.name)?.lifted?.(e) === true;
+          const v = !st.grabbed && liftedBy(st, e);
           if (v !== st.lifted) {
             st.lifted = v;
             orderDirty = true;
@@ -3975,7 +4818,7 @@ function createDeskBuilder(world, opts) {
             const st = stateOf(e);
             if (st === void 0) continue;
             st.active = true;
-            st.lifted = !st.grabbed && locals?.get(st.kind.name)?.lifted?.(e) === true;
+            st.lifted = !st.grabbed && liftedBy(st, e);
             (st.grabbed || st.lifted ? tiers[1] : tiers[0]).push(e);
           }
         });
@@ -4047,8 +4890,17 @@ function createDeskBuilder(world, opts) {
         const ctx = { entity: e, rect: g.rect, props: g.props, flux: { ...g.flux, ring: 0, fade: 1 - g.del }, look: looks.get(g.kind.name), theme, lamp: rootLamp, view: rootView, grid: frameGrid, dt, ...g.asset !== void 0 ? { asset: g.asset } : {}, ...local !== void 0 ? { local } : {} };
         work.resolved += 1;
         work.recorded += 1;
-        const G = g.kind.resolve(ctx);
-        const row = { entity: void 0, kind: g.kind.name, record: g.kind.record(G, ctx), band: g.band, ghostOf: e };
+        const gkind = drawerOf(g.kind);
+        let record;
+        try {
+          record = gkind.record(gkind.resolve(ctx), ctx);
+        } catch (err) {
+          ghosts.delete(e);
+          forget(g.kind, e);
+          fault(gkind, "record", err, e);
+          continue;
+        }
+        const row = { entity: void 0, kind: g.kind.name, record, band: g.band, ghostOf: e };
         let at2 = g.next === void 0 ? -1 : rows.findIndex((q) => q.entity === g.next);
         if (at2 < 0) {
           at2 = rows.length;
@@ -4135,7 +4987,17 @@ function createDeskBuilder(world, opts) {
       }
       const objects = rows.map((r) => ({ kind: r.kind, record: r.record, key: r.entity !== void 0 ? r.entity : -r.ghostOf }));
       const veiledSet = /* @__PURE__ */ new Set();
-      for (const local of locals?.values() ?? []) for (const e of local.veils?.() ?? []) veiledSet.add(e);
+      for (let i = 0; i < veilers.length; i++) {
+        const name = veilerNames[i];
+        const local = veilers[i];
+        if (locals?.get(name) !== local) continue;
+        try {
+          for (const e of local.veils?.() ?? []) veiledSet.add(e);
+        } catch (err) {
+          if (faults === void 0) throw err;
+          faults.strike(name, "veils", err);
+        }
+      }
       veiledList = veiledSet;
       const ruler2 = frameGrid.mat.ruler;
       const marked = marks.frame({ rows: markRows, cam, view: vp, dt, night: theme.name === "dark", rulers: ruler2.on ? { margin: ruler2.margin, band: ruler2.band } : null });
@@ -4225,7 +5087,7 @@ function createDeskBuilder(world, opts) {
           const st = states.get(e);
           if (st === void 0) continue;
           if (st.insert) {
-            landing.push({ type: st.widget.type, rect: st.rect, lift: st.lift, liftV: st.liftV });
+            landing.push({ type: st.widget?.type ?? "", rect: st.rect, lift: st.lift, liftV: st.liftV });
             forget(st.kind, e);
           } else {
             ghostOf(e, st);
@@ -4332,8 +5194,25 @@ function createDeskBuilder(world, opts) {
     heldPart(e, x, y) {
       const w = heldToWorld(e, x, y);
       const st = states.get(e);
-      if (w === void 0 || st === void 0 || st.geometry === null) return null;
-      return st.kind.hit(st.geometry, w[0], w[1]);
+      if (w === void 0 || st === void 0 || st.geometry === null || st.face) return null;
+      try {
+        return st.kind.hit(st.geometry, w[0], w[1]);
+      } catch (err) {
+        fault(st.kind, "hit", err, e);
+        return null;
+      }
+    },
+    hitAt(e, wx, wy) {
+      const st = states.get(e);
+      if (st === void 0 || st.geometry === null) return void 0;
+      if (st.face) return MISSING_OBJECT.hit(st.geometry, wx, wy);
+      if (drawerOf(st.kind) === MISSING_OBJECT) return void 0;
+      try {
+        return st.kind.hit(st.geometry, wx, wy);
+      } catch (err) {
+        fault(st.kind, "hit", err, e);
+        return null;
+      }
     },
     stats: () => stats,
     dispose() {
@@ -4396,6 +5275,14 @@ function createRasterBudget(cap, floor = Math.floor(cap * BUDGET_FLOOR)) {
       const ent = entries.get(k);
       if (ent !== void 0) drop(k, ent);
     },
+    forget(owner) {
+      let bytes = 0;
+      for (const [k, ent] of [...entries]) if (ent.owner === owner) {
+        drop(k, ent);
+        bytes += ent.bytes;
+      }
+      return bytes;
+    },
     trim(keep2) {
       const limit = room();
       if (cached <= limit) return 0;
@@ -4551,6 +5438,10 @@ function createPickSource(builder, opts = {}) {
       if (G === void 0 || kind === void 0) return void 0;
       const hp = builder.heldPoint?.(e, wx, wy);
       const [x, y] = hp ?? [wx, wy];
+      if (builder.hitAt !== void 0) {
+        const part = builder.hitAt(e, x, y);
+        return part === void 0 ? void 0 : part ?? "outside";
+      }
       return kind.hit(G, x, y) ?? "outside";
     },
     live: () => builder.live() || opts.moving?.() === true
@@ -4559,7 +5450,8 @@ function createPickSource(builder, opts = {}) {
 
 // ../desk/src/tray/flux.ts
 var EPS2 = 1e-4;
-function createTrayFlux() {
+function createTrayFlux(opts = {}) {
+  const foot = opts.foot ?? 0;
   let facts = null;
   let p = 0;
   let from = 0;
@@ -4633,8 +5525,8 @@ function createTrayFlux() {
       const pp = P?.p ?? p;
       const pb = P?.band ?? shown;
       const rect = drawerRect(vw, vh, pp);
-      drawn = { x: rect.x, y: rect.y, w: rect.w, h: rect.h, p: pp, max: scrollRange(vw, vh, f.bottom ?? 0), pitch: DRAWER.pitch, scroll: f.scroll + pb, face: rect.h, head: DRAWER.arris + DRAWER.header };
-      return { p: pp, scroll: f.scroll + pb };
+      drawn = { x: rect.x, y: rect.y, w: rect.w, h: rect.h, p: pp, max: scrollRange(vw, vh, f.bottom ?? 0, foot), pitch: DRAWER.pitch, scroll: f.scroll + pb, face: rect.h, head: DRAWER.arris + DRAWER.header, ...foot > 0 ? { foot } : {} };
+      return { p: pp, scroll: f.scroll + pb, ...foot > 0 ? { foot } : {} };
     },
     live: () => moving && pinned === null,
     frame: () => drawn,
@@ -4652,12 +5544,15 @@ var localPointersQ2 = defineQuery([Pointer, LocalPointer, PointerScreen]);
 var trayQ = defineQuery([Tray]);
 var insertQ = defineQuery([InsertGhost, Position, Size]);
 function createDeskReflector(opts) {
-  const { world, builder, ambient } = opts;
+  const { world, builder, ambient, faults } = opts;
   const maxDpr = opts.maxDpr ?? 2;
   let theme = opts.theme;
   let palette = opts.palette;
   let grid = opts.grid ?? DEFAULT_GRID;
-  let looks = looksOf(opts.kinds, palette, theme);
+  const lookKinds = () => faults === void 0 || faults.size === 0 ? opts.kinds : opts.kinds.filter((k) => !faults.missing(k.name));
+  const mountedKinds = new Set(opts.kinds.map((k) => k.name));
+  const kindOn = (kind) => kind === void 0 || faults === void 0 || mountedKinds.has(kind.name) ? kind : void 0;
+  let looks = looksOf(lookKinds(), palette, theme);
   let dirty = true;
   let disposed = false;
   let redraws = 0;
@@ -4682,7 +5577,7 @@ function createDeskReflector(opts) {
   let gridGen = 0;
   let pinGen = 0;
   const wakes = { world: 0, removed: 0, reset: 0, order: 0, hover: 0, marks: 0, camera: 0, viewport: 0, nav: 0, theme: 0, grid: 0, pin: 0, ambient: 0, live: 0, ink: 0, tray: 0 };
-  const tray = createTrayFlux();
+  const tray = createTrayFlux(opts.tray?.foot !== void 0 ? { foot: opts.tray.foot } : {});
   let drawnSpecimens = [];
   const carry2 = createTrayCarry();
   let drawnCarried = [];
@@ -4810,11 +5705,11 @@ function createDeskReflector(opts) {
       let trayed = tray.step(now, vp.w, vp.h);
       drawnSpecimens = [];
       if (trayed !== void 0 && trayed.p > 0 && tray.pinned()?.bare !== true) {
-        const specimens = readSpecimens(w, te, opts.locals);
+        const specimens = readSpecimens(w, te, opts.locals, kindOn);
         if (specimens.length > 0) {
           ground.warmTray(specimens.map((q) => [q.type, q.kind.name]), trayLanded);
           for (const q of specimens) if (q.local !== void 0) faced.set(q.key, q.local);
-          drawnSpecimens = specimenFrames(specimens, { rect: drawerRect(vp.w, vp.h, trayed.p), scroll: trayed.scroll }, { view: { width: vp.w, height: vp.h, dpr }, theme, grid, looks, lift: (t) => tray.lift(t) });
+          drawnSpecimens = specimenFrames(specimens, { rect: drawerRect(vp.w, vp.h, trayed.p), scroll: trayed.scroll, ...trayed.foot !== void 0 ? { foot: trayed.foot } : {} }, { view: { width: vp.w, height: vp.h, dpr }, theme, grid, looks, lift: (t) => tray.lift(t), ...faults !== void 0 ? { faults } : {} });
           trayed = { ...trayed, specimens: drawnSpecimens };
         }
       }
@@ -4846,11 +5741,11 @@ function createDeskReflector(opts) {
       drawnCarried = [];
       if (trayed !== void 0 && poses.length > 0) {
         const L = lampOf(built.grid.mat.plane);
-        const env = { view: { width: vp.w, height: vp.h, dpr }, theme, grid, looks };
+        const env = { view: { width: vp.w, height: vp.h, dpr }, theme, grid, looks, ...faults !== void 0 ? { faults } : {} };
         const made = [];
         for (const pose of poses) {
           const widget = widgetTypeFor(w, pose.type);
-          const kind = objectKindOf(widget);
+          const kind = kindOn(objectKindOf(widget));
           if (widget === void 0 || kind === void 0) continue;
           const local = opts.locals?.get(kind.name);
           if (pose.ghost !== void 0) {
@@ -4859,7 +5754,8 @@ function createDeskReflector(opts) {
             const size = w.get(g, Size);
             if (at2 === void 0 || size === void 0) continue;
             const r = rectOf(at2, size);
-            made.push(carriedFrame(pose, { kind, rect: { x: r.cx - r.w / 2, y: r.cy - r.h / 2, w: r.w, h: r.h }, props: propsOf(w, g, widget), key: g, lamp: L, ...local !== void 0 ? { local } : {} }, env));
+            const frame2 = carriedFrame(pose, { kind, rect: { x: r.cx - r.w / 2, y: r.cy - r.h / 2, w: r.w, h: r.h }, props: propsOf(w, g, widget), key: g, lamp: L, ...local !== void 0 ? { local } : {} }, env);
+            if (frame2 !== void 0) made.push(frame2);
             continue;
           }
           const n = widget.defaultSize;
@@ -4868,10 +5764,11 @@ function createDeskReflector(opts) {
           const cy = cam.y + pose.py / cam.zoom - (pose.v - 0.5) * n.h;
           const key = -(1073741824 + pose.id);
           if (copyLocal !== void 0) faced.set(key, copyLocal);
-          made.push(carriedFrame(pose, { kind, rect: { x: -n.w / 2, y: -n.h / 2, w: n.w, h: n.h }, props: takenProps(widget), key, lamp: { x: L.x - cx, y: L.y - cy, h: L.h }, ...copyLocal !== void 0 ? { local: copyLocal } : {} }, env));
+          const frame = carriedFrame(pose, { kind, rect: { x: -n.w / 2, y: -n.h / 2, w: n.w, h: n.h }, props: takenProps(widget), key, lamp: { x: L.x - cx, y: L.y - cy, h: L.h }, ...copyLocal !== void 0 ? { local: copyLocal } : {} }, env);
+          if (frame !== void 0) made.push(frame);
         }
         ground.warmTray(carry2.types().flatMap((t) => {
-          const k = objectKindOf(widgetTypeFor(w, t));
+          const k = kindOn(objectKindOf(widgetTypeFor(w, t)));
           return k === void 0 ? [] : [[carrySlot(t), k.name]];
         }), trayLanded);
         drawnCarried = made;
@@ -4935,7 +5832,7 @@ function createDeskReflector(opts) {
     setTheme(t, p) {
       theme = t;
       if (p !== void 0) palette = p;
-      looks = looksOf(opts.kinds, palette, theme);
+      looks = looksOf(lookKinds(), palette, theme);
       dirty = true;
       wakes.theme += 1;
       themeGen += 1;
@@ -4987,14 +5884,14 @@ function createDeskReflector(opts) {
     }
   };
 }
-function readSpecimens(w, tray, locals) {
+function readSpecimens(w, tray, locals, on) {
   if (tray === void 0) return [];
   const out = [];
   for (const e of specimensOf(w, tray)) {
     const type = w.get(e, PrefabId)?.id;
     if (typeof type !== "string") continue;
     const widget = widgetTypeFor(w, type);
-    const kind = objectKindOf(widget);
+    const kind = on(objectKindOf(widget));
     const entry = widget?.tray;
     const at2 = w.get(e, Position);
     const size = w.get(e, Size);
@@ -5323,6 +6220,7 @@ function createDeskEditor(opts) {
     },
     placement: () => placed,
     dispose() {
+      end();
       if (idle !== void 0) clearTimeout(idle);
       lent = void 0;
       el.removeEventListener("input", onInput);
@@ -6282,20 +7180,56 @@ function kindsOf(types, extra) {
   for (const k of extra) if (!byName.has(k.name)) byName.set(k.name, k);
   return { kinds: [...byName.values()], objectKinds };
 }
+function bitmapOf(c) {
+  const n = c.width * c.height * 4;
+  const rgba = new Uint8ClampedArray(n);
+  const b = c.bytes;
+  const bgra = c.format.startsWith("bgra");
+  for (let i = 0; i < n; i += 4) {
+    rgba[i] = b[bgra ? i + 2 : i];
+    rgba[i + 1] = b[i + 1];
+    rgba[i + 2] = b[bgra ? i : i + 2];
+    rgba[i + 3] = 255;
+  }
+  return createImageBitmap(new ImageData(rgba, c.width, c.height), { premultiplyAlpha: "none", colorSpaceConversion: "none" });
+}
 var toldAwake = /* @__PURE__ */ new Set();
 function tellAwake(kind) {
   if (toldAwake.has(kind)) return;
   toldAwake.add(kind);
   console.warn(`[ice] desk: the kind "${kind}" declares a local \`tick\` and no \`due\` \u2014 it is due every frame, so the desk never sleeps. Declare \`KindLocal.due(now)\`: now while it moves, a later time, or Infinity until a fact, an input or \`KindHost.wake\` moves it (design-016 K7a).`);
 }
+var toldAnchor = /* @__PURE__ */ new Set();
+function tellAnchor(kind, call, err) {
+  const key = `${call} ${kind}`;
+  if (toldAnchor.has(key)) return;
+  toldAnchor.add(key);
+  const kept = call === "readout" ? "no word (petition I22)" : "no swatches (petition I24)";
+  console.error(`[ice] desk: the kind "${kind}"'s \`open.${call}\` threw \u2014 the anchor carries its held tools and ${kept}; said once a page`, err);
+}
+function hostNumber(name, v) {
+  if (v === void 0) return void 0;
+  if (typeof v !== "number" || !Number.isFinite(v) || v < 0) throw new Error(`[ice] deskLayer: \`${name}\` is ${String(v)} \u2014 a finite number \u2265 0 (CSS px, or ms for a time)`);
+  return v;
+}
+function holdOf(hold) {
+  const top = hostNumber("hold.top", hold?.top);
+  const band2 = hostNumber("hold.band", hold?.band);
+  return { reserves: top === void 0 && band2 === void 0 ? void 0 : { top: top ?? HOLD.top, band: band2 ?? HOLD.band }, travelMs: hostNumber("hold.travelMs", hold?.travelMs) };
+}
 function deskLayer(opts) {
   return (ctx) => {
+    const mountedAt = performance.now();
+    const boot = {};
     const { host, world } = ctx;
     const doc = host.container.ownerDocument;
     const view = doc.defaultView;
     const types = /* @__PURE__ */ new Set([...(ctx.catalog?.widgetTypes() ?? []).filter((t) => t.object !== void 0), ...opts.objects ?? []]);
     const { kinds, objectKinds } = kindsOf([...types], opts.kinds ?? []);
     looksOf(objectKinds, opts.palette, opts.theme);
+    const hold = holdOf(opts.hold);
+    const foot = hostNumber("tray.foot", opts.tray?.foot);
+    const cursors = opts.cursors !== false;
     const canvas = doc.createElement("canvas");
     canvas.style.position = "absolute";
     canvas.style.left = "0";
@@ -6315,9 +7249,11 @@ function deskLayer(opts) {
     let profiler;
     let status = { state: "pending" };
     const statusHeard = /* @__PURE__ */ new Set();
+    const faults = createKindFaults();
     const setStatus = (next) => {
-      status = next;
-      for (const l of [...statusHeard]) l(next);
+      const { faults: _was, ...rest } = next;
+      status = faults.size > 0 ? { ...rest, faults: faults.list() } : rest;
+      for (const l of [...statusHeard]) l(status);
     };
     let disposed = false;
     let ended = false;
@@ -6365,21 +7301,51 @@ function deskLayer(opts) {
     }
     const keeps = (owner, key) => locals.get(owner)?.keeps?.(key) ?? false;
     const readMarquee = ctx.readMarquee;
-    const builder = createDeskBuilder(world, { objects: [...types], locals, ...opts.springs !== void 0 ? { springs: opts.springs } : {}, ...readMarquee !== void 0 ? { marquee: readMarquee } : {}, ...ctx.spatial !== void 0 ? { spatial: ctx.spatial } : {} });
+    const builder = createDeskBuilder(world, { objects: [...types], locals, faults, ...opts.springs !== void 0 ? { springs: opts.springs } : {}, ...readMarquee !== void 0 ? { marquee: readMarquee } : {}, ...ctx.spatial !== void 0 ? { spatial: ctx.spatial } : {}, ...hold.reserves !== void 0 ? { hold: hold.reserves } : {} });
     const typeNamed = new Map([...types].map((t) => [t.type, t]));
     const menuOf = (e) => {
       const id3 = world.isAlive(e) ? world.get(e, PrefabId)?.id : void 0;
       return typeof id3 === "string" ? typeNamed.get(id3)?.menu ?? [] : [];
     };
+    const propsOf2 = (e) => {
+      const id3 = world.isAlive(e) ? world.get(e, PrefabId)?.id : void 0;
+      const props = {};
+      for (const g of (typeof id3 === "string" ? typeNamed.get(id3)?.groups : void 0) ?? []) Object.assign(props, world.get(e, g.component) ?? {});
+      return props;
+    };
+    const readoutOf = (kind, e) => {
+      const r = kind?.open?.readout;
+      if (r === void 0 || kind === void 0) return void 0;
+      let word = r;
+      if (typeof r === "function") {
+        try {
+          word = r({ world, entity: e, props: () => propsOf2(e), local: locals.get(kind.name) });
+        } catch (err) {
+          tellAnchor(kind.name, "readout", err);
+          return void 0;
+        }
+      }
+      return typeof word === "string" && word.length > 0 ? word : void 0;
+    };
+    const swatchesOf = (kind) => {
+      if (kind?.open?.swatches === void 0) return {};
+      try {
+        return kind.open.swatches(compose2.look(kind.name));
+      } catch (err) {
+        tellAnchor(kind.name, "swatches", err);
+        return {};
+      }
+    };
     const anchorOf = () => {
       const a = builder.anchor();
       if (trayOpen(world)) return { ...a, box: null, count: 0 };
       const h = builder.hand();
       if (h === void 0) return withKindActs(a, selectedEntities(world), menuOf);
       const kind = builder.kindOf(h.entity);
-      const swatches = kind?.open?.swatches?.(compose2.look(kind.name)) ?? {};
+      const swatches = swatchesOf(kind);
       const active = world.isAlive(h.entity) ? world.get(h.entity, HeldTool)?.id ?? "" : "";
-      return { ...a, held: { tools: heldSlots(kind?.open?.tools ?? [], swatches), active, landing: h.landing, settled: h.settled } };
+      const readout = readoutOf(kind, h.entity);
+      return { ...a, held: { tools: heldSlots(kind?.open?.tools ?? [], swatches), active, landing: h.landing, settled: h.settled, ...hold.travelMs !== void 0 ? { travelMs: hold.travelMs } : {}, ...readout !== void 0 ? { readout } : {} } };
     };
     const listeners = /* @__PURE__ */ new Set();
     let published = "";
@@ -6413,15 +7379,28 @@ function deskLayer(opts) {
       trayPublished = key;
       for (const l of [...trayListeners]) l();
     };
+    let presenting = false;
+    const firstFrame = () => {
+      if (presenting) return;
+      presenting = true;
+      const queue = drawDevice?.queue;
+      if (typeof queue?.onSubmittedWorkDone !== "function") return;
+      queue.onSubmittedWorkDone().then(() => {
+        boot.presented ??= performance.now() - mountedAt;
+      }, () => {
+      });
+    };
     const compose2 = createDeskReflector({
       onFrame: () => {
         publish();
         publishTray();
+        firstFrame();
       },
       world,
       builder,
       kinds: objectKinds,
       ambient,
+      faults,
       ground: () => ground,
       attach: { resize: (w, h) => {
         if (canvas.width !== w || canvas.height !== h) {
@@ -6434,6 +7413,7 @@ function deskLayer(opts) {
       grid,
       locals,
       ...opts.maxDpr !== void 0 ? { maxDpr: opts.maxDpr } : {},
+      ...foot !== void 0 ? { tray: { foot } } : {},
       ...opts.name !== void 0 ? { name: opts.name } : {},
       // a frame asked for outside the flush — a pin, an ink landing, the ground arriving, a theme: a sleeping loop wakes (K7a)
       onWake: (reason) => frame?.wake(`desk:${reason}`)
@@ -6441,6 +7421,8 @@ function deskLayer(opts) {
     motionQuery?.addEventListener("change", syncMotion);
     const docs = opts.docs ?? NO_DOCS;
     const drivers = /* @__PURE__ */ new Map();
+    const driverKinds = /* @__PURE__ */ new Map();
+    const parked = [];
     const ofKind = (e, name) => builder.kindOf(e)?.name === name && !world.has(e, InsertGhost);
     const kindNamed = (name) => objectKinds.some((k) => k.name === name) ? (e) => ofKind(e, name) : void 0;
     const providing = (key) => [...types].some((t) => t.provides.includes(key)) ? (e) => {
@@ -6465,7 +7447,10 @@ function deskLayer(opts) {
         refused: (e) => builder.meetTape(e),
         wake: () => compose2.wake("ink")
       });
-      if (d !== void 0) drivers.set(t.type, d);
+      if (d !== void 0) {
+        drivers.set(t.type, d);
+        driverKinds.set(t.type, k.name);
+      }
     }
     const driver = (type) => drivers.get(type);
     const textParts = [];
@@ -6516,11 +7501,17 @@ function deskLayer(opts) {
         restless.clear();
         for (const [name, local] of locals) {
           if (local.tick === void 0) continue;
-          if (timeAlone && !woken.has(name) && (local.due?.(now) ?? now) > now) continue;
-          kindTicks[name] = (kindTicks[name] ?? 0) + 1;
-          if (local.tick(now)) {
-            want = true;
-            restless.add(name);
+          let call = "due";
+          try {
+            if (timeAlone && !woken.has(name) && (local.due?.(now) ?? now) > now) continue;
+            kindTicks[name] = (kindTicks[name] ?? 0) + 1;
+            call = "tick";
+            if (local.tick(now)) {
+              want = true;
+              restless.add(name);
+            }
+          } catch (err) {
+            faults.strike(name, call, err);
           }
         }
         woken.clear();
@@ -6545,11 +7536,22 @@ function deskLayer(opts) {
         profiler?.flushed(spent);
       }
     };
+    const dueOf = (local, now) => {
+      try {
+        return local.due?.(now) ?? now;
+      } catch (err) {
+        for (const [name, l] of locals) if (l === local) {
+          faults.strike(name, "due", err);
+          break;
+        }
+        return Number.POSITIVE_INFINITY;
+      }
+    };
     const deskDue = (now) => {
       let t = following || woken.size > 0 ? now : compose2.due(now);
       for (const local of locals.values()) {
         if (local.tick === void 0) continue;
-        const d = local.due?.(now) ?? now;
+        const d = dueOf(local, now);
         if (d < t) t = d;
       }
       const tray = ground?.trayIdleAt() ?? Number.POSITIVE_INFINITY;
@@ -6559,6 +7561,31 @@ function deskLayer(opts) {
     };
     const stopWake = frame?.wakeWhen("desk", deskDue);
     const stopText = opts.text?.onVersion?.(() => frame?.wake("desk:text"));
+    const retire = (name) => {
+      const local = locals.get(name);
+      locals.delete(name);
+      woken.delete(name);
+      for (const [type, kind] of driverKinds) {
+        const d = drivers.get(type);
+        if (kind === name && d !== void 0) {
+          drivers.delete(type);
+          parked.push(d);
+        }
+      }
+      rasters.clear(name);
+      budget.forget(name);
+      try {
+        local?.dispose?.();
+      } catch (err) {
+        console.error(`[ice] desk: the missing kind "${name}"'s desk state threw in its dispose`, err);
+      }
+      ground?.quarantine(name);
+      compose2.wake("ink");
+    };
+    faults.subscribe((f) => {
+      retire(f.kind);
+      if (status.state !== "pending") setStatus(status);
+    });
     const pick = createPickSource(builder, { moving: () => moving });
     const framePick = ctx.framePick;
     if (framePick !== void 0) framePick.current = pick;
@@ -6605,27 +7632,31 @@ function deskLayer(opts) {
     };
     const shared = ctx.gpu;
     const device = shared !== void 0 ? Promise.resolve(adopt(shared.adapter, shared.device, events)) : gpu === void 0 ? Promise.reject(new Error("WebGPU is unavailable here (no navigator.gpu)")) : acquire({ gpu, label: "desk", ...events });
-    const boot = device.then(async (g) => {
+    const booted = device.then(async (g) => {
       if (disposed) {
         if (shared === void 0) g.device.destroy();
         throw new Error("disposed before the device arrived");
       }
+      boot.device = performance.now() - mountedAt;
       drawDevice = g.device;
       if (shared === void 0) ownDevice = g.device;
       if (opts.gpuLedger === true) ledger = instrumentMemory(g.device);
       opts.onDevice?.(g.device);
-      const made = await Ground.create({ device: g.device, surface: surface(g.device, canvas), mat: matShaders(shaderText(MAT_SHADER_FILES)), kinds, marks: marksShaders(shaderText(MARKS_SHADER_FILES)), hold: holdShaders(shaderText(HOLD_SHADER_FILES)), tray: trayShaders(shaderText) });
+      const made = await Ground.create({ device: g.device, surface: surface(g.device, canvas), mat: matShaders(shaderText(MAT_SHADER_FILES)), kinds, marks: marksShaders(shaderText(MARKS_SHADER_FILES)), hold: holdShaders(shaderText(HOLD_SHADER_FILES)), tray: trayShaders(shaderText), ...events.onError !== void 0 ? { onError: events.onError } : {} });
       if (disposed || ended) {
         made.dispose();
         return;
       }
+      boot.compiled = performance.now() - mountedAt;
       made.mat.setNoise(blueNoise());
       made.grid = grid;
+      for (const f of made.faults()) faults.refuse(f.kind, f.reason);
+      for (const f of faults.list()) made.quarantine(f.kind);
       ground = made;
       if (status.state === "pending") setStatus({ state: "ready" });
       compose2.ready();
     });
-    boot.catch((e) => {
+    booted.catch((e) => {
       if (!disposed) fail("no desk \u2014 the adapter, the device or the pipelines were refused", e);
     });
     const setGrid = (next) => {
@@ -6633,8 +7664,42 @@ function deskLayer(opts) {
       if (ground !== null) ground.grid = next;
       compose2.configureGrid(next);
     };
+    let capturing = null;
+    let captures = Promise.resolve();
+    const captureKey = (o) => JSON.stringify([o.scale ?? 1, o.rect === void 0 ? null : [o.rect.x, o.rect.y, o.rect.width, o.rect.height]]);
+    const capture = (opts2 = {}) => {
+      checkCapture(opts2);
+      const key = captureKey(opts2);
+      const asked2 = compose2.lastInputs();
+      const same = capturing;
+      if (same !== null && same.key === key && same.inputs === asked2) return same.promise;
+      const run = captures.then(async () => {
+        const g = ground;
+        const inputs = compose2.lastInputs();
+        if (disposed || ended || g === null || status.state !== "ready" || inputs === null) return void 0;
+        const bytes = await g.capture(inputs, opts2);
+        return bytes === void 0 ? void 0 : await bitmapOf(bytes);
+      }).finally(() => {
+        if (capturing?.promise === run) capturing = null;
+      });
+      capturing = { key, inputs: asked2, promise: run };
+      captures = run.catch(() => void 0);
+      return run;
+    };
+    const pickAt = ctx.pickAt;
+    const pickPoint = (point) => {
+      if (typeof point?.x !== "number" || typeof point.y !== "number" || !Number.isFinite(point.x) || !Number.isFinite(point.y)) {
+        throw new Error(`[ice] desk: pick \u2014 the point is ${JSON.stringify(point) ?? String(point)}: { x, y } in CSS px of the view, two finite numbers`);
+      }
+      if (pickAt === void 0 || ground === null || compose2.lastInputs() === null || heldEntity(world) !== void 0) return null;
+      const hit = pickAt(point.x, point.y);
+      const type = hit === void 0 ? void 0 : world.get(hit.entity, PrefabId)?.id;
+      if (hit === void 0 || typeof type !== "string") return null;
+      return { entity: hit.entity, type, canvas: frameParent(world) ?? NO_ENTITY, part: hit.part };
+    };
     return {
       reflector,
+      cursors,
       canvas,
       available: () => ground !== null && (status.state === "ready" || status.state === "degraded"),
       status: () => status,
@@ -6647,6 +7712,8 @@ function deskLayer(opts) {
       device: () => drawDevice ?? void 0,
       ground: () => ground,
       setTheme: (t, p) => compose2.setTheme(t, p),
+      capture,
+      pick: pickPoint,
       configureMat: (mat) => setGrid({ ...grid, mat: { ...grid.mat, ...mat, ...mat.gobo !== void 0 ? { gobo: { ...grid.mat.gobo, ...mat.gobo } } : {}, ...mat.ruler !== void 0 ? { ruler: { ...grid.mat.ruler, ...mat.ruler } } : {} } }),
       configureFadeIn: (fadeIn) => setGrid({ ...grid, fadeIn }),
       setPlate(name, bytes) {
@@ -6690,6 +7757,7 @@ function deskLayer(opts) {
       hand: () => builder.hand(),
       setPortals: (on) => compose2.pinBuild({ portals: on }),
       tuneLaw(kind, law) {
+        if (faults.missing(kind)) return;
         for (const t of types) {
           const k = objectKindOf(t);
           if (k?.name === kind) k.tune?.(law);
@@ -6751,7 +7819,7 @@ function deskLayer(opts) {
         }
         return profiler;
       },
-      perf: () => ({ ...perf, kindTicks: { ...kindTicks } }),
+      perf: () => ({ ...perf, kindTicks: { ...kindTicks }, boot: { ...boot } }),
       memory: () => budget.stats(),
       rasters: () => rasters.stats(),
       gpuMemory: () => ledger,
@@ -6768,7 +7836,8 @@ function deskLayer(opts) {
       wakes: () => compose2.wakes(),
       due: (now) => {
         const kinds2 = {};
-        for (const [name, local] of locals) if (local.tick !== void 0) kinds2[name] = local.due?.(now) ?? now;
+        for (const [name, local] of locals) if (local.tick !== void 0) kinds2[name] = dueOf(local, now);
+        for (const f of faults.list()) kinds2[f.kind] = KIND_MISSING;
         const busy = [];
         for (const [type, d] of drivers) if (d.idle?.() !== true) busy.push(type);
         return { at: deskDue(now), reflector: compose2.due(now), drivers: following ? now : Number.POSITIVE_INFINITY, following: busy, woken: [...woken], kinds: kinds2, tray: ground?.trayIdleAt() ?? Number.POSITIVE_INFINITY, rasters: rasters.size > 0 ? now : Number.POSITIVE_INFINITY };
@@ -6780,7 +7849,7 @@ function deskLayer(opts) {
       dirty: () => {
         if (compose2.dirty() || woken.size > 0) return true;
         const now = performance.now();
-        for (const local of locals.values()) if (local.tick !== void 0 && (local.due?.(now) ?? now) <= now) return true;
+        for (const local of locals.values()) if (local.tick !== void 0 && dueOf(local, now) <= now) return true;
         return false;
       },
       builder,
@@ -6843,7 +7912,7 @@ function deskLayer(opts) {
         listeners.clear();
         trayListeners.clear();
         statusHeard.clear();
-        for (const d of drivers.values()) d.dispose?.();
+        for (const d of [...drivers.values(), ...parked]) d.dispose?.();
         editor.dispose();
         for (const local of locals.values()) local.dispose?.();
         motionQuery?.removeEventListener("change", syncMotion);
@@ -7097,219 +8166,16 @@ async function ablateKinds(a, opts = {}) {
   return { frames, rounds, base: baseS, control: sampled(c), aa: median(c) - baseS.median, noise, kinds: out, samples: Object.fromEntries(ms) };
 }
 
-// ../desk/src/engine/records.ts
-var DEFAULT_MAX = 65536;
-var GAP = 4;
-var NONE = { aux: 0, blockN: 0 };
-function createRecordStore(opts) {
-  const { device, def, label, pack } = opts;
-  const max = opts.max ?? DEFAULT_MAX;
-  const blocksDef = opts.blocks;
-  const per = blocksDef?.per ?? 0;
-  let capacity = Math.max(1, Math.min(opts.capacity, max));
-  let cpu = def.alloc(capacity);
-  let gpu = storageBuffer(device, def.size * capacity, label);
-  let blockCpu = blocksDef ? blocksDef.def.alloc(capacity * per) : null;
-  let blockGpu = blocksDef ? storageBuffer(device, blocksDef.def.size * capacity * per, blocksDef.label) : null;
-  let orderCpu = new Uint32Array(capacity);
-  let orderGpu = storageBuffer(device, 4 * capacity, `${label} order`);
-  let version = 0;
-  let grown = 0;
-  const byKey = /* @__PURE__ */ new Map();
-  let bySlot = new Array(capacity).fill(null);
-  const free = [];
-  let next = 0;
-  let gen = 0;
-  let lastKeys = null;
-  let prevOrder = [];
-  let count = 0;
-  const dirty = [];
-  let written = 0;
-  let bytes = 0;
-  let orderWrites = 0;
-  const grow = () => {
-    if (capacity >= max) throw new Error(`${label}: ${capacity} record slots is the most this store grows to`);
-    const was = capacity;
-    capacity = Math.min(capacity * 2, max);
-    const nextCpu = def.alloc(capacity);
-    new Uint8Array(nextCpu.bytes).set(new Uint8Array(cpu.bytes));
-    cpu = nextCpu;
-    gpu.destroy();
-    gpu = storageBuffer(device, def.size * capacity, label);
-    if (blocksDef && blockCpu && blockGpu) {
-      const nextBlocks = blocksDef.def.alloc(capacity * per);
-      new Uint8Array(nextBlocks.bytes).set(new Uint8Array(blockCpu.bytes));
-      blockCpu = nextBlocks;
-      blockGpu.destroy();
-      blockGpu = storageBuffer(device, blocksDef.def.size * capacity * per, blocksDef.label);
-    }
-    const nextOrder = new Uint32Array(capacity);
-    nextOrder.set(orderCpu);
-    orderCpu = nextOrder;
-    orderGpu.destroy();
-    orderGpu = storageBuffer(device, 4 * capacity, `${label} order`);
-    const nextBySlot = new Array(capacity).fill(null);
-    for (let i = 0; i < was; i++) nextBySlot[i] = bySlot[i] ?? null;
-    bySlot = nextBySlot;
-    version += 1;
-    grown += 1;
-  };
-  let grew = false;
-  const alloc = () => {
-    const reused = free.pop();
-    if (reused !== void 0) return reused;
-    if (next === capacity) {
-      grow();
-      grew = true;
-    }
-    return next++;
-  };
-  const release = (ent) => {
-    byKey.delete(ent.key);
-    bySlot[ent.slot] = null;
-    free.push(ent.slot);
-  };
-  const resetAll = () => {
-    bySlot.fill(null);
-    byKey.clear();
-    free.length = 0;
-    next = 0;
-  };
-  const packInto = (ent, record, aux) => {
-    ent.record = record;
-    ent.aux = aux;
-    ent.blockN = pack(record, aux, cpu, ent.slot, blockCpu, ent.slot * per);
-    dirty.push(ent.slot);
-  };
-  const runs = () => {
-    dirty.sort((a, b) => a - b);
-    const out = [];
-    for (const s of dirty) {
-      const last = out[out.length - 1];
-      if (last !== void 0 && s <= last[1] + 1 + GAP) {
-        if (s > last[1]) last[1] = s;
-      } else out.push([s, s]);
-    }
-    return out;
-  };
-  const upload = (n, orderMoved) => {
-    let rewriteOrder = orderMoved;
-    if (grew) {
-      grew = false;
-      if (next > 0) {
-        device.queue.writeBuffer(gpu, 0, cpu.bytes, 0, next * def.size);
-        bytes += next * def.size;
-      }
-      if (blocksDef && blockCpu && blockGpu && next > 0) {
-        device.queue.writeBuffer(blockGpu, 0, blockCpu.bytes, 0, next * per * blocksDef.def.size);
-        bytes += next * per * blocksDef.def.size;
-      }
-      written += dirty.length;
-      dirty.length = 0;
-      rewriteOrder = true;
-    } else if (dirty.length > 0) {
-      for (const [a, b] of runs()) {
-        const n0 = b - a + 1;
-        device.queue.writeBuffer(gpu, a * def.size, cpu.bytes, a * def.size, n0 * def.size);
-        bytes += n0 * def.size;
-      }
-      if (blocksDef && blockCpu && blockGpu) {
-        const bsize = blocksDef.def.size;
-        for (const s of dirty) {
-          const ent = bySlot[s];
-          if (!ent || ent.blockN === 0) continue;
-          device.queue.writeBuffer(blockGpu, s * per * bsize, blockCpu.bytes, s * per * bsize, ent.blockN * bsize);
-          bytes += ent.blockN * bsize;
-        }
-      }
-      written += dirty.length;
-      dirty.length = 0;
-    }
-    if (rewriteOrder) {
-      if (n > 0) device.queue.writeBuffer(orderGpu, 0, orderCpu, 0, n);
-      orderWrites += 1;
-      prevOrder = Array.from(orderCpu.subarray(0, n));
-    }
-  };
-  return {
-    get records() {
-      return gpu;
-    },
-    get order() {
-      return orderGpu;
-    },
-    get blocks() {
-      return blockGpu;
-    },
-    get version() {
-      return version;
-    },
-    prepare(records, keys, aux) {
-      gen += 1;
-      const n = records.length;
-      let orderChanged = n !== prevOrder.length;
-      if (keys === void 0) {
-        resetAll();
-        lastKeys = null;
-        for (let i = 0; i < n; i++) {
-          const slot = alloc();
-          const ent = { key: -0.5 - i, slot, record: void 0, aux: 0, gen, blockN: 0 };
-          bySlot[slot] = ent;
-          packInto(ent, records[i], aux ? aux(i) : 0);
-          if (!orderChanged && prevOrder[i] !== slot) orderChanged = true;
-          orderCpu[i] = slot;
-        }
-      } else {
-        if (keys.length !== n) throw new Error(`${label}: ${keys.length} keys for ${n} records`);
-        if (lastKeys === null) resetAll();
-        const same = lastKeys !== null && lastKeys.length === n && lastKeys.every((k, i) => k === keys[i]);
-        for (let i = 0; i < n; i++) {
-          const key = keys[i];
-          let ent = byKey.get(key);
-          if (ent === void 0) {
-            const slot = alloc();
-            ent = { key, slot, record: void 0, aux: 0, gen, blockN: 0 };
-            byKey.set(key, ent);
-            bySlot[slot] = ent;
-          }
-          ent.gen = gen;
-          const a = aux ? aux(i) : 0;
-          if (ent.record !== records[i] || ent.aux !== a) packInto(ent, records[i], a);
-          if (!orderChanged && prevOrder[i] !== ent.slot) orderChanged = true;
-          orderCpu[i] = ent.slot;
-        }
-        if (!same) {
-          if (lastKeys !== null) for (const k of lastKeys) {
-            const ent = byKey.get(k);
-            if (ent !== void 0 && ent.gen !== gen) release(ent);
-          }
-          lastKeys = keys.slice();
-        }
-      }
-      upload(n, orderChanged);
-      count = n;
-      return n;
-    },
-    slotAt: (i) => i < count ? orderCpu[i] : -1,
-    entryAt(i) {
-      if (i >= count) return NONE;
-      const ent = bySlot[orderCpu[i]];
-      return ent === null || ent === void 0 ? NONE : { aux: ent.aux, blockN: ent.blockN };
-    },
-    invalidate() {
-      for (const ent of byKey.values()) ent.record = void 0;
-    },
-    stats: () => ({ written, bytes, orderWrites, slots: next - free.length, capacity, grown }),
-    dispose() {
-      gpu.destroy();
-      orderGpu.destroy();
-      blockGpu?.destroy();
-      byKey.clear();
-    }
-  };
-}
-
 export {
+  KIND_STRIKES,
+  KIND_MISSING,
+  faultText,
+  createKindFaults,
+  isMissingRecord,
+  missingFace,
+  createRecordStore,
+  MISSING_KIND,
+  MISSING_OBJECT,
   STRATA,
   DRAWER,
   drawerSize,
@@ -7329,15 +8195,20 @@ export {
   TRAY_SHADER_FILES,
   trayShaders,
   visible,
+  createKindPasses,
   createSlotSet,
   SlotPool,
   drawSlot,
   drawFrame,
   prepareFrame,
   drawTray,
+  encodeFrame,
   Ground,
   tagsOf,
   renderHeldFrame,
+  checkCapture,
+  scaledInputs,
+  captureFrame,
   AMBIENT_DEFAULTS,
   createAmbient,
   rectOf,
@@ -7393,7 +8264,6 @@ export {
   inkRaster,
   kindsIn,
   withoutKind,
-  ablateKinds,
-  createRecordStore
+  ablateKinds
 };
-//# sourceMappingURL=chunk-ZPUPBULB.js.map
+//# sourceMappingURL=chunk-52GMQ2BN.js.map