paperlab 0.6.0 → 0.7.1

package/dist/{chunk-E22ILEDO.js → chunk-NTDVOOBA.js}

@@ -1,3 +1,8 @@
+import {
+  DAMAGE_CHANNELS,
+  DAMAGE_LOOK_DEFAULTS
+} from "./chunk-7TLIWPGM.js";
+
 // src/config/merge.ts
 function mergeConfig(base, override) {
   if (override === void 0) return base;
@@ -4399,10 +4404,10 @@ function usePaperStates(config, enabled, instant, onAction, onStateChange) {
 }
 
 // src/PaperMesh.tsx
-import * as THREE7 from "three";
+import * as THREE8 from "three";
 import { gsap as gsap2 } from "gsap";
-import { useFrame, useThree } from "@react-three/fiber";
-import { forwardRef, useEffect as useEffect5, useImperativeHandle, useMemo as useMemo3, useRef as useRef3 } from "react";
+import { useFrame as useFrame3, useThree } from "@react-three/fiber";
+import { forwardRef, useEffect as useEffect6, useImperativeHandle, useMemo as useMemo4, useRef as useRef3 } from "react";
 
 // src/core/normals.ts
 function computeSheetNormals(geometry) {
@@ -4498,6 +4503,27 @@ function spreadByAspect(sheet2, target) {
   if (!(long > 0)) return [target, target];
   return [Math.round(sheet2.width / long * target), Math.round(sheet2.height / long * target)];
 }
+function surfacePointAt(positions, cols, rows, u, v, out) {
+  const fx = Math.min(1, Math.max(0, u)) * (cols - 1);
+  const fy = (1 - Math.min(1, Math.max(0, v))) * (rows - 1);
+  const ix = Math.min(Math.floor(fx), cols - 2);
+  const iy = Math.min(Math.floor(fy), rows - 2);
+  const tx = fx - ix;
+  const ty = fy - iy;
+  const a = (iy * cols + ix) * 3;
+  const b = a + cols * 3;
+  const c = b + 3;
+  const d = a + 3;
+  for (let axis = 0; axis < 3; axis++) {
+    const pa = positions[a + axis];
+    const pb = positions[b + axis];
+    const pc = positions[c + axis];
+    const pd = positions[d + axis];
+    const value = tx + ty <= 1 ? pa + tx * (pd - pa) + ty * (pb - pa) : pc + (1 - tx) * (pb - pc) + (1 - ty) * (pd - pc);
+    out.setComponent(axis, value);
+  }
+  return out;
+}
 function createSheetGeometry(sheet2, minSegments = 2, autoSegments = LEGACY_FLAT_SEGMENTS) {
   const [sx, sy] = resolveSegments(sheet2, minSegments, autoSegments);
   return new THREE.PlaneGeometry(sheet2.width, sheet2.height, sx, sy);
@@ -4910,9 +4936,86 @@ var ClothSim = class {
   height;
   positions;
   prev;
+  /** Where the constructor laid every particle out — what {@link restore} puts back. */
+  laidOut;
   pinned;
   pinTargets;
-  constraints = [];
+  /**
+   * The constraints, one typed array per field rather than one object each.
+   *
+   * Because the effects layer has to vary them across the sheet, and an
+   * object with a fixed `rest` cannot be varied cheaply. Paper that chars
+   * SHRINKS — that is what curls it toward the flame, not softening — which
+   * is a shorter rest length on exactly the constraints the heat reached.
+   * Burnt-through paper has to stop pulling on what is left, which is a
+   * broken flag. A wet corner is floppier than the dry sheet above it, which
+   * is a per-constraint stiffness. None of that is in this file; this file
+   * only makes it possible, and at the defaults below the solve is
+   * bit-identical to the object version it replaces.
+   */
+  constraintCount;
+  constraintA;
+  constraintB;
+  /** 0 = structural, 1 = shear, 2 = bend (scaled by `stiffness` at solve time). */
+  constraintKind;
+  /**
+   * The length each constraint is laid out at. Never changes; the reference
+   * to shrink from.
+   *
+   * Float64, not Float32, and that is measured rather than cautious: with
+   * single-precision rest lengths every one of them rounded, and the first
+   * typed-array version of this solve disagreed with the object version it
+   * replaced in 476–711 of 714 coordinates after five seconds. The object
+   * version held a JS number, which is a double.
+   */
+  naturalLength;
+  /** The length it pulls toward now. `naturalLength` until something shrinks or stretches it. */
+  restLength;
+  /** A multiplier on the constraint's own strength. 1 is the paper as built. */
+  constraintStiffness;
+  /** Non-zero where the paper between two particles is gone. Skipped by the solve. */
+  broken;
+  /**
+   * How easily each particle is moved, 0..1: one over its mass, relative to
+   * dry paper.
+   *
+   * Mass matters in exactly two places here, and both are wired, because a
+   * "heavier" that touched neither would be another knob that does nothing.
+   * Gravity is an acceleration, so weight alone does not make wet paper fall
+   * differently. What does: the air pushes a heavy particle less (the aero
+   * term is divided by mass), and the constraint solve moves a heavy particle
+   * less than a light one it is tied to. Zero is infinite mass: static, moved by nothing — not the air, not the solve, and not gravity either.
+   */
+  invMass;
+  /**
+   * How far the middle of each BEND spring sits off the line between its ends
+   * when relaxed, along the sheet's normal — a signed rest curvature, as a
+   * sagitta in world units. Ignored on every other kind of constraint.
+   *
+   * Positive curls the paper toward its FRONT, the face a flat sheet turns to
+   * +z — which puts the middle of each span that far BEHIND its ends. Paper
+   * curling toward you is hollow on the side you see; the first cut of this
+   * had the middle in front, which is a dome, and a dome's rim goes the other
+   * way.
+   *
+   * The only lever here with a sign, and the sign is why it exists. A bend
+   * spring is a distance, and a distance cannot tell paper curled toward you
+   * from paper curled away: shorten it and the sheet buckles, but which way
+   * is a coin toss, and gravity can flip it through later. Measured on the
+   * first version, which pushed hot paper toward the front along its normal
+   * and left the char to hold it — the curl held while the heat did and
+   * snapped through to the BACK the moment the front had passed. Charred
+   * paper stays curled toward the side that burnt because that side shrank
+   * more: a curvature built into the material, which is what this is.
+   *
+   * Solved as a couple — the middle moves one way, the two ends half as far
+   * the other — so it bends the sheet and never pushes it anywhere. A push
+   * cannot do this job: it moves paper, and a uniformly curled sheet in still
+   * air has no business going anywhere.
+   */
+  restBend;
+  /** For each bend spring, the particle between its ends; -1 for every other kind. */
+  constraintMiddle;
   params;
   time = 0;
   accumulator = 0;
@@ -4968,11 +5071,11 @@ var ClothSim = class {
       }
     }
     this.prev.set(this.positions);
+    this.laidOut = this.positions.slice();
     const idx = (r, c) => r * cols + c;
+    const links = [];
     const link = (a, b, kind) => {
-      const dx = this.positions[a * 3] - this.positions[b * 3];
-      const dy = this.positions[a * 3 + 1] - this.positions[b * 3 + 1];
-      this.constraints.push({ a, b, rest: Math.hypot(dx, dy), kind });
+      links.push(a, b, kind);
     };
     for (let r = 0; r < rows; r++) {
       for (let c = 0; c < cols; c++) {
@@ -4986,6 +5089,31 @@ var ClothSim = class {
         if (r + 2 < rows) link(idx(r, c), idx(r + 2, c), 2);
       }
     }
+    const m = links.length / 3;
+    this.constraintCount = m;
+    this.constraintA = new Uint32Array(m);
+    this.constraintB = new Uint32Array(m);
+    this.constraintKind = new Uint8Array(m);
+    this.naturalLength = new Float64Array(m);
+    this.restLength = new Float64Array(m);
+    this.constraintStiffness = new Float64Array(m).fill(1);
+    this.broken = new Uint8Array(m);
+    this.restBend = new Float64Array(m);
+    this.constraintMiddle = new Int32Array(m).fill(-1);
+    for (let k = 0; k < m; k++) {
+      const a = links[k * 3];
+      const b = links[k * 3 + 1];
+      this.constraintA[k] = a;
+      this.constraintB[k] = b;
+      this.constraintKind[k] = links[k * 3 + 2];
+      if (this.constraintKind[k] === 2) this.constraintMiddle[k] = (a + b) / 2;
+      const dx = this.positions[a * 3] - this.positions[b * 3];
+      const dy = this.positions[a * 3 + 1] - this.positions[b * 3 + 1];
+      const rest = Math.hypot(dx, dy);
+      this.naturalLength[k] = rest;
+      this.restLength[k] = rest;
+    }
+    this.invMass = new Float32Array(this.count).fill(1);
     const pin = (r, c) => {
       const i = idx(r, c);
       this.pinned[i] = 1;
@@ -5061,6 +5189,22 @@ var ClothSim = class {
     this.asleep = false;
     this.stillFrames = 0;
   }
+  /**
+   * Back to the sheet as it was laid out: flat, still, every particle where
+   * the constructor put it. Pins, a grab and every lever are left alone.
+   *
+   * For a history that has been rewound — a burn played back from an earlier
+   * moment, say, which hands back paper that had burnt away and paper that
+   * had FALLEN, lying on the floor with its springs to the sheet suddenly
+   * whole again. Solved from there, the solve hauls it up through the sheet
+   * in a tangle. Laid out afresh, it is simply the sheet it is again.
+   */
+  restore() {
+    this.positions.set(this.laidOut);
+    this.prev.set(this.laidOut);
+    this.accumulator = 0;
+    this.wake();
+  }
   /**
    * Take hold of the sheet at one particle.
    *
@@ -5103,7 +5247,7 @@ var ClothSim = class {
       for (let c = centreCol - spanCols; c <= centreCol + spanCols; c++) {
         if (c < 0 || c >= this.cols) continue;
         const i = r * this.cols + c;
-        if (this.pinned[i]) continue;
+        if (this.pinned[i] || this.invMass[i] <= 0) continue;
         const distance = Math.hypot((c - centreCol) * cellX, (r - centreRow) * cellY);
         const weight = i === this.grabbedIndex ? 1 : grabFalloff(distance, radius);
         if (weight <= 0) continue;
@@ -5117,6 +5261,12 @@ var ClothSim = class {
         );
       }
     }
+    if (this.grabbed.length === 0) {
+      this.grabbedIndex = -1;
+      this.grabOffsets = new Float32Array(0);
+      this.wake();
+      return -1;
+    }
     this.grabOffsets = Float32Array.from(offsets);
     this.grabAt.set(this.positions.subarray(anchor, anchor + 3));
     this.grabWas.set(this.grabAt);
@@ -5277,12 +5427,19 @@ var ClothSim = class {
       const ax = nx * facing * (1 - AERO_TURBULENCE) + gust2 * 0.25 * AERO_TURBULENCE;
       const ay = ny * facing * (1 - AERO_TURBULENCE);
       const az = nz * facing * (1 - AERO_TURBULENCE) + gust2 * AERO_TURBULENCE;
+      const im = this.invMass[i];
+      if (im <= 0) {
+        this.prev[i3] = x;
+        this.prev[i3 + 1] = y;
+        this.prev[i3 + 2] = z25;
+        continue;
+      }
       this.prev[i3] = x;
       this.prev[i3 + 1] = y;
       this.prev[i3 + 2] = z25;
-      p[i3] = x + vx + ax * dt2;
-      p[i3 + 1] = y + vy + (ay - gravity * 3.2) * dt2;
-      p[i3 + 2] = z25 + vz + az * dt2;
+      p[i3] = x + vx + ax * im * dt2;
+      p[i3 + 1] = y + vy + (ay * im - gravity * 3.2) * dt2;
+      p[i3 + 2] = z25 + vz + az * im * dt2;
       maxTravel = Math.max(maxTravel, vx * vx + vy * vy + vz * vz);
     }
     for (let k = 0; k < this.grabbed.length; k++) {
@@ -5295,21 +5452,38 @@ var ClothSim = class {
         p[i3 + axis] = p[i3 + axis] + (target - p[i3 + axis]) * held;
       }
     }
+    const {
+      constraintA,
+      constraintB,
+      constraintKind,
+      restLength,
+      constraintStiffness,
+      broken,
+      invMass,
+      restBend,
+      constraintMiddle,
+      normals
+    } = this;
+    const bend2 = 0.25 + stiffness * 0.7;
     for (let iter = 0; iter < SOLVER_ITERATIONS2; iter++) {
-      for (const c of this.constraints) {
-        const k = c.kind === 2 ? 0.25 + stiffness * 0.7 : c.kind === 1 ? 0.85 : 1;
-        const a3 = c.a * 3;
-        const b3 = c.b * 3;
+      for (let c = 0; c < this.constraintCount; c++) {
+        if (broken[c]) continue;
+        const kind = constraintKind[c];
+        const k = (kind === 2 ? bend2 : kind === 1 ? 0.85 : 1) * constraintStiffness[c];
+        const ia = constraintA[c];
+        const ib = constraintB[c];
+        const a3 = ia * 3;
+        const b3 = ib * 3;
         const dx = p[b3] - p[a3];
         const dy = p[b3 + 1] - p[a3 + 1];
         const dz = p[b3 + 2] - p[a3 + 2];
         const dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
         if (dist === 0) continue;
-        const ma = this.pinned[c.a] ? 0 : 1 - this.grabWeights[c.a];
-        const mb = this.pinned[c.b] ? 0 : 1 - this.grabWeights[c.b];
+        const ma = this.pinned[ia] ? 0 : invMass[ia] * (1 - this.grabWeights[ia]);
+        const mb = this.pinned[ib] ? 0 : invMass[ib] * (1 - this.grabWeights[ib]);
         const total = ma + mb;
         if (total <= 0) continue;
-        const diff = (dist - c.rest) / dist / total * k;
+        const diff = (dist - restLength[c]) / dist / total * k;
         const aw = ma;
         const bw = mb;
         p[a3] = p[a3] + dx * diff * aw;
@@ -5318,6 +5492,31 @@ var ClothSim = class {
         p[b3] = p[b3] - dx * diff * bw;
         p[b3 + 1] = p[b3 + 1] - dy * diff * bw;
         p[b3 + 2] = p[b3 + 2] - dz * diff * bw;
+        const sag = restBend[c];
+        if (sag !== 0) {
+          const im = constraintMiddle[c];
+          const m3 = im * 3;
+          const nx = normals[m3];
+          const ny = normals[m3 + 1];
+          const nz = normals[m3 + 2];
+          const offset = (p[m3] - (p[a3] + p[b3]) / 2) * nx + (p[m3 + 1] - (p[a3 + 1] + p[b3 + 1]) / 2) * ny + (p[m3 + 2] - (p[a3 + 2] + p[b3 + 2]) / 2) * nz;
+          const mm = this.pinned[im] ? 0 : invMass[im] * (1 - this.grabWeights[im]);
+          const weight = mm + (ma + mb) / 4;
+          if (weight > 0) {
+            const lambda = (-sag - offset) / weight * k;
+            const along = lambda * mm;
+            const back = lambda / 2;
+            p[m3] = p[m3] + nx * along;
+            p[m3 + 1] = p[m3 + 1] + ny * along;
+            p[m3 + 2] = p[m3 + 2] + nz * along;
+            p[a3] = p[a3] - nx * back * ma;
+            p[a3 + 1] = p[a3 + 1] - ny * back * ma;
+            p[a3 + 2] = p[a3 + 2] - nz * back * ma;
+            p[b3] = p[b3] - nx * back * mb;
+            p[b3 + 1] = p[b3 + 1] - ny * back * mb;
+            p[b3 + 2] = p[b3 + 2] - nz * back * mb;
+          }
+        }
       }
     }
     for (let i = 0; i < this.count; i++) {
@@ -5338,9 +5537,392 @@ var ClothSim = class {
   }
 };
 
+// src/physics/damage.ts
+var { char: CHAR, saturation: SATURATION, presence: PRESENCE } = DAMAGE_CHANNELS;
+var GONE_BELOW = 128;
+var CHAR_SHRINK = 0.12;
+var CHAR_CURL = 6;
+var FRONT_GRADIENT = 16 * 16;
+var WET_MASS = 2;
+var TEAR_STRETCH = 1.5;
+var DamageCoupling = class {
+  sim;
+  source = null;
+  version = -1;
+  size = 0;
+  /** Each particle's texel, laid out for `size`. */
+  particleTexel = new Int32Array(0);
+  /** Gone, per particle, as of the last read. */
+  gone;
+  /** Whether any particle has ever been gone since the last reset — nothing can tear before. */
+  holed = false;
+  /** The gone particles with live paper beside them. See {@link follow}. */
+  followers = [];
+  /**
+   * Which piece of paper each particle belongs to, named by the lowest index
+   * in it — or -1 in the middle of a hole.
+   *
+   * A piece is whatever the sim's unbroken springs still hold together, which
+   * is exactly what moves as one: two pieces are two things the solve lets
+   * part. A gone particle on a cut takes the piece it borders MOST — a cut a
+   * single particle wide borders two, and a particle averaged between them
+   * would be dragged across the gap as one piece fell, stretching both edges
+   * into it.
+   */
+  piece;
+  /** Union-find over the particles, reused on every read. */
+  parent;
+  /**
+   * Per bend spring, how squarely it lies ACROSS the burn front, 0..1 — and
+   * remembered once it has been.
+   *
+   * A burnt edge rolls about an axis along the front, like a scroll; it does
+   * not dish into a bowl. Measured with the curl in every bend spring alike: a
+   * burnt band settled into a saddle, its corners forward and its middle BACK
+   * (+0.07, −0.06), because a surface cannot curve two ways at once without
+   * stretching and paper does not stretch. Curled across the front only, the
+   * same band rolled toward the viewer along its whole edge (+0.13).
+   *
+   * "Across the front" is the direction the char is changing fastest in, at
+   * the moment the front passes. It has to be remembered: once the front has
+   * gone by, the char behind it is uniform and says nothing about direction,
+   * but the paper stays rolled the way it rolled.
+   */
+  curlWeight;
+  /** The mesh's index as it was built — what {@link tear} hides triangles from and mends them back to. */
+  original = null;
+  /** Per triangle of that index: torn, and hidden until the history is rewound. */
+  torn = new Uint8Array(0);
+  /** The triangles with a gone corner — the only ones that can tear. */
+  rim = [];
+  rimStale = true;
+  /** Every torn triangle has to be put back: the history was rewound, or the source went. */
+  mend = false;
+  constructor(sim) {
+    this.sim = sim;
+    this.gone = new Uint8Array(sim.count);
+    this.piece = new Int32Array(sim.count);
+    this.parent = new Int32Array(sim.count);
+    this.curlWeight = new Float32Array(sim.constraintCount);
+  }
+  /**
+   * Bring the sim's levers up to date with `source`. Call before stepping.
+   *
+   * Returns whether anything was read. Free when the source has not changed,
+   * and a null source hands every lever back at its default.
+   */
+  update(source) {
+    const next = source ?? null;
+    if (next === this.source && (next === null || next.version === this.version)) return false;
+    if (next !== this.source) {
+      this.curlWeight.fill(0);
+      if (next && this.holed) {
+        this.rewind();
+        this.gone.fill(0);
+      }
+    }
+    this.source = next;
+    if (!next) {
+      this.reset();
+      return true;
+    }
+    if (next.size !== this.size) this.layout(next.size);
+    this.version = next.version;
+    this.read(next.pixels);
+    this.sim.wake();
+    return true;
+  }
+  /**
+   * Carry the gone particles at the edge of a hole along with the paper beside
+   * them. Call after stepping.
+   *
+   * Each one goes where its live neighbours say it would be if the grid were
+   * laid out flat around them — their positions plus its rest offset from
+   * each, averaged. The triangles that straddle the burnt edge then keep
+   * roughly their shape instead of stretching back to wherever the particle
+   * was when it burnt. Only the neighbours in its own {@link piece} count, so
+   * on a cut between two pieces it leaves with one of them.
+   */
+  follow() {
+    if (this.followers.length === 0) return;
+    const { gone, sim } = this;
+    const piece = this.piece;
+    const p = sim.positions;
+    const { cols, rows } = sim;
+    const cellX = cols > 1 ? sim.width / (cols - 1) : 0;
+    const cellY = rows > 1 ? sim.height / (rows - 1) : 0;
+    for (const g of this.followers) {
+      const r = g / cols | 0;
+      const c = g % cols;
+      const own = piece[g];
+      let sx = 0;
+      let sy = 0;
+      let sz = 0;
+      let n = 0;
+      for (let dr = -1; dr <= 1; dr++) {
+        const nr = r + dr;
+        if (nr < 0 || nr >= rows) continue;
+        for (let dc = -1; dc <= 1; dc++) {
+          const nc = c + dc;
+          if (dr === 0 && dc === 0 || nc < 0 || nc >= cols) continue;
+          const j = nr * cols + nc;
+          if (gone[j] || piece[j] !== own) continue;
+          const j3 = j * 3;
+          sx += p[j3] - dc * cellX;
+          sy += p[j3 + 1] + dr * cellY;
+          sz += p[j3 + 2];
+          n++;
+        }
+      }
+      if (n === 0) continue;
+      const g3 = g * 3;
+      p[g3] = sx / n;
+      p[g3 + 1] = sy / n;
+      p[g3 + 2] = sz / n;
+    }
+  }
+  /**
+   * Hide the triangles a piece has torn away from. Call after {@link follow},
+   * with the sheet's index buffer: it is rewritten in place, and the return
+   * says whether it changed, so the caller knows to upload it.
+   *
+   * A triangle tears when one of its edges has stretched past
+   * {@link TEAR_STRETCH} — which, among triangles with a burnt-away corner,
+   * only ever happens across a gap that is opening. It is then collapsed to a
+   * point, which draws nothing, casts no shadow and adds nothing to its
+   * corners' normals, and it stays hidden: torn paper does not mend because
+   * the two sides swing close again. Only a rewound history puts it back.
+   *
+   * A sheet in one piece, held, never stretches one that far — so a burn that
+   * cuts nothing loose leaves this index exactly as it was built.
+   */
+  tear(index) {
+    if (!this.holed && !this.mend) return false;
+    if (!this.original || this.original.length !== index.length) {
+      this.original = index.slice();
+      this.torn = new Uint8Array(index.length / 3);
+      this.rimStale = true;
+    }
+    const { original, torn, gone, sim } = this;
+    let changed = false;
+    if (this.mend) {
+      this.mend = false;
+      index.set(original);
+      changed = true;
+    }
+    if (this.rimStale) {
+      this.rimStale = false;
+      const rim = [];
+      for (let t = 0; t < torn.length; t++) {
+        if (gone[original[t * 3]] || gone[original[t * 3 + 1]] || gone[original[t * 3 + 2]]) rim.push(t);
+      }
+      this.rim = rim;
+    }
+    const p = sim.positions;
+    const { cols, rows } = sim;
+    const cellX = cols > 1 ? sim.width / (cols - 1) : 0;
+    const cellY = rows > 1 ? sim.height / (rows - 1) : 0;
+    const limit = TEAR_STRETCH * TEAR_STRETCH;
+    const stretched = (i, j) => {
+      const dc = i % cols - j % cols;
+      const dr = (i / cols | 0) - (j / cols | 0);
+      const rest = (dc * cellX) ** 2 + (dr * cellY) ** 2;
+      const i3 = i * 3;
+      const j3 = j * 3;
+      const now = (p[i3] - p[j3]) ** 2 + (p[i3 + 1] - p[j3 + 1]) ** 2 + (p[i3 + 2] - p[j3 + 2]) ** 2;
+      return now > rest * limit;
+    };
+    for (const t of this.rim) {
+      if (torn[t]) continue;
+      const a = original[t * 3];
+      const b = original[t * 3 + 1];
+      const c = original[t * 3 + 2];
+      if (!stretched(a, b) && !stretched(b, c) && !stretched(c, a)) continue;
+      torn[t] = 1;
+      index[t * 3 + 1] = a;
+      index[t * 3 + 2] = a;
+      changed = true;
+    }
+    return changed;
+  }
+  /** Map each particle to its texel. The damage grid's row 0 is v = 0, the sheet's BOTTOM. */
+  layout(size) {
+    const { cols, rows, count } = this.sim;
+    const last = size - 1;
+    this.size = size;
+    this.particleTexel = new Int32Array(count);
+    for (let r = 0; r < rows; r++) {
+      for (let c = 0; c < cols; c++) {
+        const u = cols > 1 ? c / (cols - 1) : 0.5;
+        const v = rows > 1 ? 1 - r / (rows - 1) : 0.5;
+        this.particleTexel[r * cols + c] = Math.round(v * last) * size + Math.round(u * last);
+      }
+    }
+  }
+  read(pixels) {
+    const { sim, gone, particleTexel, curlWeight, size } = this;
+    const {
+      invMass,
+      restLength,
+      naturalLength,
+      restBend,
+      broken,
+      constraintA,
+      constraintB,
+      constraintKind,
+      constraintMiddle
+    } = sim;
+    let rewound = false;
+    let holed = false;
+    for (let i = 0; i < sim.count; i++) {
+      const t = particleTexel[i] * 4;
+      const isGone = pixels[t + PRESENCE] < GONE_BELOW;
+      if (gone[i] && !isGone) rewound = true;
+      if (isGone) holed = true;
+      gone[i] = isGone ? 1 : 0;
+      invMass[i] = isGone ? 0 : 1 / (1 + WET_MASS * pixels[t + SATURATION] / 255);
+    }
+    if (rewound) this.rewind();
+    this.holed = holed;
+    this.rimStale = true;
+    for (let k = 0; k < sim.constraintCount; k++) {
+      const a = constraintA[k];
+      const b = constraintB[k];
+      const m = constraintMiddle[k];
+      if (gone[a] || gone[b] || m >= 0 && gone[m]) {
+        broken[k] = 1;
+        continue;
+      }
+      broken[k] = 0;
+      let charSum = pixels[particleTexel[a] * 4 + CHAR] + pixels[particleTexel[b] * 4 + CHAR];
+      let samples = 2;
+      if (m >= 0) {
+        charSum += pixels[particleTexel[m] * 4 + CHAR];
+        samples = 3;
+      }
+      const char = charSum / (samples * 255);
+      restLength[k] = naturalLength[k] * (1 - CHAR_SHRINK * char);
+      if (constraintKind[k] === 2) {
+        const t = particleTexel[m];
+        const x = t % size;
+        const y = t / size | 0;
+        const gx = pixels[(y * size + Math.min(size - 1, x + 2)) * 4 + CHAR] - pixels[(y * size + Math.max(0, x - 2)) * 4 + CHAR];
+        const gy = pixels[(Math.min(size - 1, y + 2) * size + x) * 4 + CHAR] - pixels[(Math.max(0, y - 2) * size + x) * 4 + CHAR];
+        const steep = gx * gx + gy * gy;
+        if (steep > FRONT_GRADIENT) {
+          const across = (b - a === 2 ? gx * gx : gy * gy) / steep;
+          if (across > curlWeight[k]) curlWeight[k] = across;
+        }
+        const span = naturalLength[k];
+        restBend[k] = CHAR_CURL * char * curlWeight[k] * span * span / 8;
+      }
+    }
+    this.findPieces();
+  }
+  /**
+   * Which piece each particle is in ({@link piece}), and which gone ones
+   * follow a piece at all ({@link followers}).
+   *
+   * Pieces by union-find over the springs that still hold, rooted at the
+   * lowest index so the same burn names the same pieces every time. Then each
+   * gone particle with live paper beside it joins the piece it has the most
+   * neighbours in, the lower-named on a tie.
+   */
+  findPieces() {
+    const { sim, gone } = this;
+    const parent = this.parent;
+    const piece = this.piece;
+    const { broken, constraintA, constraintB } = sim;
+    for (let i = 0; i < sim.count; i++) parent[i] = i;
+    const find = (i) => {
+      let r = i;
+      while (parent[r] !== r) r = parent[r];
+      while (parent[i] !== r) {
+        const up = parent[i];
+        parent[i] = r;
+        i = up;
+      }
+      return r;
+    };
+    for (let k = 0; k < sim.constraintCount; k++) {
+      if (broken[k]) continue;
+      const ra = find(constraintA[k]);
+      const rb = find(constraintB[k]);
+      if (ra < rb) parent[rb] = ra;
+      else if (rb < ra) parent[ra] = rb;
+    }
+    for (let i = 0; i < sim.count; i++) piece[i] = gone[i] ? -1 : find(i);
+    const followers = [];
+    const { cols, rows } = sim;
+    const seen = [];
+    const votes = [];
+    for (let i = 0; i < sim.count; i++) {
+      if (!gone[i]) continue;
+      const r = i / cols | 0;
+      const c = i % cols;
+      seen.length = 0;
+      votes.length = 0;
+      for (let dr = -1; dr <= 1; dr++) {
+        const nr = r + dr;
+        if (nr < 0 || nr >= rows) continue;
+        for (let dc = -1; dc <= 1; dc++) {
+          const nc = c + dc;
+          if (nc < 0 || nc >= cols) continue;
+          const j = nr * cols + nc;
+          if (gone[j]) continue;
+          const at = seen.indexOf(piece[j]);
+          if (at < 0) {
+            seen.push(piece[j]);
+            votes.push(1);
+          } else {
+            votes[at]++;
+          }
+        }
+      }
+      if (seen.length === 0) continue;
+      let best = 0;
+      for (let k = 1; k < seen.length; k++) {
+        if (votes[k] > votes[best] || votes[k] === votes[best] && seen[k] < seen[best]) best = k;
+      }
+      piece[i] = seen[best];
+      followers.push(i);
+    }
+    this.followers = followers;
+  }
+  /**
+   * A rewound history: the sheet starts over.
+   *
+   * Paper that had fallen away is paper again, with every spring back to the
+   * sheet it was cut from — solved from where it lies, the solve would haul it
+   * up off the floor through the sheet in a tangle. And the curl it rolled
+   * into belonged to a front that has not passed yet.
+   */
+  rewind() {
+    this.sim.restore();
+    this.curlWeight.fill(0);
+    this.torn.fill(0);
+    this.mend = true;
+  }
+  reset() {
+    const { sim } = this;
+    if (this.holed) this.rewind();
+    sim.invMass.fill(1);
+    sim.restBend.fill(0);
+    sim.broken.fill(0);
+    sim.restLength.set(sim.naturalLength);
+    this.gone.fill(0);
+    this.curlWeight.fill(0);
+    this.followers = [];
+    this.holed = false;
+    this.version = -1;
+    sim.wake();
+  }
+};
+
 // src/surface/PaperMaterial.tsx
-import * as THREE6 from "three";
-import { useEffect as useEffect4, useMemo as useMemo2 } from "react";
+import * as THREE7 from "three";
+import { useEffect as useEffect5, useMemo as useMemo3 } from "react";
+import { useFrame as useFrame2 } from "@react-three/fiber";
 import CustomShaderMaterial from "three-custom-shader-material";
 
 // src/surface/compose.ts
@@ -5753,6 +6335,518 @@ void plPerforation(inout vec4 color) {
 }
 `
 );
+var DAMAGE_CHUNK = (
+  /* glsl */
+  `
+uniform sampler2D uDamage;
+uniform float uDamageDetail;
+// (edgeWave mm, edgeBite mm, sparkle, \u2013) \u2014 see DamageLook.
+uniform vec4 uLook3;
+
+// The damage grid's texels sit ON the sheet \u2014 texel x at u = x / (N - 1), its
+// corners on the sheet's corners, which is how the field paints and how the
+// physics reads it. A texture puts texel x at (x + 0.5) / N. Sampled straight,
+// the picture of a burn sat up to half a texel off the burn the paper feels.
+vec2 plDamageUv(vec2 uv) {
+  vec2 n = vec2(textureSize(uDamage, 0));
+  // Texel space, on the field's convention: texel x at u = x / (N - 1).
+  vec2 t = uv * (n - 1.0) + 0.5;
+  // Quintic-smoothed texel coordinates.
+  //
+  // Bilinear filtering is continuous but its DERIVATIVE is not: the blend
+  // weight is a straight line inside each texel and turns a corner at every
+  // boundary. Magnify a 64 grid to fill a macro crop \u2014 one cell is 4.9 mm of
+  // A4, about 58 px there \u2014 and those corners fall on a 58 px lattice, so
+  // every ramp drawn from this field can crease along it.
+  //
+  // Also tried against the contour rings, and also not their cause (that was
+  // the scorch fingers). Kept because it costs nothing and the crease is
+  // real:
+  // Bending the fractional part through a quintic (6t^5 - 15t^4 + 10t^3,
+  // whose first and second derivatives vanish at both ends) makes the
+  // interpolation C2 without a single extra tap: the hardware still does one
+  // bilinear fetch, it is just asked for a smoothed position. The sample at a
+  // texel's centre is unchanged, so the half-texel alignment this function
+  // exists for still holds \u2014 and a field nothing has happened to reads 1
+  // everywhere whatever the position, so the untouched-sheet identity is
+  // untouched too.
+  vec2 i = floor(t - 0.5) + 0.5;
+  vec2 f = t - i;
+  f = f * f * f * (f * (f * 6.0 - 15.0) + 10.0);
+  return (i + f) / n;
+}
+
+/**
+ * The four channels here, frayed finer than the grid.
+ *
+ * One cell of the field is ~3.3 mm of A4, and a burnt edge is jagged at the
+ * scale of a fibre (0.3\u20132 mm) \u2014 so the grid decides roughly WHERE and this
+ * decides exactly where. Stretched along the fibre (the field's default grain
+ * runs along u), so a tear follows the grain. Scaled by what is already
+ * there, so pristine paper (char 0, presence 1) is untouched to the bit, and
+ * skipped outright at detail 0: the zones still draw on every tier, only
+ * without the finest octaves.
+ */
+/**
+ * Where on the grid this fragment reads its damage \u2014 warped.
+ *
+ * A burnt hole is never a circle: paper burns unevenly, and its edge wobbles
+ * in long waves with small bites in and out. The field is too coarse to hold
+ * that, so the READ is displaced instead: two octaves of noise in the sheet's
+ * own space, a long wave of up to \xB16 mm and short bites of \xB12 mm. Every zone \u2014
+ * the cut, the lip, the ember line, the char, the scorch \u2014 reads through the
+ * same warp, so they all follow one uneven edge. Warping a field nothing has
+ * happened to reads the same untouched value everywhere, so the identity
+ * holds.
+ */
+vec2 plDamageWarpAt(vec2 paperUv) {
+  vec2 p = (paperUv - 0.5) * uSheetSize;
+  const float mm = 1.0 / 210.0;
+  vec2 wave = vec2(plFbm(p * 26.0 + 3.1), plFbm(p * 26.0 + 17.7)) - 0.5;
+  vec2 bite = vec2(plNoise(p * 95.0 + 5.3), plNoise(p * 95.0 + 41.9)) - 0.5;
+  vec2 shift = (wave * 2.0 * uLook3.x + bite * 2.0 * uLook3.y) * mm;
+  return plDamageUv(paperUv + shift / uSheetSize);
+}
+
+vec2 plDamageWarp() {
+  return plDamageWarpAt(vPaperUv);
+}
+
+/** Presence softened over five taps \u2014 see \`plDamageRead\`. */
+float plSoftPresence(vec2 uv) {
+  vec2 texel = 0.75 / vec2(textureSize(uDamage, 0));
+  return (2.0 * texture2D(uDamage, uv).a
+    + texture2D(uDamage, uv + vec2(texel.x, 0.0)).a + texture2D(uDamage, uv - vec2(texel.x, 0.0)).a
+    + texture2D(uDamage, uv + vec2(0.0, texel.y)).a + texture2D(uDamage, uv - vec2(0.0, texel.y)).a) / 6.0;
+}
+
+/** The fray and the fibre at a point of the sheet (local units), scaled by detail. */
+vec2 plFray(vec2 p) {
+  return vec2(
+    (plFbm(vec2(p.x * 22.0, p.y * 48.0)) - 0.47) * uDamageDetail,
+    (plNoise(vec2(p.x * 140.0, p.y * 420.0)) - 0.5) * uDamageDetail
+  );
+}
+
+/**
+ * The presence the cut is drawn from, at any point of the paper: warped,
+ * softened and frayed exactly as \`plDamageRead\` does it for this fragment.
+ */
+float plDrawnPresenceAt(vec2 paperUv) {
+  float a = plSoftPresence(plDamageWarpAt(paperUv));
+  if (uDamageDetail > 0.0) {
+    vec2 ff = plFray((paperUv - 0.5) * uSheetSize);
+    a = clamp(a + (ff.x * 0.36 + ff.y * 0.05) * (1.0 - smoothstep(0.9, 1.0, a)), 0.0, 1.0);
+  }
+  return a;
+}
+
+// The softened presence before the fray, from the last \`plDamageRead\`: what
+// the distance to the cut takes its slope from (see \`plDamage\`).
+float plDamageSmooth;
+
+vec4 plDamageRead() {
+  vec2 uv = plDamageWarp();
+  vec4 d = texture2D(uDamage, uv);
+  // The cut runs on a SOFTENED presence. Paper burns through within a single
+  // texel now, so the raw field is hard-edged and its half-presence contour
+  // is the grid's own staircase \u2014 the fray below can only move a line within
+  // the band it is given, and a one-texel band is not enough to hide a grid.
+  // Five taps round the contour; an untouched field is 1 everywhere and
+  // stays exactly 1.
+  d.a = plSoftPresence(uv);
+  plDamageSmooth = d.a;
+  if (uDamageDetail > 0.0) {
+    vec2 ff = plFray(plLocal());
+    float fray = ff.x;
+    float fibre = ff.y;
+    float edge = 1.0 - smoothstep(0.9, 1.0, d.a);
+    d.r = clamp(d.r + fray * 0.3 * smoothstep(0.0, 0.15, d.r), 0.0, 1.0);
+    d.a = clamp(d.a + (fray * 0.36 + fibre * 0.05) * edge, 0.0, 1.0);
+  }
+  return d;
+}
+
+void plDamageCut(inout vec4 color, vec4 d) {
+  // Missing paper: gone at half presence, on every stock alike.
+  color.a *= step(0.5, d.a);
+}
+`
+);
+var DAMAGE_SHADE_CHUNK = (
+  /* glsl */
+  `
+uniform float uDamageTime;
+// The look, packed \u2014 see DamageLook for what each number means.
+uniform vec4 uLook0; // emberWidth mm, emberIntensity, emberCoverage, emberFlicker
+uniform vec4 uLook1; // emberGlow, lipWidth mm, lipBrightness, charWarmth
+uniform vec4 uLook2; // charCracks, scorchReach mm, scorchDarkness, fingers
+/** The light the burn gives off from the sheet itself: the ember line, and nothing else. */
+vec3 plDamageLight;
+
+// World units per millimetre: a default sheet is one unit across, and A4 is 210 mm.
+const float PL_MM = 1.0 / 210.0;
+
+vec3 plLinear(vec3 srgb) {
+  return pow(srgb, vec3(2.2));
+}
+
+/**
+ * World up, as a direction in the sheet's UV, from how this fragment's UV and
+ * view position change across the screen. Must be called in uniform control
+ * flow \u2014 it is all derivatives.
+ */
+vec2 plUpUv() {
+  vec3 dpx = dFdx(-vViewPosition);
+  vec3 dpy = dFdy(-vViewPosition);
+  vec2 dux = dFdx(vPaperUv);
+  vec2 duy = dFdy(vPaperUv);
+  float det = dux.x * duy.y - dux.y * duy.x;
+  if (abs(det) < 1e-14) return vec2(0.0, 1.0);
+  vec3 dPdu = (dpx * duy.y - dpy * dux.y) / det;
+  vec3 dPdv = (dpy * dux.x - dpx * duy.x) / det;
+  vec3 up = (viewMatrix * vec4(0.0, 1.0, 0.0, 0.0)).xyz;
+  vec2 g = vec2(dot(up, dPdu) / max(dot(dPdu, dPdu), 1e-12), dot(up, dPdv) / max(dot(dPdv, dPdv), 1e-12));
+  float l = length(g);
+  return l > 1e-6 ? g / l : vec2(0.0, 1.0);
+}
+
+/** F1 and F2 of a cell noise \u2014 the crack network in char. */
+vec2 plVoronoi(vec2 p) {
+  vec2 i = floor(p);
+  vec2 f = fract(p);
+  float f1 = 8.0;
+  float f2 = 8.0;
+  for (int y = -1; y <= 1; y++) {
+    for (int x = -1; x <= 1; x++) {
+      vec2 o = vec2(float(x), float(y));
+      vec2 r = o + vec2(plHash(i + o), plHash(i + o + 17.31)) - f;
+      float dd = dot(r, r);
+      if (dd < f1) {
+        f2 = f1;
+        f1 = dd;
+      } else if (dd < f2) {
+        f2 = dd;
+      }
+    }
+  }
+  return sqrt(vec2(f1, f2));
+}
+
+/** The scorch ramp, sampled off Scorch.png and Hero.png, as a tint over paper. 0 is the leading edge. */
+vec3 plScorchTint(float t) {
+  vec3 paper = plLinear(vec3(0.90, 0.885, 0.855));
+  vec3 c0 = plLinear(vec3(0.843, 0.741, 0.569)); // #D7BD91
+  vec3 c1 = plLinear(vec3(0.745, 0.514, 0.263)); // #BE8343
+  vec3 c2 = plLinear(vec3(0.631, 0.384, 0.180)); // #A1622E
+  vec3 c3 = plLinear(vec3(0.541, 0.310, 0.141)); // #8A4F24
+  vec3 c4 = plLinear(vec3(0.471, 0.275, 0.149)); // #784626
+  vec3 c5 = plLinear(vec3(0.380, 0.216, 0.133)); // #613722
+  vec3 c6 = plLinear(vec3(0.310, 0.200, 0.137)); // #4F3323
+  float s = clamp(t, 0.0, 1.0) * 6.0;
+  // Each stop is blended with a SMOOTH step, not a linear one.
+  //
+  // Seven colours joined by six straight segments is a ramp with a corner at
+  // every joint: the colour is continuous there but its rate of change is
+  // not, and the eye reads a discontinuous gradient as a faint line (Mach
+  // banding). smoothstep's derivative is zero at both ends of a segment, so
+  // consecutive segments meet with matching slope and there is no corner.
+  //
+  // Cheap insurance, not a bug fix \u2014 this was tried first against the macro
+  // crops' contour rings and did NOT remove them; the cause turned out to be
+  // the scorch fingers below, sampled in a frame that follows the contours.
+  float k = smoothstep(0.0, 1.0, clamp(s, 0.0, 1.0));
+  vec3 c = mix(c0, c1, k);
+  c = mix(c, c2, smoothstep(0.0, 1.0, clamp(s - 1.0, 0.0, 1.0)));
+  c = mix(c, c3, smoothstep(0.0, 1.0, clamp(s - 2.0, 0.0, 1.0)));
+  c = mix(c, c4, smoothstep(0.0, 1.0, clamp(s - 3.0, 0.0, 1.0)));
+  c = mix(c, c5, smoothstep(0.0, 1.0, clamp(s - 4.0, 0.0, 1.0)));
+  c = mix(c, c6, smoothstep(0.0, 1.0, clamp(s - 5.0, 0.0, 1.0)));
+  return min(c / paper, vec3(1.0));
+}
+
+/** The ember ramp (\xA75 zone 3): off \u2192 #870E03 \u2192 #A12108 \u2192 #F77E14 \u2192 #FEFBE0, hottest last. */
+vec3 plEmberRamp(float t) {
+  vec3 c0 = plLinear(vec3(0.529, 0.055, 0.012));
+  vec3 c1 = plLinear(vec3(0.631, 0.129, 0.031));
+  vec3 c2 = plLinear(vec3(0.969, 0.494, 0.078));
+  vec3 c3 = plLinear(vec3(0.996, 0.984, 0.878));
+  vec3 c = mix(c0, c1, smoothstep(0.0, 0.3, t));
+  c = mix(c, c2, smoothstep(0.3, 0.7, t));
+  return mix(c, c3, smoothstep(0.75, 1.0, t));
+}
+
+void plDamage(inout vec4 color, inout float roughness) {
+  plDamageLight = vec3(0.0);
+  vec4 d = plDamageRead();
+  vec2 uv = plDamageWarp();
+  vec2 texel = 1.0 / vec2(textureSize(uDamage, 0));
+
+  // Everything measured off screen derivatives, up front: derivatives are
+  // undefined past a branch that only some fragments of a quad take.
+  vec2 upUv = plUpUv();
+  vec4 e = texture2D(uDamage, uv + vec2(texel.x, 0.0));
+  vec4 w = texture2D(uDamage, uv - vec2(texel.x, 0.0));
+  vec4 n = texture2D(uDamage, uv + vec2(0.0, texel.y));
+  vec4 s = texture2D(uDamage, uv - vec2(0.0, texel.y));
+  // Per world unit: one texel step is 1 / (N - 1) of the sheet.
+  vec2 perWorld = (vec2(textureSize(uDamage, 0)) - 1.0) / uSheetSize;
+  vec2 gradP = vec2(e.a - w.a, n.a - s.a) * 0.5 * perWorld;
+  vec2 gradC = vec2(e.r - w.r, n.r - s.r) * 0.5 * perWorld;
+  // Millimetres from the cut, on the paper side \u2014 measured against the field
+  // the cut is DRAWN from (softened, frayed, warped), through its own screen
+  // derivatives. It used to divide by the slope of the raw texels, and since
+  // paper burns through within a texel that slope is a cliff while the drawn
+  // edge is spread over millimetres: a point well into the char computed as a
+  // hair from the cut, and the ember line drew there \u2014 found by the gate.
+  // The slope, though, is the SMOOTH presence's. The fray's fibre noise
+  // changes pixel to pixel, and its slope is a cliff everywhere it touches:
+  // divided by that, a point deep in the char came out a hair from the cut
+  // and the ember glow drew there \u2014 the gate's stray pixels. The fray still
+  // moves where the edge is; it just cannot fake how steep it is.
+  float smoothA = plDamageSmooth;
+  vec2 cutSlope = vec2(dFdx(smoothA), dFdy(smoothA));
+  float pxFromCut = (d.a - 0.5) / max(length(cutSlope), 1e-4);
+  // Millimetres per pixel ALONG the way to the cut, not across the screen's
+  // x: a sheet leaning away is foreshortened vertically, so above and below a
+  // hole a pixel covers more paper than beside it, and a scale taken from x
+  // alone drew the ember zone too many pixels deep on the top and bottom rims.
+  vec2 toCutPx = cutSlope / max(length(cutSlope), 1e-6);
+  float mmPerPx = length(dFdx(-vViewPosition) * toCutPx.x + dFdy(-vViewPosition) * toCutPx.y) / PL_MM;
+  float mm = pxFromCut * mmPerPx;
+  // About a pixel of antialiasing, never more: where the warp makes the
+  // estimate jump between neighbours, fwidth(mm) is millimetres wide, and the
+  // ember's soft tail \u2014 faint, but multiplied by its light \u2014 drew stray glow
+  // well out into the char.
+  float aa = min(fwidth(mm), 1.5 * mmPerPx);
+  // Scorch reaches ahead of the char, and further UP than anywhere else:
+  // the char a centimetre below this point, and the char a few millimetres
+  // around it, each lent to the scorch at a discount (\xA74.2, \xA74.5).
+  vec2 mmUv = vec2(PL_MM) / uSheetSize;
+  float charBelow = max(texture2D(uDamage, uv - upUv * uLook2.y * mmUv).r, texture2D(uDamage, uv - upUv * 0.5 * uLook2.y * mmUv).r);
+  // A ring of eight, averaged: four diagonal maxima drew the grid back in as
+  // squares wherever the scorch was magnified.
+  float charWide = 0.0;
+  for (int k = 0; k < 8; k++) {
+    float a = float(k) * 0.7853982;
+    charWide += texture2D(uDamage, uv + vec2(cos(a), sin(a)) * 7.0 * mmUv).r;
+  }
+  charWide /= 8.0;
+  // Only paper that has a CUT beside it has an edge: a half-eaten cell out
+  // in the middle of the sheet reads as "half a presence" too, and without
+  // this the ember line and the ash lip drew on it \u2014 islands of glow on
+  // paper, the painted glow by another route.
+  // Eased in, not switched: a hard threshold on the neighbouring texels drew
+  // the grid back into the ember glow as small squares.
+  float cutNear = 1.0 - smoothstep(0.3, 0.62, min(min(e.a, w.a), min(n.a, s.a)));
+  // And the cut has to really be there. \`mm\` extrapolates this pixel's
+  // slope to half presence, and the uneven edge's warp bends the field inside
+  // those few millimetres \u2014 measured: with the warp off the stray ember light
+  // the gate finds all but vanishes. So step across the PAPER toward where the
+  // cut should be, half a millimetre past it but never beyond the ember
+  // zone's own outer edge (the lip and the widest bead \u2014 2.5 mm at the
+  // spec's numbers, \xA75) plus that half, and read what the cut is drawn from.
+  // Still paper: this is not an edge, however close the slope said it was.
+  vec2 toCutPaper = -(dFdx(vPaperUv) * toCutPx.x + dFdy(vPaperUv) * toCutPx.y);
+  float reachPx = min(max(mm, 0.0) + 0.5, uLook1.y + uLook0.x + 0.5) / max(mmPerPx, 1e-6);
+  float pastA = plDrawnPresenceAt(vPaperUv + toCutPaper * reachPx);
+  // And a hole, not a pinhole: the fray opens specks of void finer than a
+  // pixel in part-burnt paper, which the check above would take for the
+  // edge. The void has to go on for another half millimetre.
+  float beyondA = plDrawnPresenceAt(vPaperUv + toCutPaper * (reachPx + 0.5 / max(mmPerPx, 1e-6)));
+  cutNear *= (1.0 - smoothstep(0.42, 0.55, pastA)) * (1.0 - smoothstep(0.42, 0.55, beyondA));
+
+  // An untouched texel is left exactly as it was \u2014 the identity the whole
+  // seam is built on. Nothing here has happened to this paper.
+  if (d.r <= 0.0 && d.g <= 0.0 && d.a >= 1.0 && charBelow <= 0.0 && charWide <= 0.0 && e.a >= 1.0 && w.a >= 1.0 && n.a >= 1.0 && s.a >= 1.0) {
+    return;
+  }
+
+  vec2 p = plLocal();
+
+  // Wet paper is darker and smoother: water fills the gaps between fibres
+  // that scatter light, which is both effects from one cause.
+  color.rgb *= 1.0 - 0.38 * d.g;
+  roughness *= 1.0 - 0.45 * d.g;
+
+  // \u2500\u2500 Scorch \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+  // Fingers: irregular teeth ALONG the scorch front, plus the grain's own
+  // streaks. Measured along the front's tangent so they point outward.
+  vec2 tangentC = length(gradC) > 1e-4 ? normalize(vec2(-gradC.y, gradC.x)) : vec2(1.0, 0.0);
+  float along = dot(p, tangentC) / (4.0 * PL_MM);
+  // Only where there really IS a front.
+  //
+  // This noise is sampled in a frame built from the char gradient, so that
+  // its teeth run across the front wherever the front happens to point. That
+  // works at the front and is meaningless behind it: a few millimetres into
+  // the char the gradient is almost flat, its direction is whatever the
+  // eight-bit field rounded to, and the frame turns with position \u2014 which
+  // makes the noise a function OF THE CONTOURS rather than of the sheet. It
+  // drew closed loops following the edge, nested a cell apart: the
+  // "concentric contour lines, like a topographic map or tree rings" the
+  // review found at macro range and left unexplained. Turning this one term
+  // off removes them completely and changes nothing else.
+  //
+  // Measured on the scripted burn's peak: the gradient runs to about 19 at
+  // the front and under 1 a few millimetres behind it.
+  float frontness = smoothstep(1.0, 6.0, length(gradC));
+  float fingers = (plFbm(vec2(along, dot(p, vec2(tangentC.y, -tangentC.x)) / (12.0 * PL_MM))) - 0.5) * 0.28 * frontness
+    + (plFbm(vec2(p.x * 9.0, p.y * 30.0)) - 0.5) * 0.08;
+  fingers *= uLook2.w;
+  // Fingers on the borrowed scorch too, so the outer edge is irregular
+  // teeth rather than a smooth offset of the char.
+  float reach = 0.75 + fingers * 4.0;
+  // The scorch reads a softened char \u2014 its own texel and the four around it
+  // \u2014 so a bilinear 64\xB2 field magnified shows no contours or corners. The
+  // char zone keeps the sharp one: its edge is meant to be crisp.
+  float soft = (2.0 * d.r + e.r + w.r + n.r + s.r) / 6.0;
+  float self_ = clamp(mix(d.r, soft, 0.65) + fingers * smoothstep(0.0, 0.08, d.r), 0.0, 1.0);
+  float c = 1.0 - (1.0 - self_) * (1.0 - clamp(0.62 * charBelow * reach, 0.0, 1.0)) * (1.0 - clamp(0.4 * charWide * reach, 0.0, 1.0));
+  // Fibre-scale grain in the scorch, so a smooth field magnified never shows
+  // its contours \u2014 real scorch is fibrous (Scorch.png), not banded.
+  c = clamp(c + ((plNoise(p * 300.0) - 0.5) * 0.07 + (plNoise(p * 90.0) - 0.5) * 0.06) * smoothstep(0.0, 0.1, c), 0.0, 1.0);
+  // A dither of about one and a half of the damage texture's own levels.
+  //
+  // The field arrives as eight bits a channel, so char comes in steps of
+  // 1/255 \u2014 and the leading edge below spans 0.03 of it, which is seven and a
+  // half steps. The fibre grain above would have hidden them, but it is
+  // multiplied by smoothstep(0, 0.1, c), which is approximately zero exactly
+  // where the leading edge lives. This is not: it applies everywhere, and
+  // being finer than a level it can only ever move a value into the
+  // neighbouring one.
+  c = clamp(c + (plNoise(p * 900.0) - 0.5) * (1.5 / 255.0), 0.0, 1.0);
+  // A steep leading edge \u2014 paper to straw in a sliver \u2014 then the long ramp.
+  float lead = smoothstep(0.02, 0.05, c);
+  float ramp = smoothstep(0.05, 0.7, c);
+  color.rgb *= mix(vec3(1.0), pow(plScorchTint(ramp), vec3(uLook2.z)), lead);
+
+  // \u2500\u2500 Char \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+  // A wide, smooth hand-over from scorch to char \u2014 the gradient is the point.
+  float charZone = smoothstep(0.5, 0.9, c);
+  vec2 cells = plVoronoi(p / (3.6 * PL_MM));
+  // Sparse: a real crack network is broken, not a tiled floor \u2014 most cell
+  // borders never split.
+  float crack = (1.0 - smoothstep(0.008, 0.03, cells.y - cells.x)) * smoothstep(0.45, 0.65, plNoise(p / (7.0 * PL_MM)));
+  float plate = plHash(floor(p / (3.6 * PL_MM)) + 3.7);
+  // Dark orange where the char meets the scorch, deep brown toward the cut \u2014
+  // warm all the way, and fading smoothly into the scorch's lighter browns
+  // rather than stopping at a grey band.
+  // Warm (dark orange \u2192 deep brown) or, turned down, the sampled greys.
+  vec3 body = mix(plLinear(vec3(0.255, 0.239, 0.227)), plLinear(vec3(0.165, 0.086, 0.043)), uLook1.w);
+  vec3 under = mix(plLinear(vec3(0.275, 0.169, 0.090)), plLinear(vec3(0.42, 0.18, 0.06)), uLook1.w);
+  vec3 cracks = plLinear(vec3(0.039, 0.024, 0.016));    // #0A0604
+  vec3 charColor = mix(under, body, smoothstep(0.66, 1.0, c));
+  // Mottled at the plate scale and finer, and darker than the sampled body
+  // under a bright key \u2014 the reference's char reads near black in the frame.
+  charColor *= (0.75 + 0.35 * plate) * (0.8 + 0.4 * plNoise(p * 260.0));
+  charColor = mix(charColor, cracks, crack * uLook2.x);
+  color.rgb = mix(color.rgb, charColor, charZone);
+  roughness = mix(roughness, 0.6, charZone);
+  // Blistered, and each plate tilted its own way, so a raking light breaks
+  // the char into plates rather than lighting it as one sheet of black.
+  plHeight += charZone * ((plNoise(p * 380.0) - 0.5) * 0.00008 + (plate - 0.5) * 0.00018 - crack * 0.00016);
+
+  // \u2500\u2500 Ash lip \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+  // Inside the spec's zones (\xA75): the lip 0.5\u20131.5 mm, then the ember line
+  // 0.3\u20131 mm \u2014 2.5 mm from the cut at most, which the gate holds it to.
+  // Along the rim. Both the lip and the ember line below are laid out on this,
+  // and unlike the scorch fingers above it is safe to sample noise in: it is
+  // used ONLY within a couple of millimetres of the cut, where the presence
+  // gradient is the actual edge and points somewhere real. The fingers'
+  // mistake was carrying the same idea out into flat char, where the gradient
+  // is rounding error and a noise sampled in its frame draws the contours.
+  vec2 tangentP = length(gradP) > 1e-4 ? normalize(vec2(-gradP.y, gradP.x)) : vec2(1.0, 0.0);
+
+  float lipWidth = mix(0.4, max(uLook1.y, 0.41), plFbm(p / (2.5 * PL_MM)));
+  // Broken, not a hem. Ash flakes off a cooling edge in pieces, so the lip
+  // comes and goes along the rim and wanders in width where it is there. It
+  // used to be a continuous band of even width with a highlight down the
+  // middle of it, which read as a neon tube round the hole \u2014 the single most
+  // synthetic thing at wide view.
+  float lipAlong = dot(p, tangentP) / (3.2 * PL_MM);
+  float lipBreak = smoothstep(0.34, 0.56, plFbm(vec2(lipAlong, 0.9)));
+  float lip = (1.0 - smoothstep(lipWidth - aa, lipWidth + aa, mm)) * step(d.a, 0.999) * cutNear * lipBreak;
+  vec3 ash = plLinear(mix(vec3(0.525, 0.498, 0.490), vec3(0.741, 0.725, 0.725), plNoise(p * 520.0) * 0.6 + plNoise(p * 90.0) * 0.4)) * uLook1.z;
+  color.rgb = mix(color.rgb, ash, lip);
+  roughness = mix(roughness, 0.99, lip);
+  // Barely raised. THIS is where the highlight came from: a 0.7 mm ridge
+  // running round the hole is a cylinder, and a cylinder under a key light
+  // has a specular line down it however rough the surface is. Ash is a
+  // fragile crust a fraction of a millimetre proud of the paper, not a bead
+  // of solder \u2014 and the shape of it belongs to the broken edge above, not to
+  // a smooth ramp.
+  plHeight += lip * (1.0 - mm / max(lipWidth, 0.1)) * 0.00018;
+
+  // \u2500\u2500 The ember line \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+  // Beads along the cut: position along the edge, crawling on the burn's
+  // clock, with a flicker of their own. Only where it is hot \u2014 and as the
+  // heat goes the threshold rises, so the line breaks into fewer, dimmer
+  // beads and they go out one by one.
+  float s1 = dot(p, tangentP) / (2.4 * PL_MM) - uDamageTime * 0.55 * uLook0.w;
+  float bead = plNoise(vec2(s1, 0.37)) * 0.7 + plNoise(vec2(s1 * 2.3, 5.1)) * 0.3;
+  float flicker = 0.62 + 0.38 * plNoise(vec2(floor(s1) * 7.13, uDamageTime * 9.0 * uLook0.w));
+  // Down to a smoulder's last flicker: a spent edge keeps a little heat in
+  // the texture (\`Afterglow\`), and a bead should glow dim red on it rather
+  // than vanish while the edge still has something to give.
+  // Heat softened like the cut (its texel and the four around it), so the
+  // beads and the crimson glow follow the burn rather than the grid's cells.
+  float heatSoft = (2.0 * d.b + e.b + w.b + n.b + s.b) / 6.0;
+  float hot = smoothstep(0.012, 0.55, heatSoft);
+  // Coverage slides the threshold: more of the edge lit, or less.
+  float shift = (uLook0.z - 0.5) * 0.5;
+  float lit = smoothstep(mix(0.82, 0.45, hot) - shift, mix(0.9, 0.58, hot) - shift, bead);
+  // Each bead tapers at its ends \u2014 a bead, not a dash cut from a strip.
+  float width = max(mix(0.4, max(uLook0.x, 0.41), plNoise(vec2(s1 * 0.7, 9.0))) * (0.35 + 0.65 * lit), 1.4 * aa);
+  float band = smoothstep(lipWidth - aa, lipWidth + aa, mm) * (1.0 - smoothstep(lipWidth + width - aa, lipWidth + width + aa, mm)) * cutNear;
+  // Mostly orange: a bead is red at its ends and yellow-white only at its
+  // hottest core, which is what Ember_line.png shows. Mapped low and pushed
+  // high by a power, so white is the exception rather than the line.
+  // Orange through, yellow-white at the hottest cores. Dim red alone reads
+  // salmon once the curve desaturates it, so the ramp starts at orange and
+  // only the cooling (low heat) falls back into red.
+  float t = hot * flicker * (0.45 + 0.55 * lit);
+  color.rgb = mix(color.rgb, plLinear(vec3(0.12, 0.04, 0.02)), band * lit);
+  // Saturated orange at orange brightness; only the hottest cores are pushed
+  // high enough for the curve to roll them to white.
+  plDamageLight = plEmberRamp(t) * mix(0.8, 6.0, t * t * t * t) * band * lit * hot * uLook0.y;
+
+  // The rest of a real burning edge (Ember_line.png): a dim crimson glow in
+  // the char beside the beads \u2014 patches of it, drifting \u2014 and specks of
+  // glowing fibre that come and go. Both stay under the bloom threshold, so
+  // they read as heat in the char rather than as light; both only where the
+  // edge is hot, and inside the zone the beads are held to \u2014 the lip plus
+  // the widest bead, measured from the cut \u2014 so the glow never reaches out
+  // over paper the gate says heat must not light.
+  float zoneEnd = uLook1.y + uLook0.x;
+  float seam = smoothstep(lipWidth - aa, lipWidth + aa, mm) * (1.0 - smoothstep(zoneEnd - 0.6, zoneEnd, mm)) * cutNear;
+  float patch_ = smoothstep(0.35, 0.72, plFbm(p / (4.0 * PL_MM) + vec2(uDamageTime * 0.15 * uLook0.w, 0.0)));
+  plDamageLight += vec3(0.55, 0.06, 0.01) * seam * patch_ * hot * uLook1.x;
+  float speck = step(0.985, plHash(floor(p / (0.35 * PL_MM)) + floor(uDamageTime * 8.0 * uLook0.w)));
+  plDamageLight += plEmberRamp(0.9) * 1.6 * speck * seam * hot * uLook3.z;
+
+  plDamageCut(color, d);
+}
+`
+);
+function carveDepthHelpers(helpers) {
+  const darken = "uniform float uBackDarken;\n";
+  const relief = helpers.indexOf("/**\n * The paper's relief");
+  const bell = helpers.lastIndexOf("/**", helpers.indexOf("float plBell("));
+  if (!helpers.includes(darken) || relief < 0 || bell <= relief) {
+    throw new Error("compose: HELPERS changed shape \u2014 update carveDepthHelpers");
+  }
+  return (helpers.slice(0, relief) + helpers.slice(bell)).replace(darken, "");
+}
+var DEPTH_HELPERS = carveDepthHelpers(HELPERS);
+var DEPTH_VERTEX = (
+  /* glsl */
+  `
+varying vec2 vPaperUv;
+void main() {
+  vPaperUv = uv;
+}
+`
+);
 var AGING_CHUNK = (
   /* glsl */
   `
@@ -5836,7 +6930,55 @@ function composeSurface(surface, stock, thickness, maps = { hasFrontMap: false,
     calls.push("plAging(csm_DiffuseColor);");
     uniforms.uAgingAmount = { value: aging };
   }
-  const relief = grain !== void 0 || creases.length > 0;
+  if (maps.hasDamage) {
+    chunks.push(DAMAGE_CHUNK, DAMAGE_SHADE_CHUNK);
+    calls.push("plDamage(csm_DiffuseColor, csm_Roughness);");
+    uniforms.uDamage = { value: null };
+    uniforms.uDamageDetail = { value: 1 };
+    uniforms.uDamageTime = { value: 0 };
+    const look = DAMAGE_LOOK_DEFAULTS;
+    uniforms.uLook0 = {
+      value: new THREE5.Vector4(look.emberWidth, look.emberIntensity, look.emberCoverage, look.emberFlicker)
+    };
+    uniforms.uLook1 = {
+      value: new THREE5.Vector4(look.emberGlow, look.lipWidth, look.lipBrightness, look.charWarmth)
+    };
+    uniforms.uLook2 = {
+      value: new THREE5.Vector4(look.charCracks, look.scorchReach, look.scorchDarkness, look.fingers)
+    };
+    uniforms.uLook3 = { value: new THREE5.Vector4(look.edgeWave, look.edgeBite, look.sparkle, 0) };
+  }
+  const cutting = [];
+  const cuts = [];
+  if (deckle) {
+    cutting.push(DECKLE_CHUNK);
+    cuts.push("plDeckle(color);");
+  }
+  if (perforation) {
+    cutting.push(PERFORATION_CHUNK);
+    cuts.push("plPerforation(color);");
+  }
+  if (maps.hasDamage) {
+    cutting.push(DAMAGE_CHUNK);
+    cuts.push("plDamageCut(color, plDamageRead());");
+  }
+  const depth = cutting.length > 0 ? {
+    vertexShader: DEPTH_VERTEX,
+    fragmentShader: (
+      /* glsl */
+      `
+${DEPTH_HELPERS}
+${cutting.join("\n")}
+void main() {
+  vec4 color = vec4(1.0);
+  float roughness = 1.0;
+  ${cuts.join("\n  ")}
+  if (color.a < 0.5) discard;
+}
+`
+    )
+  } : null;
+  const relief = grain !== void 0 || creases.length > 0 || Boolean(maps.hasDamage);
   const frontExpr = maps.hasFrontMap ? "texture2D(uFrontMap, vPaperUv).rgb" : "uStockColor";
   const backBaseExpr = stock.adhesive ? "vec3(0.965, 0.96, 0.945)" : maps.hasBackMap ? "texture2D(uBackMap, vec2(1.0 - vPaperUv.x, vPaperUv.y)).rgb" : "uStockColor";
   const fragmentShader = (
@@ -5865,6 +7007,7 @@ ${relief ? "  // The relief every effect above described, spent once \u2014 see
   ${stock.adhesive ? "// Adhesive underside: higher specular than the printed face.\n  if (!gl_FrontFacing) csm_Roughness = 0.18;" : ""}
   // What the key light pushes through the sheet, filtered by the ink on it.
   csm_Emissive = plTransmission(front);
+${maps.hasDamage ? "  // The ember line \u2014 the only light a burn gives off from the sheet itself.\n  csm_Emissive += plDamageLight;" : ""}
 }
 `
   );
@@ -5876,11 +7019,14 @@ ${relief ? "  // The relief every effect above described, spent once \u2014 see
       aging !== void 0 ? "a" : "",
       perforation ? "p" : "",
       stock.adhesive ? "A" : ""
-    ].join("")}:${maps.hasFrontMap ? "F" : ""}${maps.hasBackMap ? "B" : ""}`,
+    ].join("")}:${maps.hasFrontMap ? "F" : ""}${maps.hasBackMap ? "B" : ""}${maps.hasDamage ? "D" : ""}`,
     vertexShader: VERTEX,
     fragmentShader,
     uniforms,
-    alphaTest: deckle || perforation ? 0.5 : 0
+    // Anything that removes paper needs fragments discarded rather than
+    // blended — a hole has to cut the depth buffer and the shadow too.
+    alphaTest: deckle || perforation || maps.hasDamage ? 0.5 : 0,
+    depth
   };
 }
 function pad(values, fill = 0) {
@@ -5889,8 +7035,43 @@ function pad(values, fill = 0) {
   return out;
 }
 
+// src/surface/useDamageTexture.ts
+import * as THREE6 from "three";
+import { useFrame } from "@react-three/fiber";
+import { useEffect as useEffect4, useMemo as useMemo2 } from "react";
+function useDamageTexture(source) {
+  const texture = useMemo2(() => {
+    if (!source) return null;
+    const t = new THREE6.DataTexture(
+      source.pixels,
+      source.size,
+      source.size,
+      THREE6.RGBAFormat,
+      THREE6.UnsignedByteType
+    );
+    t.magFilter = THREE6.LinearFilter;
+    t.minFilter = THREE6.LinearFilter;
+    t.wrapS = THREE6.ClampToEdgeWrapping;
+    t.wrapT = THREE6.ClampToEdgeWrapping;
+    t.generateMipmaps = false;
+    t.colorSpace = THREE6.NoColorSpace;
+    t.flipY = false;
+    t.userData.version = source.version;
+    t.needsUpdate = true;
+    return t;
+  }, [source]);
+  useEffect4(() => () => texture?.dispose(), [texture]);
+  useFrame(() => {
+    if (!source || !texture) return;
+    if (texture.userData.version === source.version) return;
+    texture.userData.version = source.version;
+    texture.needsUpdate = true;
+  });
+  return texture;
+}
+
 // src/surface/PaperMaterial.tsx
-import { jsx as jsx3 } from "react/jsx-runtime";
+import { Fragment, jsx as jsx3, jsxs } from "react/jsx-runtime";
 function PaperMaterial({
   stock,
   texture,
@@ -5899,26 +7080,31 @@ function PaperMaterial({
   thickness,
   sheet: sheet2,
   lighting = "studio",
-  creases
+  creases,
+  damage
 }) {
   const rig = useLightRig(lighting);
+  const damageTexture = useDamageTexture(damage);
   const composed = composeSurface(
     surface,
     stock,
     thickness,
     {
       hasFrontMap: Boolean(texture),
-      hasBackMap: Boolean(backTexture)
+      hasBackMap: Boolean(backTexture),
+      hasDamage: Boolean(damageTexture)
     },
     sheet2,
     rig,
     creases ?? resolveCreases(surface, [], sheet2 ?? { width: 1, height: 1.4 })
   );
-  const bound = useMemo2(() => composed.uniforms, [composed.structureKey]);
-  useEffect4(() => {
+  const bound = useMemo3(() => composed.uniforms, [composed.structureKey]);
+  useEffect5(() => {
     for (const [key, uniform] of Object.entries(composed.uniforms)) {
-      if (!bound[key] || key === "uFrontMap" || key === "uBackMap") continue;
-      if (bound[key].value instanceof THREE6.Color && uniform.value instanceof THREE6.Color) {
+      if (!bound[key] || key === "uFrontMap" || key === "uBackMap" || key === "uDamage" || key === "uDamageDetail" || key === "uDamageTime" || key.startsWith("uLook")) {
+        continue;
+      }
+      if (bound[key].value instanceof THREE7.Color && uniform.value instanceof THREE7.Color) {
         ;
         bound[key].value.copy(uniform.value);
       } else {
@@ -5926,27 +7112,80 @@ function PaperMaterial({
       }
     }
   });
-  useEffect4(() => {
+  useEffect5(() => {
     if (bound.uFrontMap) bound.uFrontMap.value = texture;
     if (bound.uBackMap) bound.uBackMap.value = backTexture ?? null;
-  }, [bound, texture, backTexture]);
-  return /* @__PURE__ */ jsx3(
-    CustomShaderMaterial,
-    {
-      baseMaterial: THREE6.MeshStandardMaterial,
-      vertexShader: composed.vertexShader,
-      fragmentShader: composed.fragmentShader,
-      uniforms: bound,
-      color: "#ffffff",
-      roughness: stock.roughness,
-      metalness: 0,
-      transparent: stock.opacity < 1,
-      opacity: stock.opacity,
-      alphaTest: composed.alphaTest,
-      side: THREE6.DoubleSide
-    },
-    composed.structureKey
-  );
+    if (bound.uDamage) bound.uDamage.value = damageTexture;
+  }, [bound, texture, backTexture, damageTexture]);
+  useFrame2((state) => {
+    if (!bound.uDamageDetail) return;
+    if (bound.uDamageTime) {
+      const time = damage?.time ?? state.clock.elapsedTime;
+      bound.uDamageTime.value = Number.isFinite(time) ? time : 0;
+    }
+    if (bound.uLook0) {
+      const look = { ...DAMAGE_LOOK_DEFAULTS, ...damage?.look };
+      const v = (x, d2) => Number.isFinite(x) ? x : d2;
+      const d = DAMAGE_LOOK_DEFAULTS;
+      bound.uLook0.value.set(
+        v(look.emberWidth, d.emberWidth),
+        v(look.emberIntensity, d.emberIntensity),
+        v(look.emberCoverage, d.emberCoverage),
+        v(look.emberFlicker, d.emberFlicker)
+      );
+      bound.uLook1.value.set(
+        v(look.emberGlow, d.emberGlow),
+        v(look.lipWidth, d.lipWidth),
+        v(look.lipBrightness, d.lipBrightness),
+        v(look.charWarmth, d.charWarmth)
+      );
+      bound.uLook2.value.set(
+        v(look.charCracks, d.charCracks),
+        v(look.scorchReach, d.scorchReach),
+        v(look.scorchDarkness, d.scorchDarkness),
+        v(look.fingers, d.fingers)
+      );
+      bound.uLook3.value.set(
+        v(look.edgeWave, d.edgeWave),
+        v(look.edgeBite, d.edgeBite),
+        v(look.sparkle, d.sparkle),
+        0
+      );
+    }
+    const detail = damage?.detail ?? 1;
+    bound.uDamageDetail.value = Number.isFinite(detail) ? Math.min(1, Math.max(0, detail)) : 1;
+  });
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx3(
+      CustomShaderMaterial,
+      {
+        baseMaterial: THREE7.MeshStandardMaterial,
+        vertexShader: composed.vertexShader,
+        fragmentShader: composed.fragmentShader,
+        uniforms: bound,
+        color: "#ffffff",
+        roughness: stock.roughness,
+        metalness: 0,
+        transparent: stock.opacity < 1,
+        opacity: stock.opacity,
+        alphaTest: composed.alphaTest,
+        side: THREE7.DoubleSide
+      },
+      composed.structureKey
+    ),
+    composed.depth ? /* @__PURE__ */ jsx3(
+      CustomShaderMaterial,
+      {
+        attach: "customDepthMaterial",
+        baseMaterial: THREE7.MeshDepthMaterial,
+        vertexShader: composed.depth.vertexShader,
+        fragmentShader: composed.depth.fragmentShader,
+        uniforms: bound,
+        depthPacking: THREE7.RGBADepthPacking
+      },
+      `${composed.structureKey}:depth`
+    ) : null
+  ] });
 }
 
 // src/motion/onTwos.ts
@@ -5960,7 +7199,7 @@ function quantizeProgress(p, duration, fps = ON_TWOS_FPS) {
 }
 
 // src/PaperMesh.tsx
-import { jsx as jsx4, jsxs } from "react/jsx-runtime";
+import { jsx as jsx4, jsxs as jsxs2 } from "react/jsx-runtime";
 function configInputs(props) {
   return [
     props.preset ?? null,
@@ -5978,7 +7217,7 @@ function configInputs(props) {
 }
 function useResolvedConfig(props) {
   const inputs = useStable(configInputs(props));
-  return useMemo3(() => resolveConfig(props), [inputs]);
+  return useMemo4(() => resolveConfig(props), [inputs]);
 }
 function resolveConfig(props) {
   const base = props.preset ? typeof props.preset === "string" ? getPreset(props.preset) : parsePreset(props.preset) : paperConfigSchema.parse({});
@@ -5997,12 +7236,12 @@ function resolveConfig(props) {
 }
 var CLOTH_MAX_SEGMENTS = 28;
 var PROGRESS_SAMPLES = [0, 0.25, 0.5, 0.75, 1];
-var dragPlane = new THREE7.Plane();
-var dragPoint = new THREE7.Vector3();
-var planeNormal = new THREE7.Vector3();
-var anchorScratch = new THREE7.Vector3();
-var worldScratch = new THREE7.Vector3();
-var quatScratch = new THREE7.Quaternion();
+var dragPlane = new THREE8.Plane();
+var dragPoint = new THREE8.Vector3();
+var planeNormal = new THREE8.Vector3();
+var anchorScratch = new THREE8.Vector3();
+var worldScratch = new THREE8.Vector3();
+var quatScratch = new THREE8.Quaternion();
 var PaperMesh = forwardRef(function PaperMesh2(props, ref) {
   const resolved = useResolvedConfig(props);
   const reduced = usePrefersReducedMotion(props.reducedMotion);
@@ -6031,7 +7270,7 @@ var PaperMesh = forwardRef(function PaperMesh2(props, ref) {
   const draggingRef = useRef3(null);
   const configRef = useRef3(config);
   configRef.current = config;
-  const baseRotation = useMemo3(() => {
+  const baseRotation = useMemo4(() => {
     const [rx, ry, rz] = props.rotation ?? [0, 0, 0];
     return [rx, ry + config.scene.turn * Math.PI / 180, rz];
   }, [props.rotation, config.scene.turn]);
@@ -6046,16 +7285,16 @@ var PaperMesh = forwardRef(function PaperMesh2(props, ref) {
   const creasesRef = useRef3(null);
   creasesRef.current ??= new CreaseTracker(config.memory.creases);
   const creases = creasesRef.current;
-  useEffect5(() => {
+  useEffect6(() => {
     if (!draggingRef.current && !playingRef.current) overridesRef.current = {};
     creases.reset();
     dirtyRef.current = true;
   }, [behaviorKey, deformersKey, sheetKey, physicsKey]);
-  useEffect5(() => {
+  useEffect6(() => {
     creases.adopt(configRef.current.memory.creases);
     dirtyRef.current = true;
   }, [creaseKey]);
-  const { minSegments, autoSegments, animatedStack } = useMemo3(() => {
+  const { minSegments, autoSegments, animatedStack } = useMemo4(() => {
     const cfg = configRef.current;
     const probe2 = withMemory(buildStack(cfg, {}), cfg);
     if (!probe2) {
@@ -6084,16 +7323,16 @@ var PaperMesh = forwardRef(function PaperMesh2(props, ref) {
       animatedStack: animated
     };
   }, [behaviorKey, deformersKey, physicsKey, memoryKey]);
-  const geometry = useMemo3(() => {
+  const geometry = useMemo4(() => {
     if (isStrip) {
       const strip = configRef.current.physics;
       const nodes = stripNodeCount(config.sheet.height, strip.perforation);
-      return new THREE7.PlaneGeometry(config.sheet.width, config.sheet.height, 1, nodes - 1);
+      return new THREE8.PlaneGeometry(config.sheet.width, config.sheet.height, 1, nodes - 1);
     }
     if (!isCloth) return createSheetGeometry(config.sheet, minSegments, autoSegments);
     const [sx, sy] = resolveSegments(config.sheet, minSegments);
     const capped = Math.min(Math.max(sx, sy), CLOTH_MAX_SEGMENTS);
-    return new THREE7.PlaneGeometry(config.sheet.width, config.sheet.height, capped, capped);
+    return new THREE8.PlaneGeometry(config.sheet.width, config.sheet.height, capped, capped);
   }, [
     sheetKey,
     minSegments,
@@ -6102,12 +7341,12 @@ var PaperMesh = forwardRef(function PaperMesh2(props, ref) {
     isStrip,
     isStrip ? config.physics.perforation : 0
   ]);
-  useEffect5(() => () => geometry.dispose(), [geometry]);
-  const basePositions = useMemo3(
+  useEffect6(() => () => geometry.dispose(), [geometry]);
+  const basePositions = useMemo4(
     () => Float32Array.from(geometry.attributes.position.array),
     [geometry]
   );
-  const stripSim = useMemo3(() => {
+  const stripSim = useMemo4(() => {
     if (!isStrip) return null;
     const strip = configRef.current.physics;
     return new StripSim(config.sheet.height, config.sheet.width, {
@@ -6125,7 +7364,7 @@ var PaperMesh = forwardRef(function PaperMesh2(props, ref) {
     });
   }, [geometry, isStrip]);
   const lastSimRef = useRef3(null);
-  const sim = useMemo3(() => {
+  const sim = useMemo4(() => {
     if (!isCloth) return null;
     const cloth = configRef.current.physics;
     const cols = geometry.parameters.widthSegments + 1;
@@ -6139,9 +7378,10 @@ var PaperMesh = forwardRef(function PaperMesh2(props, ref) {
     next.adopt(lastSimRef.current);
     return next;
   }, [geometry, isCloth, isCloth ? config.physics.pins : ""]);
-  useEffect5(() => {
+  useEffect6(() => {
     lastSimRef.current = sim;
   }, [sim]);
+  const coupling = useMemo4(() => sim ? new DamageCoupling(sim) : null, [sim]);
   const stock = getStock(config.stock);
   const texture = useContentTexture(config.content, config.sheet, stock);
   const backTexture = useContentTexture(config.content.back, config.sheet, stock);
@@ -6183,7 +7423,7 @@ var PaperMesh = forwardRef(function PaperMesh2(props, ref) {
     playingRef.current = false;
     tweenRef.current?.pause();
   };
-  useEffect5(() => {
+  useEffect6(() => {
     if (props.autoplay && !reduced) play();
     return () => {
       tweenRef.current?.kill();
@@ -6226,7 +7466,22 @@ var PaperMesh = forwardRef(function PaperMesh2(props, ref) {
       const index = id ? handles.findIndex((h) => h.id === id) : 0;
       const mesh = handleRefs.current[index];
       if (!mesh) return null;
-      return mesh.getWorldPosition(target ?? new THREE7.Vector3());
+      return mesh.getWorldPosition(target ?? new THREE8.Vector3());
+    },
+    surfacePoint(u, v, target) {
+      const mesh = meshRef.current;
+      if (!mesh) return null;
+      const { widthSegments, heightSegments } = geometry.parameters;
+      const out = surfacePointAt(
+        geometry.attributes.position.array,
+        widthSegments + 1,
+        heightSegments + 1,
+        u,
+        v,
+        target ?? new THREE8.Vector3()
+      );
+      mesh.updateWorldMatrix(true, false);
+      return out.applyMatrix4(mesh.matrixWorld);
     },
     get state() {
       return machineState;
@@ -6236,12 +7491,12 @@ var PaperMesh = forwardRef(function PaperMesh2(props, ref) {
     placeProgrammatic: () => machineRef.current?.placeProgrammatic() ?? false,
     returnProgrammatic: () => machineRef.current?.returnProgrammatic() ?? false
   }));
-  const shadedCreases = useMemo3(
+  const shadedCreases = useMemo4(
     () => resolveCreases(config.surface, config.memory.creases, config.sheet),
     [config.surface, config.memory.creases, config.sheet]
   );
   const idlePose = useRef3({ position: [0, 0, 0], rotation: [0, 0, 0] });
-  useFrame(({ clock }, delta) => {
+  useFrame3(({ clock }, delta) => {
     const cfg = liveConfig();
     const now = reduced ? 0 : cfg.onTwos ? quantizeTime(clock.elapsedTime) : clock.elapsedTime;
     const hasBehaviorTransform = Boolean(behavior?.transform && cfg.behavior);
@@ -6325,8 +7580,14 @@ var PaperMesh = forwardRef(function PaperMesh2(props, ref) {
         stiffness: cloth.stiffness,
         floor: cloth.floor
       });
+      coupling?.update(props.damage);
       sim.step(delta);
       const moved = !sim.asleep;
+      if (moved && coupling) {
+        coupling.follow();
+        const index = geometry.index;
+        if (index && coupling.tear(index.array)) index.needsUpdate = true;
+      }
       if (!applyShape(sim.positions, moved) && moved) {
         const position = geometry.attributes.position;
         position.array.set(sim.positions);
@@ -6358,8 +7619,8 @@ var PaperMesh = forwardRef(function PaperMesh2(props, ref) {
     const p = overridesRef.current[behavior.progressParam];
     if (typeof p === "number") props.onProgress?.(p);
   };
-  const grabAnchor = useRef3(new THREE7.Vector3());
-  const grabOffset = useRef3(new THREE7.Vector3());
+  const grabAnchor = useRef3(new THREE8.Vector3());
+  const grabOffset = useRef3(new THREE8.Vector3());
   const clothDown = (e) => {
     if (!isCloth || !sim || !props.interactive || !groupRef.current) return;
     e.stopPropagation();
@@ -6422,7 +7683,7 @@ var PaperMesh = forwardRef(function PaperMesh2(props, ref) {
     e.target.releasePointerCapture(e.pointerId);
   };
   const sendState = (event) => machineRef.current?.send(event);
-  return /* @__PURE__ */ jsxs("group", { ref: groupRef, position: props.position, rotation: baseRotation, children: [
+  return /* @__PURE__ */ jsxs2("group", { ref: groupRef, position: props.position, rotation: baseRotation, children: [
     /* @__PURE__ */ jsx4(
       "mesh",
       {
@@ -6454,7 +7715,8 @@ var PaperMesh = forwardRef(function PaperMesh2(props, ref) {
             thickness: config.sheet.thickness,
             sheet: config.sheet,
             lighting: config.scene.lighting,
-            creases: shadedCreases
+            creases: shadedCreases,
+            damage: props.damage
           }
         )
       }
@@ -6463,7 +7725,7 @@ var PaperMesh = forwardRef(function PaperMesh2(props, ref) {
     // is no deformer stack for a handle to drive. Harmless as `!isCloth`
     // only because the schema makes a sim and a behavior exclusive — the
     // intent is what is written here.
-    !simKind && behavior?.handles?.map((h, i) => /* @__PURE__ */ jsxs(
+    !simKind && behavior?.handles?.map((h, i) => /* @__PURE__ */ jsxs2(
       "mesh",
       {
         userData: { paperlabChrome: true },
@@ -6536,13 +7798,13 @@ function buildStack(config, overrides, behavior, t = 0) {
 }
 
 // src/scene/PaperLighting.tsx
-import * as THREE9 from "three";
-import { useEffect as useEffect6, useMemo as useMemo4, useRef as useRef4 } from "react";
-import { useFrame as useFrame2, useThree as useThree2 } from "@react-three/fiber";
+import * as THREE10 from "three";
+import { useEffect as useEffect7, useMemo as useMemo5, useRef as useRef4 } from "react";
+import { useFrame as useFrame4, useThree as useThree2 } from "@react-three/fiber";
 import { ContactShadows } from "@react-three/drei";
 
 // src/scene/environment.ts
-import * as THREE8 from "three";
+import * as THREE9 from "three";
 
 // src/scene/color.ts
 var probe;
@@ -6591,7 +7853,7 @@ function drawSky(ctx, preset) {
   const x = skyU(angles.azimuth) * WIDTH;
   const y = skyV(angles.elevation) * HEIGHT;
   const radius = WIDTH * 0.3;
-  const color = new THREE8.Color(preset.key.color);
+  const color = new THREE9.Color(preset.key.color);
   const strength = Math.min(1, preset.key.intensity / 3);
   for (const offset of [-WIDTH, 0, WIDTH]) {
     const glow = ctx.createRadialGradient(x + offset, y, 0, x + offset, y, radius);
@@ -6610,14 +7872,14 @@ function makeSkyEquirect(preset) {
   canvas.height = HEIGHT;
   const ctx = canvas.getContext("2d");
   drawSky(ctx, preset);
-  const texture = new THREE8.CanvasTexture(canvas);
-  texture.mapping = THREE8.EquirectangularReflectionMapping;
-  texture.colorSpace = THREE8.SRGBColorSpace;
+  const texture = new THREE9.CanvasTexture(canvas);
+  texture.mapping = THREE9.EquirectangularReflectionMapping;
+  texture.colorSpace = THREE9.SRGBColorSpace;
   return texture;
 }
 function buildEnvironment(renderer, preset) {
   const equirect = makeSkyEquirect(preset);
-  const pmrem = new THREE8.PMREMGenerator(renderer);
+  const pmrem = new THREE9.PMREMGenerator(renderer);
   const target = pmrem.fromEquirectangular(equirect);
   pmrem.dispose();
   equirect.dispose();
@@ -6628,11 +7890,11 @@ function buildEnvironment(renderer, preset) {
 }
 
 // src/scene/PaperLighting.tsx
-import { Fragment, jsx as jsx5, jsxs as jsxs2 } from "react/jsx-runtime";
+import { Fragment as Fragment2, jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
 var toneMappings = {
-  agx: THREE9.AgXToneMapping,
-  neutral: THREE9.NeutralToneMapping,
-  filmic: THREE9.ACESFilmicToneMapping
+  agx: THREE10.AgXToneMapping,
+  neutral: THREE10.NeutralToneMapping,
+  filmic: THREE10.ACESFilmicToneMapping
 };
 function mulberry322(seed) {
   let a = seed;
@@ -6689,15 +7951,15 @@ function makeGoboTexture(kind) {
       }
     }
   }
-  const texture = new THREE9.CanvasTexture(canvas);
-  texture.wrapS = texture.wrapT = THREE9.RepeatWrapping;
+  const texture = new THREE10.CanvasTexture(canvas);
+  texture.wrapS = texture.wrapT = THREE10.RepeatWrapping;
   return texture;
 }
 function StudioLight({ rig }) {
   const gl = useThree2((s) => s.gl);
   const scene = useThree2((s) => s.scene);
   const sky = `${rig.sky.zenith}|${rig.sky.horizon}|${rig.sky.ground}|${rig.key.color}|${rig.key.intensity}|${rig.key.position.join()}`;
-  useEffect6(() => {
+  useEffect7(() => {
     const environment = buildEnvironment(gl, rig);
     const previous = scene.environment;
     scene.environment = environment.texture;
@@ -6706,7 +7968,7 @@ function StudioLight({ rig }) {
       environment.dispose();
     };
   }, [gl, scene, sky]);
-  useEffect6(() => {
+  useEffect7(() => {
     const previous = scene.environmentIntensity;
     scene.environmentIntensity = rig.studio;
     return () => {
@@ -6727,13 +7989,13 @@ function PaperLighting({
   contactShadow = true,
   environment = true
 }) {
-  const p = useMemo4(() => rig ?? resolveLighting(preset, light), [rig, preset, light]);
+  const p = useMemo5(() => rig ?? resolveLighting(preset, light), [rig, preset, light]);
   const mapSize = shadowMapSize ?? p.shadow.mapSize;
   const castShadow = mapSize > 0;
   const reduced = usePrefersReducedMotion(reducedMotion);
   const gl = useThree2((s) => s.gl);
   const scene = useThree2((s) => s.scene);
-  useEffect6(() => {
+  useEffect7(() => {
     const previousExposure = gl.toneMappingExposure;
     const previousFilm = gl.toneMapping;
     gl.toneMappingExposure = p.exposure;
@@ -6743,23 +8005,23 @@ function PaperLighting({
       gl.toneMapping = previousFilm;
     };
   }, [gl, p.exposure, p.film]);
-  useEffect6(() => {
+  useEffect7(() => {
     if (!p.fog) return;
     const previous = scene.fog;
-    scene.fog = new THREE9.Fog(p.fog.color, p.fog.near, p.fog.far);
+    scene.fog = new THREE10.Fog(p.fog.color, p.fog.near, p.fog.far);
     return () => {
       scene.fog = previous;
     };
   }, [scene, p.fog]);
-  const goboMap = useMemo4(() => p.gobo ? makeGoboTexture(p.gobo.kind) : null, [p.gobo?.kind]);
-  useEffect6(() => () => goboMap?.dispose(), [goboMap]);
+  const goboMap = useMemo5(() => p.gobo ? makeGoboTexture(p.gobo.kind) : null, [p.gobo?.kind]);
+  useEffect7(() => () => goboMap?.dispose(), [goboMap]);
   const driftRef = useRef4(0);
-  useFrame2((_, delta) => {
+  useFrame4((_, delta) => {
     if (!goboMap || !p.gobo || reduced) return;
     driftRef.current += delta * p.gobo.drift;
     goboMap.offset.set(driftRef.current, driftRef.current * 0.6);
   });
-  return /* @__PURE__ */ jsxs2(Fragment, { children: [
+  return /* @__PURE__ */ jsxs3(Fragment2, { children: [
     p.studio > 0 && (environment ? /* @__PURE__ */ jsx5(StudioLight, { rig: p }) : (
       // The studio light degrades rather than disappearing. A hemisphere
       // is the cheap half of what the room does — light from above, a
@@ -6817,15 +8079,15 @@ function PaperLighting({
 }
 
 // src/scene/backdrop.tsx
-import * as THREE10 from "three";
-import { useEffect as useEffect7, useState as useState4 } from "react";
+import * as THREE11 from "three";
+import { useEffect as useEffect8, useState as useState4 } from "react";
 import { useThree as useThree3 } from "@react-three/fiber";
 function PaperBackdrop({ backdrop }) {
   const scene = useThree3((s) => s.scene);
   const size = useThree3((s) => s.size);
   const [image, setImage] = useState4(null);
   const src = backdrop?.image ?? "";
-  useEffect7(() => {
+  useEffect8(() => {
     if (!src) {
       setImage(null);
       return;
@@ -6841,7 +8103,7 @@ function PaperBackdrop({ backdrop }) {
     };
   }, [src]);
   const key = JSON.stringify({ backdrop: backdrop ?? null, w: size.width, h: size.height, loaded: !!image });
-  useEffect7(() => {
+  useEffect8(() => {
     if (!backdrop) return;
     const previous = scene.background;
     const texture = paintBackdrop(backdrop, size.width, size.height, image);
@@ -6877,15 +8139,15 @@ function paintBackdrop(backdrop, width, height, image) {
       ctx.globalAlpha = 1;
     }
   }
-  const texture = new THREE10.CanvasTexture(canvas);
-  texture.colorSpace = THREE10.SRGBColorSpace;
+  const texture = new THREE11.CanvasTexture(canvas);
+  texture.colorSpace = THREE11.SRGBColorSpace;
   return texture;
 }
 
 // src/field/dropZones.tsx
-import * as THREE11 from "three";
-import { createContext as createContext2, useContext as useContext2, useEffect as useEffect8, useMemo as useMemo5, useRef as useRef5, useSyncExternalStore } from "react";
-import { jsx as jsx6, jsxs as jsxs3 } from "react/jsx-runtime";
+import * as THREE12 from "three";
+import { createContext as createContext2, useContext as useContext2, useEffect as useEffect9, useMemo as useMemo6, useRef as useRef5, useSyncExternalStore } from "react";
+import { jsx as jsx6, jsxs as jsxs4 } from "react/jsx-runtime";
 var DropZoneRegistry = class {
   zones = /* @__PURE__ */ new Map();
   hoveredId = null;
@@ -6942,10 +8204,10 @@ function DropZone(props) {
   const registry4 = useContext2(DropZoneContext);
   const { id, accept, bounds, highlight = "glow", onPlace } = props;
   const place = useRef5(onPlace);
-  useEffect8(() => {
+  useEffect9(() => {
     place.current = onPlace;
   }, [onPlace]);
-  useEffect8(() => {
+  useEffect9(() => {
     if (!registry4) return;
     return registry4.register({
       id,
@@ -6963,15 +8225,15 @@ function DropZoneVisual({ registry: registry4, config }) {
   const hovered = registry4.hovered === config.id;
   const style = config.highlight ?? "glow";
   const [w, h] = config.bounds.size;
-  const edges = useMemo5(() => {
-    const plane = new THREE11.PlaneGeometry(w, h);
-    const geo = new THREE11.EdgesGeometry(plane);
+  const edges = useMemo6(() => {
+    const plane = new THREE12.PlaneGeometry(w, h);
+    const geo = new THREE12.EdgesGeometry(plane);
     plane.dispose();
     return geo;
   }, [w, h]);
-  useEffect8(() => () => edges.dispose(), [edges]);
-  return /* @__PURE__ */ jsxs3("group", { position: config.bounds.position, children: [
-    style !== "outline" && /* @__PURE__ */ jsxs3("mesh", { children: [
+  useEffect9(() => () => edges.dispose(), [edges]);
+  return /* @__PURE__ */ jsxs4("group", { position: config.bounds.position, children: [
+    style !== "outline" && /* @__PURE__ */ jsxs4("mesh", { children: [
       /* @__PURE__ */ jsx6("planeGeometry", { args: [w, h] }),
       /* @__PURE__ */ jsx6(
         "meshBasicMaterial",
@@ -7572,17 +8834,17 @@ registerLayout(colonnade);
 registerLayout(sheet);
 
 // src/PaperField.tsx
-import * as THREE16 from "three";
+import * as THREE17 from "three";
 import { gsap as gsap5 } from "gsap";
-import { Canvas, useFrame as useFrame5, useThree as useThree6 } from "@react-three/fiber";
-import { forwardRef as forwardRef2, useEffect as useEffect14, useMemo as useMemo9, useRef as useRef8 } from "react";
+import { Canvas, useFrame as useFrame7, useThree as useThree6 } from "@react-three/fiber";
+import { forwardRef as forwardRef2, useEffect as useEffect15, useMemo as useMemo10, useRef as useRef8 } from "react";
 
 // src/scene/release.tsx
 import { useThree as useThree4 } from "@react-three/fiber";
-import { useEffect as useEffect9 } from "react";
+import { useEffect as useEffect10 } from "react";
 function ReleaseContextOnUnmount() {
   const gl = useThree4((s) => s.gl);
-  useEffect9(
+  useEffect10(
     () => () => {
       gl.forceContextLoss();
       gl.dispose();
@@ -7638,15 +8900,15 @@ function resolveFieldSlotConfig(slot, fallback, index, layoutId, layoutOptions)
 }
 
 // src/field/fieldGroup.tsx
-import * as THREE13 from "three";
+import * as THREE14 from "three";
 import { gsap as gsap3 } from "gsap";
-import { useFrame as useFrame3 } from "@react-three/fiber";
-import { useEffect as useEffect11, useMemo as useMemo6, useRef as useRef6 } from "react";
+import { useFrame as useFrame5 } from "@react-three/fiber";
+import { useEffect as useEffect12, useMemo as useMemo7, useRef as useRef6 } from "react";
 import CustomShaderMaterial2 from "three-custom-shader-material";
 
 // src/content/atlas.ts
-import * as THREE12 from "three";
-import { useEffect as useEffect10, useState as useState5 } from "react";
+import * as THREE13 from "three";
+import { useEffect as useEffect11, useState as useState5 } from "react";
 var MAX_ATLAS = 4096;
 function atlasGrid(count, aspect = 1) {
   const cols = Math.max(1, Math.min(count, Math.ceil(Math.sqrt(count * Math.max(aspect, 0.01)))));
@@ -7655,7 +8917,7 @@ function atlasGrid(count, aspect = 1) {
 function useContentAtlas(contents, sheet2, stock) {
   const [atlas, setAtlas] = useState5(null);
   const stableContents = useStable(contents);
-  useEffect10(() => {
+  useEffect11(() => {
     let disposed = false;
     const aspect = sheet2.height / sheet2.width;
     const { cols, rows } = atlasGrid(contents.length, aspect);
@@ -7671,8 +8933,8 @@ function useContentAtlas(contents, sheet2, stock) {
     const ctx = canvas.getContext("2d");
     ctx.fillStyle = stock.color;
     ctx.fillRect(0, 0, canvas.width, canvas.height);
-    const texture = new THREE12.CanvasTexture(canvas);
-    texture.colorSpace = THREE12.SRGBColorSpace;
+    const texture = new THREE13.CanvasTexture(canvas);
+    texture.colorSpace = THREE13.SRGBColorSpace;
     texture.anisotropy = 4;
     setAtlas({ texture, cols, rows });
     const drawTile = (index, tile) => {
@@ -7841,7 +9103,7 @@ function fieldShapeStack(config, progress) {
 
 // src/field/fieldGroup.tsx
 import { jsx as jsx7 } from "react/jsx-runtime";
-var scratchObj = new THREE13.Object3D();
+var scratchObj = new THREE14.Object3D();
 var scratchAero = { position: [0, 0, 0], rotation: [0, 0, 0] };
 var FIELD_SEGMENT_CAP = 48;
 var FIELD_AUTO_CEILING = 128;
@@ -7864,7 +9126,7 @@ function FieldGroup({
     behavior ? config.behavior[behavior.progressParam] : 0
   );
   const buildStackAt = (progress) => fieldShapeStack(config, progress);
-  const initialStack = useMemo6(
+  const initialStack = useMemo7(
     () => buildStackAt(progressRef.current),
     [
       JSON.stringify(config.behavior ?? null),
@@ -7873,7 +9135,7 @@ function FieldGroup({
     ]
   );
   const structureKey = initialStack.map((i) => i.type).join("|");
-  const geometry = useMemo6(() => {
+  const geometry = useMemo7(() => {
     const floor = stackMinSegments(initialStack, config.sheet);
     const want = [0, 0];
     for (const p of PROGRESS_SAMPLES2) {
@@ -7902,28 +9164,28 @@ function FieldGroup({
       atlasIdx[i] = i;
       phase[i] = indices[i] * 0.618034 % 1 * 4;
     }
-    geo.setAttribute("aAtlas", new THREE13.InstancedBufferAttribute(atlasIdx, 1));
-    geo.setAttribute("aPhase", new THREE13.InstancedBufferAttribute(phase, 1));
-    geo.setAttribute("aBias", new THREE13.InstancedBufferAttribute(bias, 1));
+    geo.setAttribute("aAtlas", new THREE14.InstancedBufferAttribute(atlasIdx, 1));
+    geo.setAttribute("aPhase", new THREE14.InstancedBufferAttribute(phase, 1));
+    geo.setAttribute("aBias", new THREE14.InstancedBufferAttribute(bias, 1));
     return geo;
   }, [JSON.stringify(config.sheet), structureKey, count, autoCeiling]);
-  useEffect11(() => () => geometry.dispose(), [geometry]);
+  useEffect12(() => () => geometry.dispose(), [geometry]);
   const atlas = useContentAtlas(contents, config.sheet, stock);
-  const shader = useMemo6(() => {
+  const shader = useMemo7(() => {
     const composed = buildDisplacementGLSL(initialStack, config.sheet);
     const uniforms = {};
     for (const [name, value] of Object.entries(composed.uniforms)) {
       uniforms[name] = {
-        value: Array.isArray(value) && value.length === 2 ? new THREE13.Vector2(...value) : value
+        value: Array.isArray(value) && value.length === 2 ? new THREE14.Vector2(...value) : value
       };
     }
     uniforms.uPlTime = { value: 0 };
     uniforms.uAtlas = { value: null };
-    uniforms.uAtlasGrid = { value: new THREE13.Vector2(1, 1) };
+    uniforms.uAtlasGrid = { value: new THREE14.Vector2(1, 1) };
     uniforms.uBackDarken = {
       value: 1 - Math.min(0.45, 0.12 + config.sheet.thickness * 0.9) * stock.opacity
     };
-    uniforms.uStockColor = { value: new THREE13.Color(stock.color) };
+    uniforms.uStockColor = { value: new THREE14.Color(stock.color) };
     uniforms.uShowThrough = { value: config.surface.showThrough ?? stock.showThrough };
     Object.assign(uniforms, translucencyUniforms(config.surface.translucency ?? stock.translucency, rig));
     return {
@@ -7938,19 +9200,19 @@ function FieldGroup({
     config.surface.showThrough,
     config.surface.translucency
   ]);
-  useEffect11(() => {
+  useEffect12(() => {
     const values = translucencyValues(config.surface.translucency ?? stock.translucency, rig);
     shader.uniforms.uTranslucency.value = values.translucency;
     shader.uniforms.uBackLightDir.value.copy(values.direction);
     shader.uniforms.uBackLightColor.value.copy(values.color);
     shader.uniforms.uAmbientTransmission.value = values.ambient;
   }, [shader, rig, config.surface.translucency, stock.translucency]);
-  useEffect11(() => {
+  useEffect12(() => {
     if (!atlas) return;
     shader.uniforms.uAtlas.value = atlas.texture;
     shader.uniforms.uAtlasGrid.value.set(atlas.cols, atlas.rows);
   }, [atlas, shader]);
-  useEffect11(() => {
+  useEffect12(() => {
     if (!behavior || shared.reduced) return;
     const state = { p: progressRef.current };
     const tween = gsap3.to(state, {
@@ -7968,7 +9230,7 @@ function FieldGroup({
     };
   }, [structureKey, shared.reduced]);
   const meshRef = useRef6(null);
-  useFrame3(({ clock }) => {
+  useFrame5(({ clock }) => {
     const mesh = meshRef.current;
     if (!mesh) return;
     const elapsed = clock.elapsedTime - Math.max(shared.mountTimeRef.current, 0);
@@ -7978,7 +9240,7 @@ function FieldGroup({
       for (const [name, value] of Object.entries(values)) {
         const uniform = shader.uniforms[name];
         if (!uniform) continue;
-        if (uniform.value instanceof THREE13.Vector2 && Array.isArray(value)) {
+        if (uniform.value instanceof THREE14.Vector2 && Array.isArray(value)) {
           uniform.value.set(value[0], value[1]);
         } else {
           uniform.value = value;
@@ -8063,13 +9325,13 @@ function FieldGroup({
         children: /* @__PURE__ */ jsx7(
           CustomShaderMaterial2,
           {
-            baseMaterial: THREE13.MeshStandardMaterial,
+            baseMaterial: THREE14.MeshStandardMaterial,
             vertexShader: shader.vertexShader,
             fragmentShader: shader.fragmentShader,
             uniforms: shader.uniforms,
             roughness: stock.roughness,
             metalness: 0,
-            side: THREE13.DoubleSide
+            side: THREE14.DoubleSide
           },
           `${structureKey}:${count}`
         )
@@ -8115,8 +9377,8 @@ var easeOut = (t) => 1 - (1 - t) ** 3;
 var easeInOut = (t) => t < 0.5 ? 2 * t * t : 1 - (-2 * t + 2) ** 2 / 2;
 
 // src/field/backingSheet.tsx
-import * as THREE14 from "three";
-import { useEffect as useEffect12, useMemo as useMemo7 } from "react";
+import * as THREE15 from "three";
+import { useEffect as useEffect13, useMemo as useMemo8 } from "react";
 
 // src/content/backing.ts
 function silhouetteRects(o, count) {
@@ -8181,7 +9443,7 @@ function roundedRect(ctx, x, y, w, h, r) {
 }
 
 // src/field/backingSheet.tsx
-import { jsx as jsx8, jsxs as jsxs4 } from "react/jsx-runtime";
+import { jsx as jsx8, jsxs as jsxs5 } from "react/jsx-runtime";
 var BACKING_TINT = "#f3ecdd";
 function BackingSheet({
   options,
@@ -8189,7 +9451,7 @@ function BackingSheet({
   removed
 }) {
   const { width, height } = sheetBackingSize(options);
-  const canvas = useMemo7(() => {
+  const canvas = useMemo8(() => {
     if (typeof document === "undefined") return null;
     const c = document.createElement("canvas");
     const scale = Math.min(1024, Math.round(360 * Math.max(width, height))) / Math.max(width, height);
@@ -8197,26 +9459,26 @@ function BackingSheet({
     c.height = Math.max(2, Math.round(height * scale));
     return c;
   }, [width, height]);
-  const texture = useMemo7(() => canvas ? new THREE14.CanvasTexture(canvas) : null, [canvas]);
+  const texture = useMemo8(() => canvas ? new THREE15.CanvasTexture(canvas) : null, [canvas]);
   const removedKey = [...removed].sort((a, b) => a - b).join(",");
-  useEffect12(() => {
+  useEffect13(() => {
     if (!canvas || !texture) return;
     drawBacking(canvas, { options, count, tint: BACKING_TINT, removed });
     texture.needsUpdate = true;
   }, [canvas, texture, JSON.stringify(options), count, removedKey]);
-  useEffect12(() => () => texture?.dispose(), [texture]);
-  return /* @__PURE__ */ jsxs4("mesh", { receiveShadow: true, children: [
+  useEffect13(() => () => texture?.dispose(), [texture]);
+  return /* @__PURE__ */ jsxs5("mesh", { receiveShadow: true, children: [
     /* @__PURE__ */ jsx8("planeGeometry", { args: [width, height] }),
     /* @__PURE__ */ jsx8("meshStandardMaterial", { map: texture, color: "#ffffff", roughness: 0.92, metalness: 0 })
   ] });
 }
 
 // src/field/interactiveField.tsx
-import * as THREE15 from "three";
+import * as THREE16 from "three";
 import { gsap as gsap4 } from "gsap";
-import { useFrame as useFrame4, useThree as useThree5 } from "@react-three/fiber";
-import { useContext as useContext3, useEffect as useEffect13, useMemo as useMemo8, useRef as useRef7, useState as useState6 } from "react";
-import { jsx as jsx9, jsxs as jsxs5 } from "react/jsx-runtime";
+import { useFrame as useFrame6, useThree as useThree5 } from "@react-three/fiber";
+import { useContext as useContext3, useEffect as useEffect14, useMemo as useMemo9, useRef as useRef7, useState as useState6 } from "react";
+import { jsx as jsx9, jsxs as jsxs6 } from "react/jsx-runtime";
 var PICK_BEHAVIORS = /* @__PURE__ */ new Set(["peel", "carry"]);
 function InteractiveField(props) {
   const { papers, fallback, layoutId, layoutOptions, sheetOptions } = props;
@@ -8224,14 +9486,14 @@ function InteractiveField(props) {
   const layout = getLayout(layoutId);
   const reduced = usePrefersReducedMotion(props.reducedMotion);
   const contextRegistry = useContext3(DropZoneContext);
-  const registry4 = useMemo8(() => contextRegistry ?? new DropZoneRegistry(), [contextRegistry]);
+  const registry4 = useMemo9(() => contextRegistry ?? new DropZoneRegistry(), [contextRegistry]);
   const camera = useThree5((s) => s.camera);
   const gl = useThree5((s) => s.gl);
   const controls = useThree5((s) => s.controls);
   const [removed, setRemoved] = useState6(EMPTY_SET);
   const [slotPatches, setSlotPatches] = useState6({});
   const [slotStates, setSlotStates] = useState6({});
-  const slotConfigs = useMemo8(
+  const slotConfigs = useMemo9(
     () => papers.map((slot, i) => {
       const config = resolveFieldSlotConfig(slot, fallback, i, layoutId, layoutOptions);
       const patch = slotPatches[i];
@@ -8245,7 +9507,7 @@ function InteractiveField(props) {
       slotPatches
     ]
   );
-  const poses = useMemo8(
+  const poses = useMemo9(
     () => slotConfigs.map((_, i) => layout.pose(i, total, layoutOptions, 0, props.sheet)),
     [layoutId, JSON.stringify(layoutOptions), total, props.sheet.width, props.sheet.height]
   );
@@ -8265,10 +9527,10 @@ function InteractiveField(props) {
     }
     props.onSlotStateChange?.(i, state);
   };
-  const raycaster = useMemo8(() => new THREE15.Raycaster(), []);
-  const planeScratch = useMemo8(() => new THREE15.Plane(new THREE15.Vector3(0, 0, 1), 0), []);
-  const pointScratch = useMemo8(() => new THREE15.Vector3(), []);
-  const ndcScratch = useMemo8(() => new THREE15.Vector2(), []);
+  const raycaster = useMemo9(() => new THREE16.Raycaster(), []);
+  const planeScratch = useMemo9(() => new THREE16.Plane(new THREE16.Vector3(0, 0, 1), 0), []);
+  const pointScratch = useMemo9(() => new THREE16.Vector3(), []);
+  const ndcScratch = useMemo9(() => new THREE16.Vector2(), []);
   const planePoint = (clientX, clientY, planeZ) => {
     const rect = gl.domElement.getBoundingClientRect();
     ndcScratch.set(
@@ -8436,7 +9698,7 @@ function InteractiveField(props) {
     if (zone) settleInto(carried, zone);
     else returnHome(carried);
   };
-  useEffect13(() => {
+  useEffect14(() => {
     const move = (e) => onPointerMoveRef.current(e);
     const up = (e) => onPointerUpRef.current(e);
     window.addEventListener("pointermove", move);
@@ -8446,7 +9708,7 @@ function InteractiveField(props) {
       window.removeEventListener("pointerup", up);
     };
   }, []);
-  useFrame4((_, delta) => {
+  useFrame6((_, delta) => {
     const carried = carriedRef.current;
     if (!carried || carried.settling) return;
     const group = groupRefs.current[carried.slot];
@@ -8472,8 +9734,8 @@ function InteractiveField(props) {
       group.position.z = carried.homePose.position[2] + 0.15;
       handle.set("drive", carryDrive(speed));
       const lag = 0.25;
-      group.rotation.y += (THREE15.MathUtils.clamp(-vx * lag, -0.6, 0.6) - group.rotation.y) * 0.12;
-      group.rotation.x += (THREE15.MathUtils.clamp(vy * lag * 0.7, -0.5, 0.5) - group.rotation.x) * 0.12;
+      group.rotation.y += (THREE16.MathUtils.clamp(-vx * lag, -0.6, 0.6) - group.rotation.y) * 0.12;
+      group.rotation.x += (THREE16.MathUtils.clamp(vy * lag * 0.7, -0.5, 0.5) - group.rotation.x) * 0.12;
     }
     const name = slotName(carried.slot);
     const zone = zonesLive().find(
@@ -8509,7 +9771,7 @@ function InteractiveField(props) {
     zoneIds: () => zonesLive().map((z25) => z25.id),
     slotState: (slot) => slotStates[slot] ?? "rest"
   };
-  useEffect13(() => {
+  useEffect14(() => {
     const ref = props.a11yRef;
     if (!ref) return;
     ref.current = {
@@ -8523,7 +9785,7 @@ function InteractiveField(props) {
       ref.current = null;
     };
   }, [props.a11yRef]);
-  return /* @__PURE__ */ jsxs5("group", { children: [
+  return /* @__PURE__ */ jsxs6("group", { children: [
     sheetOptions?.backing && /* @__PURE__ */ jsx9(BackingSheet, { options: sheetOptions, count: total, removed }),
     (props.zones ?? []).map((zone) => /* @__PURE__ */ jsx9(DropZoneVisual, { registry: registry4, config: zone }, zone.id)),
     slotConfigs.map((config, i) => {
@@ -8563,7 +9825,7 @@ function InteractiveField(props) {
 
 // src/field/keyboardMirror.tsx
 import { useState as useState7 } from "react";
-import { jsx as jsx10, jsxs as jsxs6 } from "react/jsx-runtime";
+import { jsx as jsx10, jsxs as jsxs7 } from "react/jsx-runtime";
 function fieldKeyboardStep(carry2, slot, key, controller) {
   if (!carry2) {
     if (key === "Enter" || key === " ") {
@@ -8625,9 +9887,9 @@ function FieldKeyboardMirror({
     if (handled) e.preventDefault();
     if (carry2 !== carrying) setCarrying(carry2);
   };
-  return /* @__PURE__ */ jsxs6("fieldset", { style: mirrorHidden, children: [
+  return /* @__PURE__ */ jsxs7("fieldset", { style: mirrorHidden, children: [
     /* @__PURE__ */ jsx10("legend", { children: "Interactive papers" }),
-    papers.map((slot, i) => /* @__PURE__ */ jsxs6(
+    papers.map((slot, i) => /* @__PURE__ */ jsxs7(
       "button",
       {
         type: "button",
@@ -8636,7 +9898,7 @@ function FieldKeyboardMirror({
         "aria-pressed": carrying?.slot === i,
         children: [
           paperLabel(slot, i),
-          carrying?.slot === i && /* @__PURE__ */ jsxs6("span", { "aria-live": "polite", children: [
+          carrying?.slot === i && /* @__PURE__ */ jsxs7("span", { "aria-live": "polite", children: [
             " ",
             "\u2014 carrying; zone ",
             controller.current?.zoneIds()[carrying.zoneIndex] ?? "none",
@@ -8710,17 +9972,17 @@ function fitCamera(layout, n, options, sheet2, fovDeg, aspect, margin = 1.06) {
 }
 
 // src/PaperField.tsx
-import { jsx as jsx11, jsxs as jsxs7 } from "react/jsx-runtime";
+import { jsx as jsx11, jsxs as jsxs8 } from "react/jsx-runtime";
 var PaperFieldMesh = forwardRef2(
   function PaperFieldMesh2(props, ref) {
     const reduced = usePrefersReducedMotion(props.reducedMotion);
-    const papers = useMemo9(
+    const papers = useMemo10(
       () => effectiveFieldPapers(props.papers, props.images),
       [props.papers, props.images]
     );
     const stablePapers = useStable(papers);
     const stablePreset = useStable(props.preset ?? null);
-    const groups = useMemo9(
+    const groups = useMemo10(
       () => groupFieldPapers(stablePapers, stablePreset ?? void 0),
       [stablePapers, stablePreset]
     );
@@ -8729,7 +9991,7 @@ var PaperFieldMesh = forwardRef2(
     const layout = getLayout(layoutId);
     const firstSheet = groups[0]?.config.sheet;
     const stableLayoutOptions = useStable(props.layoutOptions ?? {});
-    const layoutOptions = useMemo9(
+    const layoutOptions = useMemo10(
       // Sheet grids size their cells from the papers themselves — gutter is
       // then literally the spacing between stamps (explicit cell dims win).
       () => resolveLayoutOptions(layoutId, layout, stableLayoutOptions, firstSheet),
@@ -8744,7 +10006,7 @@ var PaperFieldMesh = forwardRef2(
     const driver = reduced ? "none" : props.motion?.driver ?? "autoplay";
     const speed = props.motion?.speed ?? 0.5;
     const entranceType = reduced ? "none" : props.entrance?.type ?? "rise";
-    useEffect14(() => {
+    useEffect15(() => {
       const prev = prevLayout.current;
       if (prev.id !== layoutId || JSON.stringify(prev.options) !== JSON.stringify(layoutOptions)) {
         morphRef.current = { from: prev, t: 0 };
@@ -8752,7 +10014,7 @@ var PaperFieldMesh = forwardRef2(
         prevLayout.current = { id: layoutId, options: layoutOptions };
       }
     }, [layoutId, layoutOptions]);
-    useEffect14(() => {
+    useEffect15(() => {
       if (driver !== "drag") return;
       const el = gl.domElement;
       let lastX = null;
@@ -8778,7 +10040,7 @@ var PaperFieldMesh = forwardRef2(
         window.removeEventListener("pointerup", up);
       };
     }, [driver, gl]);
-    useFrame5(({ clock }, delta) => {
+    useFrame7(({ clock }, delta) => {
       if (mountTimeRef.current < 0) mountTimeRef.current = clock.elapsedTime;
       if (driver === "autoplay") phaseRef.current += delta * speed * 0.02;
       if (driver === "drag") {
@@ -8820,7 +10082,7 @@ var PaperFieldMesh = forwardRef2(
         }
       ) });
     }
-    return /* @__PURE__ */ jsxs7("group", { ref, children: [
+    return /* @__PURE__ */ jsxs8("group", { ref, children: [
       sheetOptions?.backing && /* @__PURE__ */ jsx11(BackingSheet, { options: sheetOptions, count: total, removed: EMPTY_SET }),
       groups.map((group, gi) => /* @__PURE__ */ jsx11(
         FieldGroup,
@@ -8843,7 +10105,7 @@ function FitCamera(meshProps) {
   const imagesProp = useStable(meshProps.images ?? null);
   const presetProp = useStable(meshProps.preset ?? null);
   const optionsProp = useStable(meshProps.layoutOptions ?? {});
-  const field = useMemo9(() => {
+  const field = useMemo10(() => {
     const papers = effectiveFieldPapers(papersProp ?? void 0, imagesProp ?? void 0);
     const layoutId = meshProps.layout ?? "ring";
     const layout = getLayout(layoutId);
@@ -8851,8 +10113,8 @@ function FitCamera(meshProps) {
     const options = resolveLayoutOptions(layoutId, layout, optionsProp, sheet2);
     return { layout, n: papers.length, options, sheet: sheet2 ?? DEFAULT_SHEET };
   }, [papersProp, imagesProp, presetProp, meshProps.layout, optionsProp]);
-  useEffect14(() => {
-    if (!(camera instanceof THREE16.PerspectiveCamera)) return;
+  useEffect15(() => {
+    if (!(camera instanceof THREE17.PerspectiveCamera)) return;
     const { position, target } = fitCamera(
       field.layout,
       field.n,
@@ -8869,20 +10131,20 @@ function FitCamera(meshProps) {
 }
 var PaperField = forwardRef2(function PaperField2({ children, className, style, scene, ...meshProps }, ref) {
   const rig = sceneSchema.parse(scene ?? {});
-  const registry4 = useMemo9(() => new DropZoneRegistry(), []);
+  const registry4 = useMemo10(() => new DropZoneRegistry(), []);
   const a11yRef = useRef8(null);
-  const papers = useMemo9(
+  const papers = useMemo10(
     () => effectiveFieldPapers(meshProps.papers, meshProps.images),
     [meshProps.papers, meshProps.images]
   );
   const stablePapers = useStable(papers);
   const stablePreset = useStable(meshProps.preset ?? null);
-  const interactive = useMemo9(
+  const interactive = useMemo10(
     () => fieldIsInteractive(stablePapers, stablePreset ?? void 0, meshProps.interactive),
     [stablePapers, stablePreset, meshProps.interactive]
   );
-  return /* @__PURE__ */ jsx11("div", { className, style: { width: "100%", height: "100%", ...style }, children: /* @__PURE__ */ jsxs7(DropZoneContext.Provider, { value: registry4, children: [
-    /* @__PURE__ */ jsxs7(Canvas, { shadows: true, camera: { position: [0, 0.6, 5.2], fov: 45 }, dpr: [1, 2], children: [
+  return /* @__PURE__ */ jsx11("div", { className, style: { width: "100%", height: "100%", ...style }, children: /* @__PURE__ */ jsxs8(DropZoneContext.Provider, { value: registry4, children: [
+    /* @__PURE__ */ jsxs8(Canvas, { shadows: true, camera: { position: [0, 0.6, 5.2], fov: 45 }, dpr: [1, 2], children: [
       /* @__PURE__ */ jsx11(FitCamera, { ...meshProps }),
       /* @__PURE__ */ jsx11(PaperBackdrop, { backdrop: rig.backdrop }),
       /* @__PURE__ */ jsx11(PaperLighting, { preset: rig.lighting, light: rig.light, floor: -2.4, scale: 14 }),
@@ -9153,4 +10415,4 @@ export {
   describeConfig,
   buildAgentPayload
 };
-//# sourceMappingURL=chunk-E22ILEDO.js.map
+//# sourceMappingURL=chunk-NTDVOOBA.js.map