paperlab 0.7.0 → 0.8.0

package/dist/stage.cjs

@@ -1766,8 +1766,23 @@ var backdropSchema = import_zod15.z.object({
   /** Out of focus, for the same reason. */
   blur: import_zod15.z.number().min(0).max(1).default(0.2)
 });
+var floorSchema = import_zod15.z.object({
+  enabled: import_zod15.z.boolean().default(false),
+  /** Dark and matte: it is the ground, not the subject. */
+  color: import_zod15.z.string().default("#1a1917").describe("color"),
+  /**
+   * Where it lies, in the sheet's own space. The contact shadow falls here
+   * too, and a simulated sheet stops here — one floor, one height, so paper
+   * cannot land through the thing its shadow is on.
+   */
+  y: import_zod15.z.number().min(-4).max(0).default(-1.05),
+  /** How rough it is, 0 mirror to 1 chalk. Slate, by default. */
+  roughness: import_zod15.z.number().min(0).max(1).default(0.92)
+});
 var sceneSchema = import_zod15.z.object({
   lighting: import_zod15.z.enum(lightingNames).default("studio"),
+  /** The ground under the sheet — see `floorSchema`. Off unless asked for. */
+  floor: floorSchema.prefault({}),
   /** What is behind the sheet. Unset leaves the canvas alone. */
   backdrop: backdropSchema.optional(),
   /**
@@ -2195,6 +2210,34 @@ function buildEnvironment(renderer, preset) {
   };
 }
 
+// src/surface/damageContract.ts
+function roomLight(source) {
+  const room = source?.firelight?.room;
+  if (room === void 0 || !(room >= 0)) return 1;
+  return Math.min(1, room);
+}
+var DAMAGE_LOOK_DEFAULTS = {
+  emberWidth: 1.25,
+  emberIntensity: 1.05,
+  emberCoverage: 0.6,
+  emberFlicker: 1.65,
+  emberGlow: 1.25,
+  sparkle: 0.5,
+  // As wide as the char band (Noor, 2026-09-13): the lip has to be seen. At
+  // 0.95 mm it was a hairline tracing the edge.
+  lipWidth: 3.5,
+  charWidth: 3.5,
+  lipBrightness: 0.76,
+  charWarmth: 0.32,
+  charCracks: 0.45,
+  scorchReach: 9,
+  scorchDarkness: 0.86,
+  fingers: 1.95,
+  edgeWave: 13,
+  edgeBite: 6
+};
+var DAMAGE_CHANNELS = { char: 0, saturation: 1, heat: 2, presence: 3 };
+
 // src/scene/PaperLighting.tsx
 var import_jsx_runtime2 = require("react/jsx-runtime");
 var toneMappings = {
@@ -2293,7 +2336,8 @@ function PaperLighting({
   reducedMotion,
   shadowMapSize,
   contactShadow = true,
-  environment = true
+  environment = true,
+  damage
 }) {
   const p2 = (0, import_react2.useMemo)(() => rig ?? resolveLighting(preset, light), [rig, preset, light]);
   const mapSize = shadowMapSize ?? p2.shadow.mapSize;
@@ -2327,6 +2371,20 @@ function PaperLighting({
     driftRef.current += delta * p2.gobo.drift;
     goboMap.offset.set(driftRef.current, driftRef.current * 0.6);
   });
+  const keyIntensity = p2.gobo && goboMap ? p2.key.intensity * 3.2 : p2.key.intensity;
+  const keyRef = (0, import_react2.useRef)(null);
+  const ambientRef = (0, import_react2.useRef)(null);
+  const hemisphereRef = (0, import_react2.useRef)(null);
+  const roomRef = (0, import_react2.useRef)(1);
+  (0, import_fiber.useFrame)(() => {
+    const room = roomLight(damage);
+    if (room === 1 && roomRef.current === 1) return;
+    roomRef.current = room;
+    if (keyRef.current) keyRef.current.intensity = keyIntensity * room;
+    if (ambientRef.current) ambientRef.current.intensity = p2.ambient * room;
+    if (hemisphereRef.current) hemisphereRef.current.intensity = p2.studio * HEMISPHERE_STAND_IN * room;
+    if (p2.studio > 0 && environment) scene.environmentIntensity = p2.studio * room;
+  });
   return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_jsx_runtime2.Fragment, { children: [
     p2.studio > 0 && (environment ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(StudioLight, { rig: p2 }) : (
       // The studio light degrades rather than disappearing. A hemisphere
@@ -2337,19 +2395,21 @@ function PaperLighting({
       /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
         "hemisphereLight",
         {
+          ref: hemisphereRef,
           color: p2.sky.horizon,
           groundColor: p2.sky.ground,
           intensity: p2.studio * HEMISPHERE_STAND_IN
         }
       )
     )),
-    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("ambientLight", { intensity: p2.ambient }),
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("ambientLight", { ref: ambientRef, intensity: p2.ambient }),
     p2.gobo && goboMap ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
       "spotLight",
       {
+        ref: keyRef,
         position: p2.key.position,
         color: p2.key.color,
-        intensity: p2.key.intensity * 3.2,
+        intensity: keyIntensity,
         angle: p2.gobo.angle,
         penumbra: 0.5,
         decay: 0,
@@ -2362,9 +2422,10 @@ function PaperLighting({
     ) : /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
       "directionalLight",
       {
+        ref: keyRef,
         position: p2.key.position,
         color: p2.key.color,
-        intensity: p2.key.intensity,
+        intensity: keyIntensity,
         castShadow,
         "shadow-mapSize": [mapSize || 1, mapSize || 1],
         "shadow-radius": p2.shadow.radius,
@@ -4360,6 +4421,8 @@ var ClothSim = class {
   height;
   positions;
   prev;
+  /** Where the constructor laid every particle out — what {@link restore} puts back. */
+  laidOut;
   pinned;
   pinTargets;
   /**
@@ -4435,6 +4498,16 @@ var ClothSim = class {
    * cannot do this job: it moves paper, and a uniformly curled sheet in still
    * air has no business going anywhere.
    */
+  /**
+   * An acceleration on each particle from whatever is in the air around the
+   * sheet, xyz — the fire's updraft, so far (`DamageCoupling`). Not the wind:
+   * the wind is one thing blowing on the whole sheet, and this is local, a
+   * hot column over a burning rim and nothing a hand's width away.
+   *
+   * An acceleration rather than a force, so it lifts a soaked sheet no
+   * differently from a dry one: hot air does not know what paper weighs.
+   */
+  draught;
   restBend;
   /** For each bend spring, the particle between its ends; -1 for every other kind. */
   constraintMiddle;
@@ -4493,6 +4566,7 @@ var ClothSim = class {
       }
     }
     this.prev.set(this.positions);
+    this.laidOut = this.positions.slice();
     const idx = (r2, c2) => r2 * cols + c2;
     const links = [];
     const link = (a, b2, kind) => {
@@ -4520,6 +4594,7 @@ var ClothSim = class {
     this.constraintStiffness = new Float64Array(m).fill(1);
     this.broken = new Uint8Array(m);
     this.restBend = new Float64Array(m);
+    this.draught = new Float64Array(this.count * 3);
     this.constraintMiddle = new Int32Array(m).fill(-1);
     for (let k2 = 0; k2 < m; k2++) {
       const a = links[k2 * 3];
@@ -4610,6 +4685,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.
    *
@@ -4842,9 +4933,9 @@ var ClothSim = class {
       this.prev[i3] = x2;
       this.prev[i3 + 1] = y2;
       this.prev[i3 + 2] = z31;
-      p2[i3] = x2 + vx + ax * im * dt2;
-      p2[i3 + 1] = y2 + vy + (ay * im - gravity * 3.2) * dt2;
-      p2[i3 + 2] = z31 + vz + az * im * dt2;
+      p2[i3] = x2 + vx + (ax * im + this.draught[i3]) * dt2;
+      p2[i3 + 1] = y2 + vy + (ay * im - gravity * 3.2 + this.draught[i3 + 1]) * dt2;
+      p2[i3 + 2] = z31 + vz + (az * im + this.draught[i3 + 2]) * dt2;
       maxTravel = Math.max(maxTravel, vx * vx + vy * vy + vz * vz);
     }
     for (let k2 = 0; k2 < this.grabbed.length; k2++) {
@@ -4942,44 +5033,17 @@ var ClothSim = class {
   }
 };
 
-// src/surface/damageContract.ts
-var DAMAGE_LOOK_DEFAULTS = {
-  // §5 asks for 0.3–1 mm. 1.8 was outside it, and outside the slider's range
-  // it was tuned in — a control at its limit is a report that something
-  // underneath is wrong, which in this case was a fire nothing could see.
-  emberWidth: 0.9,
-  emberIntensity: 1.45,
-  emberCoverage: 0.6,
-  emberFlicker: 1.65,
-  emberGlow: 1.25,
-  sparkle: 0.5,
-  lipWidth: 1.2,
-  // Was 1.5, its slider's ceiling, which made the ash lip brighter than the
-  // paper it sits on. Ash is pale GREY; the reference's lip is dimmer than
-  // the sheet, not a highlight drawn on it.
-  lipBrightness: 0.85,
-  // Was 1, also a ceiling. At full warmth the char is milk chocolate —
-  // closer to cardboard than to charcoal (§5). Burnt paper keeps a little
-  // warmth in the plates and reads near black in a frame with a fire in it.
-  charWarmth: 0.3,
-  // Was 1, also a ceiling. The cracks are drawn as thin polygon outlines, so
-  // at full strength the char reads as a mosaic rather than as broken plates.
-  charCracks: 0.55,
-  scorchReach: 30,
-  scorchDarkness: 1.17,
-  fingers: 1.25,
-  edgeWave: 8.5,
-  edgeBite: 3.6
-};
-var DAMAGE_CHANNELS = { char: 0, saturation: 1, heat: 2, presence: 3 };
-
 // src/physics/damage.ts
-var { char: CHAR, saturation: SATURATION, presence: PRESENCE } = DAMAGE_CHANNELS;
+var { char: CHAR, saturation: SATURATION, heat: HEAT, presence: PRESENCE } = DAMAGE_CHANNELS;
 var GONE_BELOW = 128;
 var CHAR_SHRINK = 0.12;
+var ACROSS_SHRINK = 0.55;
+var UPDRAFT = 1.1;
+var UPDRAFT_OUT = 0.35;
 var CHAR_CURL = 6;
 var FRONT_GRADIENT = 16 * 16;
 var WET_MASS = 2;
+var TEAR_STRETCH = 1.5;
 var DamageCoupling = class {
   sim;
   source = null;
@@ -4989,12 +5053,31 @@ var DamageCoupling = class {
   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 = [];
   /**
-   * Per bend spring, how squarely it lies ACROSS the burn front, 0..1 — and
+   * 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 spring, how squarely it lies ACROSS the burn front, 0..1 — and
    * remembered once it has been.
    *
+   * It decides two things: how far the spring shrinks ({@link ACROSS_SHRINK})
+   * and, for a bend spring, which way the paper rolls ({@link CHAR_CURL}).
+   *
    * 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
@@ -5007,11 +5090,22 @@ var DamageCoupling = class {
    * gone by, the char behind it is uniform and says nothing about direction,
    * but the paper stays rolled the way it rolled.
    */
-  curlWeight;
+  acrossFront;
+  /** 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.curlWeight = new Float32Array(sim.constraintCount);
+    this.piece = new Int32Array(sim.count);
+    this.parent = new Int32Array(sim.count);
+    this.acrossFront = new Float32Array(sim.constraintCount);
   }
   /**
    * Bring the sim's levers up to date with `source`. Call before stepping.
@@ -5022,7 +5116,13 @@ var DamageCoupling = class {
   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.source) {
+      this.acrossFront.fill(0);
+      if (next && this.holed) {
+        this.rewind();
+        this.gone.fill(0);
+      }
+    }
     this.source = next;
     if (!next) {
       this.reset();
@@ -5042,12 +5142,13 @@ var DamageCoupling = class {
    * 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 a band of a single particle's width, with live
-   * paper pulling it both ways, is left averaging between them.
+   * 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 p2 = sim.positions;
     const { cols, rows } = sim;
     const cellX = cols > 1 ? sim.width / (cols - 1) : 0;
@@ -5055,6 +5156,7 @@ var DamageCoupling = class {
     for (const g of this.followers) {
       const r2 = g / cols | 0;
       const c2 = g % cols;
+      const own = piece[g];
       let sx = 0;
       let sy = 0;
       let sz = 0;
@@ -5066,7 +5168,7 @@ var DamageCoupling = class {
           const nc = c2 + dc;
           if (dr === 0 && dc === 0 || nc < 0 || nc >= cols) continue;
           const j3 = nr * cols + nc;
-          if (gone[j3]) continue;
+          if (gone[j3] || piece[j3] !== own) continue;
           const j32 = j3 * 3;
           sx += p2[j32] - dc * cellX;
           sy += p2[j32 + 1] + dr * cellY;
@@ -5081,6 +5183,70 @@ var DamageCoupling = class {
       p2[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 p2 = 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, j3) => {
+      const dc = i % cols - j3 % cols;
+      const dr = (i / cols | 0) - (j3 / cols | 0);
+      const rest = (dc * cellX) ** 2 + (dr * cellY) ** 2;
+      const i3 = i * 3;
+      const j32 = j3 * 3;
+      const now = (p2[i3] - p2[j32]) ** 2 + (p2[i3 + 1] - p2[j32 + 1]) ** 2 + (p2[i3 + 2] - p2[j32 + 2]) ** 2;
+      return now > rest * limit;
+    };
+    for (const t of this.rim) {
+      if (torn[t]) continue;
+      const a = original[t * 3];
+      const b2 = original[t * 3 + 1];
+      const c2 = original[t * 3 + 2];
+      if (!stretched(a, b2) && !stretched(b2, c2) && !stretched(c2, 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;
@@ -5096,8 +5262,10 @@ var DamageCoupling = class {
     }
   }
   read(pixels) {
-    const { sim, gone, particleTexel, curlWeight, size } = this;
+    const { sim, gone, particleTexel, acrossFront, size } = this;
     const {
+      draught,
+      cols,
       invMass,
       restLength,
       naturalLength,
@@ -5108,12 +5276,25 @@ var DamageCoupling = class {
       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);
+      const heat = isGone ? 0 : pixels[t + HEAT] / 255;
+      const lift = heat > 0.15 ? (heat - 0.15) / 0.85 : 0;
+      const i3 = i * 3;
+      draught[i3] = 0;
+      draught[i3 + 1] = UPDRAFT * lift;
+      draught[i3 + 2] = UPDRAFT * UPDRAFT_OUT * lift;
     }
+    if (rewound) this.rewind();
+    this.holed = holed;
+    this.rimStale = true;
     for (let k2 = 0; k2 < sim.constraintCount; k2++) {
       const a = constraintA[k2];
       const b2 = constraintB[k2];
@@ -5130,54 +5311,125 @@ var DamageCoupling = class {
         samples = 3;
       }
       const char = charSum / (samples * 255);
-      restLength[k2] = naturalLength[k2] * (1 - CHAR_SHRINK * char);
+      const t = particleTexel[m >= 0 ? m : a];
+      const x2 = t % size;
+      const y2 = t / size | 0;
+      const gx = pixels[(y2 * size + Math.min(size - 1, x2 + 2)) * 4 + CHAR] - pixels[(y2 * size + Math.max(0, x2 - 2)) * 4 + CHAR];
+      const gy = pixels[(Math.min(size - 1, y2 + 2) * size + x2) * 4 + CHAR] - pixels[(Math.max(0, y2 - 2) * size + x2) * 4 + CHAR];
+      const steep = gx * gx + gy * gy;
+      if (steep > FRONT_GRADIENT) {
+        const dc = b2 % cols - a % cols;
+        const dr = (b2 / cols | 0) - (a / cols | 0);
+        const along = dc * gx - dr * gy;
+        const span = dc * dc + dr * dr || 1;
+        const across2 = along * along / (span * steep);
+        if (across2 > acrossFront[k2]) acrossFront[k2] = across2;
+      }
+      const across = acrossFront[k2];
+      restLength[k2] = naturalLength[k2] * (1 - CHAR_SHRINK * char * (1 - (1 - ACROSS_SHRINK) * across));
       if (constraintKind[k2] === 2) {
-        const t = particleTexel[m];
-        const x2 = t % size;
-        const y2 = t / size | 0;
-        const gx = pixels[(y2 * size + Math.min(size - 1, x2 + 2)) * 4 + CHAR] - pixels[(y2 * size + Math.max(0, x2 - 2)) * 4 + CHAR];
-        const gy = pixels[(Math.min(size - 1, y2 + 2) * size + x2) * 4 + CHAR] - pixels[(Math.max(0, y2 - 2) * size + x2) * 4 + CHAR];
-        const steep = gx * gx + gy * gy;
-        if (steep > FRONT_GRADIENT) {
-          const across = (b2 - a === 2 ? gx * gx : gy * gy) / steep;
-          if (across > curlWeight[k2]) curlWeight[k2] = across;
-        }
         const span = naturalLength[k2];
-        restBend[k2] = CHAR_CURL * char * curlWeight[k2] * span * span / 8;
+        restBend[k2] = CHAR_CURL * char * across * 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 r2 = i;
+      while (parent[r2] !== r2) r2 = parent[r2];
+      while (parent[i] !== r2) {
+        const up = parent[i];
+        parent[i] = r2;
+        i = up;
       }
+      return r2;
+    };
+    for (let k2 = 0; k2 < sim.constraintCount; k2++) {
+      if (broken[k2]) continue;
+      const ra = find(constraintA[k2]);
+      const rb = find(constraintB[k2]);
+      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 r2 = i / cols | 0;
       const c2 = i % cols;
-      let beside = false;
-      for (let dr = -1; dr <= 1 && !beside; dr++) {
+      seen.length = 0;
+      votes.length = 0;
+      for (let dr = -1; dr <= 1; dr++) {
         const nr = r2 + dr;
         if (nr < 0 || nr >= rows) continue;
         for (let dc = -1; dc <= 1; dc++) {
           const nc = c2 + dc;
           if (nc < 0 || nc >= cols) continue;
-          if (!gone[nr * cols + nc]) {
-            beside = true;
-            break;
+          const j3 = nr * cols + nc;
+          if (gone[j3]) continue;
+          const at = seen.indexOf(piece[j3]);
+          if (at < 0) {
+            seen.push(piece[j3]);
+            votes.push(1);
+          } else {
+            votes[at]++;
           }
         }
       }
-      if (beside) followers.push(i);
+      if (seen.length === 0) continue;
+      let best = 0;
+      for (let k2 = 1; k2 < seen.length; k2++) {
+        if (votes[k2] > votes[best] || votes[k2] === votes[best] && seen[k2] < seen[best]) best = k2;
+      }
+      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.acrossFront.fill(0);
+    this.torn.fill(0);
+    this.mend = true;
+  }
   reset() {
     const { sim } = this;
+    if (this.holed) this.rewind();
+    sim.draught.fill(0);
     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.acrossFront.fill(0);
     this.followers = [];
+    this.holed = false;
     this.version = -1;
     sim.wake();
   }
@@ -6545,6 +6797,82 @@ function p({
 }
 var j2 = r.forwardRef(p);
 
+// src/surface/cutDistance.ts
+var CUT_REACH_MM = 16;
+var SPECK_TEXELS = 3;
+var GONE_BELOW2 = 128;
+var scratch = null;
+function cutDistance(pixels, size, texelMm, out) {
+  const n = size * size;
+  if (!scratch || scratch.size !== size) {
+    scratch = { size, dist: new Float32Array(n), kept: new Uint8Array(n), stack: new Int32Array(n) };
+  }
+  const { dist, kept, stack } = scratch;
+  const gone = (i) => pixels[i * 4 + 3] < GONE_BELOW2;
+  kept.fill(0);
+  const seen = dist;
+  seen.fill(0);
+  for (let start = 0; start < n; start++) {
+    if (seen[start] || !gone(start)) continue;
+    let top = 0;
+    let count = 0;
+    stack[top++] = start;
+    seen[start] = 1;
+    const first = top;
+    let head = 0;
+    while (head < top) {
+      const i = stack[head++];
+      count++;
+      const x2 = i % size;
+      const y2 = i / size | 0;
+      const next = [
+        x2 > 0 ? i - 1 : -1,
+        x2 < size - 1 ? i + 1 : -1,
+        y2 > 0 ? i - size : -1,
+        y2 < size - 1 ? i + size : -1
+      ];
+      for (const j3 of next) {
+        if (j3 < 0 || seen[j3] || !gone(j3)) continue;
+        seen[j3] = 1;
+        stack[top++] = j3;
+      }
+    }
+    if (count > SPECK_TEXELS) for (let k2 = first - 1; k2 < top; k2++) kept[stack[k2]] = 1;
+  }
+  const [dx, dy] = texelMm;
+  const dd = Math.hypot(dx, dy);
+  for (let i = 0; i < n; i++) dist[i] = kept[i] ? 0 : Number.POSITIVE_INFINITY;
+  for (let y2 = 0; y2 < size; y2++) {
+    for (let x2 = 0; x2 < size; x2++) {
+      const i = y2 * size + x2;
+      let v2 = dist[i];
+      if (v2 === 0) continue;
+      if (x2 > 0) v2 = Math.min(v2, dist[i - 1] + dx);
+      if (y2 > 0) {
+        v2 = Math.min(v2, dist[i - size] + dy);
+        if (x2 > 0) v2 = Math.min(v2, dist[i - size - 1] + dd);
+        if (x2 < size - 1) v2 = Math.min(v2, dist[i - size + 1] + dd);
+      }
+      dist[i] = v2;
+    }
+  }
+  for (let y2 = size - 1; y2 >= 0; y2--) {
+    for (let x2 = size - 1; x2 >= 0; x2--) {
+      const i = y2 * size + x2;
+      let v2 = dist[i];
+      if (v2 === 0) continue;
+      if (x2 < size - 1) v2 = Math.min(v2, dist[i + 1] + dx);
+      if (y2 < size - 1) {
+        v2 = Math.min(v2, dist[i + size] + dy);
+        if (x2 < size - 1) v2 = Math.min(v2, dist[i + size + 1] + dd);
+        if (x2 > 0) v2 = Math.min(v2, dist[i + size - 1] + dd);
+      }
+      dist[i] = v2;
+    }
+  }
+  for (let i = 0; i < n; i++) out[i] = Math.round(Math.min(dist[i], CUT_REACH_MM) / CUT_REACH_MM * 255);
+}
+
 // src/surface/compose.ts
 var THREE9 = __toESM(require("three"), 1);
 
@@ -6960,7 +7288,7 @@ var DAMAGE_CHUNK = (
   `
 uniform sampler2D uDamage;
 uniform float uDamageDetail;
-// (edgeWave mm, edgeBite mm, sparkle, \u2013) \u2014 see DamageLook.
+// (edgeWave mm, edgeBite mm, sparkle, charWidth mm) \u2014 see DamageLook.
 uniform vec4 uLook3;
 
 // The damage grid's texels sit ON the sheet \u2014 texel x at u = x / (N - 1), its
@@ -7097,6 +7425,8 @@ var DAMAGE_SHADE_CHUNK = (
   /* glsl */
   `
 uniform float uDamageTime;
+// How far each texel is from the cut, as a fraction of PL_CUT_REACH \u2014 see cutDistance.
+uniform sampler2D uDamageEdge;
 // 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
@@ -7106,6 +7436,10 @@ 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;
+// How far out a burnt edge's zones can be measured from the cut, mm: past
+// the widest lip, ember line, char and scorch the look allows by default.
+// The same number cutDistance encodes with, so the two cannot drift.
+const float PL_CUT_REACH = ${CUT_REACH_MM.toFixed(1)};
 
 vec3 plLinear(vec3 srgb) {
   return pow(srgb, vec3(2.2));
@@ -7162,7 +7496,12 @@ vec3 plScorchTint(float t) {
   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
+  // The dark end hands over to the char's black: a nearly neutral umber, not
+  // the saturated brown (#4F3323) it used to stop at. Beside black char that
+  // brown showed through wherever the band thinned, and turned the black
+  // brown \u2014 measured, the cold char's saturation went from 0.43 to 0.11 with
+  // the scorch's darkening switched off.
+  vec3 c6 = plLinear(vec3(0.169, 0.133, 0.110)); // #2B221C
   float s = clamp(t, 0.0, 1.0) * 6.0;
   // Each stop is blended with a SMOOTH step, not a linear one.
   //
@@ -7213,32 +7552,6 @@ void plDamage(inout vec4 color, inout float roughness) {
   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).
@@ -7252,38 +7565,61 @@ void plDamage(inout vec4 color, inout float roughness) {
     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));
+  // \u2500\u2500 The cut, measured \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
+  // How far this point is from the cut, in millimetres, out to PL_CUT_REACH \u2014
+  // the one measure every zone of a burnt edge is laid out on: the ash lip,
+  // the ember line, the char and the scorch (Ember_line annotated). Worked
+  // out on the CPU once per change of the field (cutDistance), where a speck
+  // of burnt-through paper can be told from a cut: measured here per pixel,
+  // every speck near the rim grew its own lip, char and scorch, and the bands
+  // came apart into blotches.
+  //
+  // Burnt AWAY, not charred: the black and the lip belong to paper beside a
+  // cut, so a burn toasts before it blackens.
+  //
+  // Read through the same warp as the cut, so the zones follow the edge that
+  // is drawn. Bilinear between a gone texel and the paper beside it, the
+  // drawn edge reads half a texel, which comes back off.
+  vec2 edgeTexel = 1.0 / vec2(textureSize(uDamageEdge, 0));
+  vec2 edgeWorld = uSheetSize / (vec2(textureSize(uDamageEdge, 0)) - 1.0);
+  float edgeRaw = texture2D(uDamageEdge, uv).r;
+  float edgeHalf = 0.5 * min(edgeWorld.x, edgeWorld.y) / PL_MM;
+  float xCut = max(edgeRaw * PL_CUT_REACH - edgeHalf, 0.0);
+  // A pixel or so of antialiasing, measured on the same measure.
+  float aa = clamp(fwidth(xCut), 0.05, 1.0);
+  // Which way the cut lies, from how the distance falls \u2014 and along the edge,
+  // across that. In the sheet's own space, so noise laid along it follows the
+  // rim wherever the rim goes.
+  vec2 toward = -vec2(
+    (texture2D(uDamageEdge, uv + vec2(edgeTexel.x, 0.0)).r - texture2D(uDamageEdge, uv - vec2(edgeTexel.x, 0.0)).r) / edgeWorld.x,
+    (texture2D(uDamageEdge, uv + vec2(0.0, edgeTexel.y)).r - texture2D(uDamageEdge, uv - vec2(0.0, edgeTexel.y)).r) / edgeWorld.y
+  );
+  vec2 tangentR = length(toward) > 1e-4 ? normalize(vec2(-toward.y, toward.x)) : vec2(1.0, 0.0);
+  // Paper with a cut within reach, eased out toward the reach.
+  float cutZone = 1.0 - smoothstep(PL_CUT_REACH - 2.0, PL_CUT_REACH - 0.5, xCut);
 
   // 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) {
+  if (d.r <= 0.0 && d.g <= 0.0 && d.a >= 1.0 && charBelow <= 0.0 && charWide <= 0.0 && edgeRaw >= 1.0 && e.a >= 1.0 && w.a >= 1.0 && n.a >= 1.0 && s.a >= 1.0) {
     return;
   }
 
   vec2 p = plLocal();
 
+  // The zones, out from the cut: the ash lip, the ember line on its outer
+  // edge, the char, then the scorch \u2014 each as wide as the look says, and
+  // uneven along the rim so none of them is a ribbon. The lip's unevenness
+  // stays inside the zone the ember gate allows it (lip plus bead).
+  float lipEdge = uLook1.y * mix(0.7, 1.1, plFbm(vec2(dot(p, tangentR) / (5.0 * PL_MM), 1.7)));
+  float charEnd = lipEdge + uLook0.x + uLook3.w * mix(0.8, 1.2, plFbm(vec2(dot(p, tangentR) / (7.0 * PL_MM), 4.3)));
+  // Further above the burn than below it \u2014 hot gas rises and cooks the paper
+  // over it (\xA74.5) \u2014 out to the scorch's full reach straight up, and about
+  // half of it below and beside.
+  vec2 upMm = normalize(upUv * uSheetSize);
+  float above = length(toward) > 1e-3 ? max(0.0, dot(-normalize(toward), upMm)) : 0.0;
+  float scorchEnd = charEnd + uLook2.y * mix(0.45, 1.0, above)
+    + (plFbm(vec2(dot(p, tangentR) / (4.0 * PL_MM), 3.1)) - 0.5) * uLook2.w * 2.5;
+
   // 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;
@@ -7335,27 +7671,64 @@ void plDamage(inout vec4 color, inout float roughness) {
   // 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);
+  // The colour INSIDE the scorch reads a smoothed c: the same char and the
+  // same reaches, without the fingers. The fingers belong to the front's
+  // silhouette (lead, below); carried into the ramp as well, a strong fingers
+  // setting swung the scorch between tan and near-black umber a few
+  // millimetres apart \u2014 a leopard print, not a toast.
+  float cSmooth = 1.0 - (1.0 - clamp(mix(d.r, soft, 0.65), 0.0, 1.0)) * (1.0 - clamp(0.62 * charBelow * 0.75, 0.0, 1.0)) * (1.0 - clamp(0.4 * charWide * 0.75, 0.0, 1.0));
+  cSmooth = clamp(cSmooth + ((plNoise(p * 300.0) - 0.5) * 0.05 + (plNoise(p * 90.0) - 0.5) * 0.04) * smoothstep(0.0, 0.1, cSmooth), 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);
+  // The front's teeth from the noisy c; filled in behind them from the smooth
+  // one, so a dip in the noise cannot open a patch of clean paper inside it.
+  float lead = max(smoothstep(0.02, 0.05, c), smoothstep(0.1, 0.2, cSmooth));
+  // The browns are done by 0.45, where the char's umber hand-over takes them:
+  // the ramp used to run on to 0.7, over the char, and most of what read as
+  // "char" was this ramp's darkest brown.
+  float ramp = smoothstep(0.05, 0.45, cSmooth);
+  // That toast is for paper with no cut near it \u2014 the first stage of a burn,
+  // before anything has gone through.
+  color.rgb *= mix(vec3(1.0), pow(plScorchTint(ramp), vec3(uLook2.z)), lead * (1.0 - cutZone));
+  // Round a cut, the scorch is a band of its own: dark, only a little lighter
+  // than the char it leads from, a shade warmer toward its outer edge, then a
+  // steep leading edge into clean paper (Ember_line annotated, zone 5: "steep
+  // leading edge \xB7 albedo only"). A black band beside a pale tan one was the
+  // contrast that read as wrong.
+  float scorchT = smoothstep(charEnd, scorchEnd, xCut);
+  vec3 scorchTint = mix(plLinear(vec3(0.24, 0.17, 0.12)), plLinear(vec3(0.42, 0.28, 0.17)), scorchT) / plLinear(vec3(0.90, 0.885, 0.855));
+  float scorchZone = (1.0 - smoothstep(scorchEnd - 0.35, scorchEnd + 0.35, xCut)) * cutZone;
+  color.rgb *= mix(vec3(1.0), pow(min(scorchTint, vec3(1.0)), vec3(uLook2.z)), scorchZone);
 
   // \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);
+  // From 0.3: the field carries char in about one texel beside the cut, so
+  // past a couple of millimetres c is mostly the scorch borrowed from below,
+  // and a zone that began at 0.5 was hardly ever char at all.
+  // Away from a cut, c only makes char where it is really high: at 0.3\u20130.6
+  // the finger noise pushed it across the line all through the scorch, and
+  // every crossing was a black island in the orange \u2014 a leopard print.
+  // Round a cut, the band from the lip out to charEnd; away from one, only
+  // where the toast has gone all the way to char.
+  float charBand = (1.0 - smoothstep(charEnd - 0.5, charEnd + 0.5, xCut)) * cutZone;
+  float charZone = max(smoothstep(0.6, 0.85, cSmooth) * (1.0 - cutZone), charBand);
   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);
+  // Black. Real char is a near-neutral black \u2014 (22, 20, 18) on the cold
+  // macro references, about 11% of the paper's value. The warm brown this
+  // used to be was Hero.png's char LIT BY ITS FLAMES, painted into the paper,
+  // which is why ours stayed orange on a frame with no fire in it. Warmth on
+  // char comes from the fire's light now, and goes when the fire does.
+  // charWarmth adds only a trace of brown to the black, and a warmer umber
+  // where the char hands over to the scorch.
+  vec3 body = mix(plLinear(vec3(0.086, 0.078, 0.071)), plLinear(vec3(0.11, 0.08, 0.06)), uLook1.w);
+  vec3 under = mix(plLinear(vec3(0.20, 0.15, 0.11)), plLinear(vec3(0.28, 0.16, 0.08)), uLook1.w);
   vec3 cracks = plLinear(vec3(0.039, 0.024, 0.016));    // #0A0604
-  vec3 charColor = mix(under, body, smoothstep(0.66, 1.0, c));
+  // Black through the band; the umber only in its outer millimetre.
+  float toUnder = mix(1.0 - smoothstep(0.45, 0.8, cSmooth), smoothstep(charEnd - 1.2, charEnd + 0.3, xCut), cutZone);
+  vec3 charColor = mix(body, under, toUnder);
   // 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));
@@ -7367,42 +7740,42 @@ void plDamage(inout vec4 color, inout float roughness) {
   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;
+  // A crust as wide as the char band, from the cut to lipEdge \u2014 the pale
+  // thing that makes a hole read as a hole on a black stage (Ember_line
+  // annotated, zone 2). It used to be held to about a millimetre, which at a
+  // reading distance is a hairline tracing the edge, not ash.
+  //
+  // 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. Mostly there, though \u2014
+  // it has to be seen.
+  float lipAlong = dot(p, tangentR) / (3.2 * PL_MM);
+  float lipBreak = smoothstep(0.1, 0.3, plFbm(vec2(lipAlong, 0.9)));
+  float lip = (1.0 - smoothstep(lipEdge - aa, lipEdge + aa, xCut)) * cutZone * lipBreak;
+  // Pale: the reference's #A49E9D up to a near-white grey, so it reads white
+  // beside the char. Still matte and still dimmer than the paper.
+  vec3 ash = plLinear(mix(vec3(0.643, 0.620, 0.616), vec3(0.84, 0.82, 0.81), 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;
+  // And the crust the ragged edge is made of. The cut is frayed at fibre
+  // scale, and the fray opened specks of void all through the first few
+  // millimetres \u2014 exactly where the lip lies \u2014 so at a reading distance the
+  // lip was grey specks in black. Paper inside the fray's band is kept, as
+  // ash, instead of cut away: the lip overhangs the hole a little, broken
+  // where the lip is broken, the way the reference's crust does.
+  float crust = lipBreak * cutZone * smoothstep(0.18, 0.3, d.a) * (1.0 - step(0.5, d.a));
+  color.rgb = mix(color.rgb, ash, crust);
+  roughness = mix(roughness, 0.99, crust);
+  // Raised, and crumbly rather than rounded: a smooth ridge round the hole is
+  // a cylinder, and a cylinder under a key light has a specular line down it
+  // however rough it is \u2014 the neon tube this once was.
+  plHeight += lip * (0.55 + 0.45 * plNoise(p * 700.0)) * 0.00016;
 
   // \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 s1 = dot(p, tangentR) / (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
@@ -7417,7 +7790,8 @@ void plDamage(inout vec4 color, inout float roughness) {
   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;
+  // On the lip's outer edge, between the ash and the char.
+  float band = smoothstep(lipEdge - aa, lipEdge + aa, xCut) * (1.0 - smoothstep(lipEdge + width - aa, lipEdge + width + aa, xCut)) * cutZone;
   // 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.
@@ -7437,13 +7811,15 @@ void plDamage(inout vec4 color, inout float roughness) {
   // 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 zoneEnd = lipEdge + uLook0.x;
+  float seam = smoothstep(lipEdge - aa, lipEdge + aa, xCut) * (1.0 - smoothstep(zoneEnd - 0.6, zoneEnd, xCut)) * cutZone;
   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;
 
+  // The crust stays, however the fray cut it.
+  d.a = mix(d.a, max(d.a, 0.5), step(0.5, crust));
   plDamageCut(color, d);
 }
 `
@@ -7554,6 +7930,7 @@ function composeSurface(surface, stock, thickness, maps = { hasFrontMap: false,
     chunks.push(DAMAGE_CHUNK, DAMAGE_SHADE_CHUNK);
     calls.push("plDamage(csm_DiffuseColor, csm_Roughness);");
     uniforms.uDamage = { value: null };
+    uniforms.uDamageEdge = { value: null };
     uniforms.uDamageDetail = { value: 1 };
     uniforms.uDamageTime = { value: 0 };
     const look = DAMAGE_LOOK_DEFAULTS;
@@ -7566,7 +7943,7 @@ function composeSurface(surface, stock, thickness, maps = { hasFrontMap: false,
     uniforms.uLook2 = {
       value: new THREE9.Vector4(look.charCracks, look.scorchReach, look.scorchDarkness, look.fingers)
     };
-    uniforms.uLook3 = { value: new THREE9.Vector4(look.edgeWave, look.edgeBite, look.sparkle, 0) };
+    uniforms.uLook3 = { value: new THREE9.Vector4(look.edgeWave, look.edgeBite, look.sparkle, look.charWidth) };
   }
   const cutting = [];
   const cuts = [];
@@ -7670,35 +8047,65 @@ function useLightRig(own) {
 var THREE10 = __toESM(require("three"), 1);
 var import_fiber4 = require("@react-three/fiber");
 var import_react9 = require("react");
-function useDamageTexture(source) {
-  const texture = (0, import_react9.useMemo)(() => {
+var MM_PER_WORLD = 210;
+function useDamageTexture(source, sheet2 = { width: 1, height: 1.4 }) {
+  const { width, height } = sheet2;
+  const textures = (0, import_react9.useMemo)(() => {
     if (!source) return null;
-    const t = new THREE10.DataTexture(
+    const damage = new THREE10.DataTexture(
       source.pixels,
       source.size,
       source.size,
       THREE10.RGBAFormat,
       THREE10.UnsignedByteType
     );
-    t.magFilter = THREE10.LinearFilter;
-    t.minFilter = THREE10.LinearFilter;
-    t.wrapS = THREE10.ClampToEdgeWrapping;
-    t.wrapT = THREE10.ClampToEdgeWrapping;
-    t.generateMipmaps = false;
-    t.colorSpace = THREE10.NoColorSpace;
-    t.flipY = false;
-    t.userData.version = source.version;
-    t.needsUpdate = true;
-    return t;
-  }, [source]);
-  (0, import_react9.useEffect)(() => () => texture?.dispose(), [texture]);
+    const edge = new THREE10.DataTexture(
+      new Uint8Array(source.size * source.size),
+      source.size,
+      source.size,
+      THREE10.RedFormat,
+      THREE10.UnsignedByteType
+    );
+    for (const t of [damage, edge]) {
+      t.magFilter = THREE10.LinearFilter;
+      t.minFilter = THREE10.LinearFilter;
+      t.wrapS = THREE10.ClampToEdgeWrapping;
+      t.wrapT = THREE10.ClampToEdgeWrapping;
+      t.generateMipmaps = false;
+      t.colorSpace = THREE10.NoColorSpace;
+      t.flipY = false;
+      t.unpackAlignment = 1;
+    }
+    measureEdge(source, edge, width, height);
+    damage.userData.version = source.version;
+    damage.needsUpdate = true;
+    return { damage, edge };
+  }, [source, width, height]);
+  (0, import_react9.useEffect)(
+    () => () => {
+      textures?.damage.dispose();
+      textures?.edge.dispose();
+    },
+    [textures]
+  );
   (0, import_fiber4.useFrame)(() => {
-    if (!source || !texture) return;
-    if (texture.userData.version === source.version) return;
-    texture.userData.version = source.version;
-    texture.needsUpdate = true;
+    if (!source || !textures) return;
+    if (textures.damage.userData.version === source.version) return;
+    textures.damage.userData.version = source.version;
+    textures.damage.needsUpdate = true;
+    measureEdge(source, textures.edge, width, height);
   });
-  return texture;
+  return textures;
+}
+function measureEdge(source, edge, width, height) {
+  const last = Math.max(1, source.size - 1);
+  cutDistance(
+    source.pixels,
+    source.size,
+    [width * MM_PER_WORLD / last, height * MM_PER_WORLD / last],
+    edge.image.data
+  );
+  edge.needsUpdate = true;
 }
 
 // src/surface/PaperMaterial.tsx
@@ -7715,7 +8122,7 @@ function PaperMaterial({
   damage
 }) {
   const rig = useLightRig(lighting);
-  const damageTexture = useDamageTexture(damage);
+  const damageTextures = useDamageTexture(damage, sheet2);
   const composed = composeSurface(
     surface,
     stock,
@@ -7723,7 +8130,7 @@ function PaperMaterial({
     {
       hasFrontMap: Boolean(texture),
       hasBackMap: Boolean(backTexture),
-      hasDamage: Boolean(damageTexture)
+      hasDamage: Boolean(damageTextures)
     },
     sheet2,
     rig,
@@ -7732,7 +8139,7 @@ function PaperMaterial({
   const bound = (0, import_react10.useMemo)(() => composed.uniforms, [composed.structureKey]);
   (0, import_react10.useEffect)(() => {
     for (const [key, uniform] of Object.entries(composed.uniforms)) {
-      if (!bound[key] || key === "uFrontMap" || key === "uBackMap" || key === "uDamage" || key === "uDamageDetail" || key === "uDamageTime" || key.startsWith("uLook")) {
+      if (!bound[key] || key === "uFrontMap" || key === "uBackMap" || key === "uDamage" || key === "uDamageEdge" || key === "uDamageDetail" || key === "uDamageTime" || key.startsWith("uLook")) {
         continue;
       }
       if (bound[key].value instanceof THREE11.Color && uniform.value instanceof THREE11.Color) {
@@ -7746,8 +8153,9 @@ function PaperMaterial({
   (0, import_react10.useEffect)(() => {
     if (bound.uFrontMap) bound.uFrontMap.value = texture;
     if (bound.uBackMap) bound.uBackMap.value = backTexture ?? null;
-    if (bound.uDamage) bound.uDamage.value = damageTexture;
-  }, [bound, texture, backTexture, damageTexture]);
+    if (bound.uDamage) bound.uDamage.value = damageTextures?.damage ?? null;
+    if (bound.uDamageEdge) bound.uDamageEdge.value = damageTextures?.edge ?? null;
+  }, [bound, texture, backTexture, damageTextures]);
   (0, import_fiber5.useFrame)((state) => {
     if (!bound.uDamageDetail) return;
     if (bound.uDamageTime) {
@@ -7780,7 +8188,7 @@ function PaperMaterial({
         v2(look.edgeWave, d.edgeWave),
         v2(look.edgeBite, d.edgeBite),
         v2(look.sparkle, d.sparkle),
-        0
+        v2(look.charWidth, d.charWidth)
       );
     }
     const detail = damage?.detail ?? 1;
@@ -8491,7 +8899,11 @@ var PaperMesh = (0, import_react12.forwardRef)(function PaperMesh2(props, ref) {
       coupling?.update(props.damage);
       sim.step(delta);
       const moved = !sim.asleep;
-      if (moved) coupling?.follow();
+      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);