paperlab 0.5.2 → 0.6.0

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

@@ -68,7 +68,7 @@ function segmentsForSine(span, amplitude, wavelength, tol = SAG_TOL) {
 }
 
 // src/config/schema.ts
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 
 // src/behaviors/peel.ts
 import { z as z2 } from "zod";
@@ -231,15 +231,169 @@ var peel = {
 };
 
 // src/behaviors/unroll.ts
+import { z as z4 } from "zod";
+
+// src/deformers/roll.ts
 import { z as z3 } from "zod";
-var unrollOptionsSchema = z3.object({
+var rollOptionsSchema = z3.object({
+  /** Direction of rolling in the sheet plane, degrees. 0 = +x, 90 = +y. */
+  angle: z3.number().min(-360).max(360).default(90),
+  /** Signed distance (along the roll direction, from sheet center) where the roll begins. */
+  boundary: z3.number().min(-20).max(20).default(0),
+  /** Radius of the OUTERMOST wrap — the one the flat sheet leaves the roll on. */
+  radius: z3.number().min(0.01).max(2).default(0.12),
+  /** Gap between consecutive wraps, in world units. 0 = a bare cylinder. */
+  thickness: z3.number().min(0).max(0.2).default(0.015)
+});
+var DEG2 = Math.PI / 180;
+var TAU = Math.PI * 2;
+var MIN_RADIUS_FRACTION = 0.08;
+function windAngle(s, r0, k) {
+  if (k <= 0) return s / r0;
+  const rMin = r0 * MIN_RADIUS_FRACTION;
+  const thetaFloor = (r0 - rMin) / k;
+  const sFloor = r0 * thetaFloor - k * thetaFloor * thetaFloor / 2;
+  if (s >= sFloor) return thetaFloor + (s - sFloor) / rMin;
+  return 2 * s / (r0 + Math.sqrt(r0 * r0 - 2 * k * s));
+}
+function windRadius(theta, r0, k) {
+  return Math.max(r0 - k * theta, r0 * MIN_RADIUS_FRACTION);
+}
+function rollRadius(length, core, thickness) {
+  return Math.sqrt(core * core + Math.max(0, length) * thickness / Math.PI);
+}
+var roll = {
+  id: "roll",
+  label: "Roll",
+  defaults: rollOptionsSchema.parse({}),
+  optionsSchema: rollOptionsSchema,
+  geometry: {
+    minSegments: 48,
+    // The INNERMOST wrap is the tightest curvature on the sheet, so it sets
+    // the density — the outer one used to, back when the spiral grew outward.
+    // Floored at a fraction of the outer radius because segment count scales
+    // as 1/√r: a roll wound to a hair's breadth would otherwise ask for a
+    // grid nobody can afford, to resolve a few square millimetres at the core.
+    autoSegments: (o, sheet2) => {
+      const span = spanAlong(sheet2, o.angle);
+      const wound = Math.max(0, span / 2 - o.boundary);
+      const k = o.thickness / TAU;
+      return segmentsForArc(span, windRadius(windAngle(wound, o.radius, k), o.radius, k));
+    },
+    axis: (o) => o.angle
+  },
+  displace(out, _uv, o) {
+    const dirX = Math.cos(o.angle * DEG2);
+    const dirY = Math.sin(o.angle * DEG2);
+    const d = out.x * dirX + out.y * dirY;
+    const s = d - o.boundary;
+    if (s <= 0) return;
+    const k = o.thickness / TAU;
+    const theta = windAngle(s, o.radius, k);
+    const r = windRadius(theta, o.radius, k) - out.z;
+    const newD = o.boundary + r * Math.sin(theta);
+    const newZ = o.radius - r * Math.cos(theta);
+    out.x += dirX * (newD - d);
+    out.y += dirY * (newD - d);
+    out.z = newZ;
+  },
+  glsl: {
+    chunk: (
+      /* glsl */
+      `
+void FN(inout vec3 p, vec2 uv, float t) {
+  vec2 dir = vec2(cos(U_angle), sin(U_angle));
+  float d = dot(p.xy, dir);
+  float s = d - U_boundary;
+  if (s <= 0.0) return;
+  float k = U_thickness / 6.2831853071795864;
+  float rMin = U_radius * 0.08;
+  float thetaFloor = (U_radius - rMin) / max(k, 1e-9);
+  float sFloor = U_radius * thetaFloor - 0.5 * k * thetaFloor * thetaFloor;
+  float theta = k <= 0.0
+    ? s / U_radius
+    : (s >= sFloor
+        ? thetaFloor + (s - sFloor) / rMin
+        : (2.0 * s) / (U_radius + sqrt(U_radius * U_radius - 2.0 * k * s)));
+  float r = max(U_radius - k * theta, rMin) - p.z;
+  float newD = U_boundary + r * sin(theta);
+  float newZ = U_radius - r * cos(theta);
+  p.xy += dir * (newD - d);
+  p.z = newZ;
+}
+`
+    ),
+    uniforms: (o) => ({
+      angle: o.angle * DEG2,
+      boundary: o.boundary,
+      radius: o.radius,
+      thickness: o.thickness
+    })
+  }
+};
+
+// src/behaviors/unroll.ts
+var unrollOptionsSchema = z4.object({
   /** 0 = fully rolled cylinder, 1 = flat sheet. */
-  progress: z3.number().min(0).max(1).default(0.5),
-  /** How tightly the paper is wound. */
-  tightness: z3.number().min(0).max(1).default(0.5),
+  progress: z4.number().min(0).max(1).default(0.5),
+  /** How tightly the paper is wound — thin layers and many turns, or few and fat. */
+  tightness: z4.number().min(0).max(1).default(0.5),
   /** Idle rocking of the rolled end. */
-  sway: z3.number().min(0).max(1).default(0.25)
+  sway: z4.number().min(0).max(1).default(0.25),
+  /** Which end of the sheet holds the roll. `top` hangs the paper below it. */
+  from: z4.enum(["bottom", "top"]).default("bottom"),
+  /** Radius of the tube the paper is wound onto — the roll never shrinks past it. */
+  core: z4.number().min(5e-3).max(0.5).default(0.03),
+  /**
+   * Paper already hanging at `progress` 0, in world units.
+   *
+   * A roll on a holder is never a bare cylinder: there is always a leaf out,
+   * because that is what you take hold of. Starting from nothing showing
+   * reads as a fresh roll still in its wrapper.
+   */
+  tail: z4.number().min(0).max(20).default(0),
+  /**
+   * How far below the roll the paper lands, in world units. Omit and it
+   * hangs forever.
+   *
+   * Paper that reaches the ground does not stop and does not carry on
+   * through it: it creases and runs out flat. Everything past this distance
+   * turns a right angle and lies down.
+   */
+  floor: z4.number().min(0.1).max(50).optional(),
+  /**
+   * Hold the roll still in space and let the paper hang off it, instead of
+   * letting the roll ride along with the shrinking wound region.
+   */
+  fixed: z4.boolean().default(false)
 });
+var LOOSE = 0.1;
+var TIGHT = 0.02;
+function layerThickness(tightness) {
+  return LOOSE - tightness * (LOOSE - TIGHT);
+}
+function sweep(o, sheet2) {
+  const maxRadius = rollRadius(sheet2.height, o.core, layerThickness(o.tightness));
+  const tail = Math.min(o.tail, sheet2.height);
+  return { start: -sheet2.height / 2 + tail, end: sheet2.height / 2 + maxRadius * 2 };
+}
+function rollBoundary(o, sheet2) {
+  const { start, end } = sweep(o, sheet2);
+  return start + o.progress * (end - start);
+}
+var LANDING_RADIUS = 0.035;
+function landing(o, sheet2, boundary, rollRadiusNow) {
+  const radius = Math.min(0.5, Math.max(0.02, sheet2.height * LANDING_RADIUS));
+  const hingeDrop = radius / (Math.PI / 2);
+  const below = Math.max(o.floor, rollRadiusNow + radius);
+  const floorLine = o.from === "top" ? boundary - below : -boundary + below;
+  return {
+    type: "fold",
+    // Travel points from the roll toward the floor, so "past the crease"
+    // means "the length that has arrived", not the drop above it.
+    options: o.from === "top" ? { angle: -90, offset: -floorLine - hingeDrop, foldAngle: 90, radius } : { angle: 90, offset: floorLine - hingeDrop, foldAngle: 90, radius }
+  };
+}
 var unroll = {
   id: "unroll",
   label: "Unroll",
@@ -250,46 +404,65 @@ var unroll = {
   duration: 3,
   loopMode: "yoyo",
   stack(o, sheet2) {
-    const radius = 0.28 - o.tightness * 0.22;
-    const start = -sheet2.height / 2;
-    const end = sheet2.height / 2 + radius * 2;
-    return [
+    const thickness = layerThickness(o.tightness);
+    const boundary = rollBoundary(o, sheet2);
+    const wound = Math.max(0, sheet2.height / 2 - boundary);
+    const radius = rollRadius(wound, o.core, thickness);
+    const stack = [
       {
         type: "roll",
         options: {
-          angle: 270,
-          boundary: start + o.progress * (end - start),
+          // Both directions sweep the same boundary; only which half of the
+          // sheet counts as "past" it changes. 270 winds the bottom (a
+          // receipt feeding downward), 90 winds the top (paper hanging below).
+          angle: o.from === "top" ? 90 : 270,
+          boundary,
           radius,
-          spiral: 0.02
+          thickness
         }
       }
     ];
+    if (o.floor !== void 0) stack.push(landing(o, sheet2, boundary, radius));
+    return stack;
   },
   loop(o, t) {
     if (o.sway === 0) return {};
     const wobble = Math.sin(t * 1.5) * 0.01 * o.sway;
     return { progress: Math.min(1, Math.max(0, o.progress + wobble)) };
   },
+  transform(o, _t, pose, sheet2) {
+    if (!o.fixed) return;
+    const travel = sweep(o, sheet2).end - rollBoundary(o, sheet2);
+    pose.position[1] += o.from === "top" ? travel : -travel;
+  },
   handles: [
     {
       id: "roll-edge",
-      anchor: (o) => [0.5, Math.max(0.02, Math.min(0.98, 1 - o.progress))],
-      drag(local, _o, sheet2) {
-        return { progress: Math.min(1, Math.max(0, 0.5 - local.y / sheet2.height)) };
+      // The grab point is the edge the paper leaves the roll on, so it tracks
+      // the boundary — which runs top-to-bottom for a roll at the bottom and
+      // bottom-to-top for one at the top.
+      anchor: (o) => {
+        const v = o.from === "top" ? o.progress : 1 - o.progress;
+        return [0.5, Math.max(0.02, Math.min(0.98, v))];
+      },
+      drag(local, o, sheet2) {
+        const along = local.y / sheet2.height;
+        const p = o.from === "top" ? 0.5 + along : 0.5 - along;
+        return { progress: Math.min(1, Math.max(0, p)) };
       }
     }
   ]
 };
 
 // src/behaviors/flip.ts
-import { z as z4 } from "zod";
-var flipOptionsSchema = z4.object({
+import { z as z5 } from "zod";
+var flipOptionsSchema = z5.object({
   /** 0 = flat, 1 = page fully turned over the spine. */
-  progress: z4.number().min(0).max(1).default(0.3),
+  progress: z5.number().min(0).max(1).default(0.3),
   /** Which edge is the spine. */
-  spine: z4.enum(["left", "right"]).default("left"),
+  spine: z5.enum(["left", "right"]).default("left"),
   /** Softness of the turning curl. */
-  radius: z4.number().min(0.1).max(0.8).default(0.3)
+  radius: z5.number().min(0.1).max(0.8).default(0.3)
 });
 var flip = {
   id: "flip",
@@ -311,7 +484,7 @@ var flip = {
           angle,
           boundary: start + o.progress * (end - start),
           radius: o.radius,
-          spiral: 0
+          thickness: 0
         }
       }
     ];
@@ -329,12 +502,12 @@ var flip = {
 };
 
 // src/behaviors/letter-fold.ts
-import { z as z5 } from "zod";
-var letterFoldOptionsSchema = z5.object({
+import { z as z6 } from "zod";
+var letterFoldOptionsSchema = z6.object({
   /** 0 = flat letter, 1 = fully tri-folded. */
-  progress: z5.number().min(0).max(1).default(0.4),
+  progress: z6.number().min(0).max(1).default(0.4),
   /** Softness of the two creases. */
-  crease: z5.number().min(0).max(1).default(0.3)
+  crease: z6.number().min(0).max(1).default(0.3)
 });
 var letterFold = {
   id: "letter-fold",
@@ -384,12 +557,12 @@ var letterFold = {
 };
 
 // src/behaviors/hang.ts
-import { z as z6 } from "zod";
-var hangOptionsSchema = z6.object({
+import { z as z7 } from "zod";
+var hangOptionsSchema = z7.object({
   /** Wind strength driving the ripple. */
-  wind: z6.number().min(0).max(1).default(0.4),
+  wind: z7.number().min(0).max(1).default(0.4),
   /** Gravity bulge of the hanging sheet. */
-  sag: z6.number().min(0).max(1).default(0.3)
+  sag: z7.number().min(0).max(1).default(0.3)
 });
 var hang = {
   id: "hang",
@@ -418,12 +591,12 @@ var hang = {
 };
 
 // src/behaviors/fly.ts
-import { z as z7 } from "zod";
-var flyOptionsSchema = z7.object({
+import { z as z8 } from "zod";
+var flyOptionsSchema = z8.object({
   /** Ripple energy. */
-  flutter: z7.number().min(0).max(1).default(0.5),
+  flutter: z8.number().min(0).max(1).default(0.5),
   /** Aerodynamic arc of the sheet. */
-  curve: z7.number().min(0).max(1).default(0.4)
+  curve: z8.number().min(0).max(1).default(0.4)
 });
 var fly = {
   id: "fly",
@@ -452,12 +625,12 @@ var fly = {
 };
 
 // src/behaviors/fall.ts
-import { z as z8 } from "zod";
-var fallOptionsSchema = z8.object({
+import { z as z9 } from "zod";
+var fallOptionsSchema = z9.object({
   /** Air resistance ripple while falling. */
-  flutter: z8.number().min(0).max(1).default(0.6),
+  flutter: z9.number().min(0).max(1).default(0.6),
   /** A falling sheet always lifts a corner. */
-  curl: z8.number().min(0).max(1).default(0.3)
+  curl: z9.number().min(0).max(1).default(0.3)
 });
 var fall = {
   id: "fall",
@@ -489,21 +662,21 @@ var fall = {
 };
 
 // src/behaviors/carry.ts
-import { z as z9 } from "zod";
-var carryOptionsSchema = z9.object({
+import { z as z10 } from "zod";
+var carryOptionsSchema = z10.object({
   /**
    * The grab point — where the pointer was on the paper at pick time.
    * 'auto' is resolved by the carry controller (usually the peeled corner:
    * continuity from peel → carry is the immersion moment).
    */
-  grab: z9.enum([...cornerNames, "auto"]).default("auto"),
+  grab: z10.enum([...cornerNames, "auto"]).default("auto"),
   /** From stock feel: a stamp is stiff — it flutters, it doesn't flow. */
-  stiffness: z9.number().min(0).max(1).default(0.7),
-  flutter: z9.number().min(0).max(1).default(0.5),
+  stiffness: z10.number().min(0).max(1).default(0.7),
+  flutter: z10.number().min(0).max(1).default(0.5),
   /** How far the paper's yaw trails the drag direction (runtime transform). */
-  lag: z9.number().min(0).max(1).default(0.35),
+  lag: z10.number().min(0).max(1).default(0.35),
   /** Drag-speed drive (0..1). Written live by the carry controller. */
-  drive: z9.number().min(0).max(1).default(0.25)
+  drive: z10.number().min(0).max(1).default(0.25)
 });
 var concreteGrab = (g) => g === "auto" ? "top-left" : g;
 var DROOP_ANGLE = {
@@ -550,7 +723,7 @@ var carry = {
 };
 
 // src/behaviors/flight.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 
 // src/physics/aero.ts
 function dampTo(state, target, smoothing, dt) {
@@ -592,17 +765,17 @@ function carryDrive(speed) {
 }
 
 // src/behaviors/flight.ts
-var flightOptionsSchema = z10.object({
+var flightOptionsSchema = z11.object({
   /** Directional wind vector — paper travels ACROSS the scene, not just down. */
-  wind: z10.tuple([z10.number().min(-2).max(2), z10.number().min(-2).max(2), z10.number().min(-2).max(2)]).default([0.6, 0.08, 0]),
-  gustiness: z10.number().min(0).max(1).default(0.4),
-  tumble: z10.number().min(0).max(1).default(0.6),
+  wind: z11.tuple([z11.number().min(-2).max(2), z11.number().min(-2).max(2), z11.number().min(-2).max(2)]).default([0.6, 0.08, 0]),
+  gustiness: z11.number().min(0).max(1).default(0.4),
+  tumble: z11.number().min(0).max(1).default(0.6),
   /** 'loop' is a seamless idle cycle; 'drift' travels along the wind. */
-  path: z10.enum(["drift", "loop"]).default("drift"),
+  path: z11.enum(["drift", "loop"]).default("drift"),
   /** Drift only: exit the scene → re-enter the opposite side. */
-  respawn: z10.boolean().default(true),
+  respawn: z11.boolean().default(true),
   /** Half-extent of the travel before respawn wraps it. */
-  range: z10.number().min(0.5).max(12).default(3.5)
+  range: z11.number().min(0.5).max(12).default(3.5)
 });
 var flight = {
   id: "flight",
@@ -634,16 +807,16 @@ var flight = {
 };
 
 // src/behaviors/crumple.ts
-import { z as z11 } from "zod";
-var crumpleBehaviorOptionsSchema = z11.object({
+import { z as z12 } from "zod";
+var crumpleBehaviorOptionsSchema = z12.object({
   /** 0 = flat sheet, 1 = crushed. */
-  progress: z11.number().min(0).max(1).default(0.55),
+  progress: z12.number().min(0).max(1).default(0.55),
   /** Few big facets at 0, many small ones at 1. */
-  coarseness: z11.number().min(0).max(1).default(0.35),
+  coarseness: z12.number().min(0).max(1).default(0.35),
   /** How far the sheet curls in on itself as it crushes. */
-  ball: z11.number().min(0).max(1).default(0.5),
+  ball: z12.number().min(0).max(1).default(0.5),
   /** A different crush of the same paper. */
-  seed: z11.number().int().min(0).max(7).default(0)
+  seed: z12.number().int().min(0).max(7).default(0)
 });
 var crumpleBehavior = {
   id: "crumple",
@@ -676,8 +849,8 @@ var crumpleBehavior = {
 };
 
 // src/behaviors/settle.ts
-import { z as z12 } from "zod";
-var settleOptionsSchema = z12.object({
+import { z as z13 } from "zod";
+var settleOptionsSchema = z13.object({
   /**
    * How long ago it landed, 0..1.
    *
@@ -685,7 +858,7 @@ var settleOptionsSchema = z12.object({
    * a sheet that has been lying there, where its own weight has flattened
    * out everything except what its stiffness refuses to give up.
    */
-  relax: z12.number().min(0).max(1).default(0.45),
+  relax: z13.number().min(0).max(1).default(0.45),
   /**
    * How hard the paper resists lying flat, 0..1.
    *
@@ -693,14 +866,14 @@ var settleOptionsSchema = z12.object({
    * never does. It is the whole reason a settled sheet reads as PAPER and
    * not as a decal — at 0 the mesh is a rectangle painted on the floor.
    */
-  lift: z12.number().min(0).max(1).default(0.45),
+  lift: z13.number().min(0).max(1).default(0.45),
   /** Which corner stayed up. */
-  corner: z12.enum(["top-left", "top-right", "bottom-left", "bottom-right"]).default("top-right"),
+  corner: z13.enum(["top-left", "top-right", "bottom-left", "bottom-right"]).default("top-right"),
   /**
    * Slack across the middle — the low, long undulation of a sheet that is
    * touching a floor in two places and bridging between them.
    */
-  slack: z12.number().min(0).max(1).default(0.4)
+  slack: z13.number().min(0).max(1).default(0.4)
 });
 var settle = {
   id: "settle",
@@ -753,8 +926,8 @@ var settle = {
 };
 
 // src/behaviors/ribbon.ts
-import { z as z13 } from "zod";
-var ribbonOptionsSchema = z13.object({
+import { z as z14 } from "zod";
+var ribbonOptionsSchema = z14.object({
   /**
    * How much of the drop is lying on the floor, as a fraction of the height.
    *
@@ -763,11 +936,11 @@ var ribbonOptionsSchema = z13.object({
    * turns over reads as paper meeting a floor, which is the thing the
    * reference installations are actually about.
    */
-  pool: z13.number().min(0).max(0.5).default(0.16),
+  pool: z14.number().min(0).max(0.5).default(0.16),
   /** How tightly it turns where it lands. Low is a soft slump, high is a curl. */
-  curl: z13.number().min(0).max(1).default(0.45),
+  curl: z14.number().min(0).max(1).default(0.45),
   /** Folds running down the length. A printed strip is never a flat plane. */
-  drape: z13.number().min(0).max(1).default(0.5)
+  drape: z14.number().min(0).max(1).default(0.5)
 });
 var ribbon = {
   id: "ribbon",
@@ -875,12 +1048,12 @@ var ribbon = {
 };
 
 // src/config/schema.ts
-var sheetSchema = z14.object({
+var sheetSchema = z15.object({
   /** World units. A letter sheet is ~1 × 1.4, a receipt ~1 × 2.6. */
-  width: z14.number().positive().max(20).default(1),
-  height: z14.number().positive().max(20).default(1.4),
+  width: z15.number().positive().max(20).default(1),
+  height: z15.number().positive().max(20).default(1.4),
   /** Visual thickness in mm-ish units; drives edge/shadow treatment, not geometry (yet). */
-  thickness: z14.number().min(0).max(2).default(0.2),
+  thickness: z15.number().min(0).max(2).default(0.2),
   /**
    * `'auto'` sizes the grid from the active deformers' needs — genuinely, as
    * of 0.3.0. It asks each one what these options require (a gentle bend and
@@ -896,8 +1069,8 @@ var sheetSchema = z14.object({
    * still raises it, because that is a correctness floor rather than a
    * preference.
    */
-  segments: z14.union([z14.literal("auto"), z14.number().int().min(2).max(256)]).default("auto"),
-  cornerRadius: z14.number().min(0).max(0.5).default(0)
+  segments: z15.union([z15.literal("auto"), z15.number().int().min(2).max(256)]).default("auto"),
+  cornerRadius: z15.number().min(0).max(0.5).default(0)
 });
 var stockNames = [
   "printer",
@@ -908,37 +1081,37 @@ var stockNames = [
   "photo-gloss",
   "sticker"
 ];
-var stockSchema = z14.enum(stockNames);
-var washSchema = z14.object({
+var stockSchema = z15.enum(stockNames);
+var washSchema = z15.object({
   /** The first pigment. */
-  color: z14.string().default("#4a5b8c").describe("color"),
+  color: z15.string().default("#4a5b8c").describe("color"),
   /** The second. Blooms alternate, and overlaps multiply into a third. */
-  secondary: z14.string().default("#b06a6a").describe("color"),
+  secondary: z15.string().default("#b06a6a").describe("color"),
   /** How many pools of colour. */
-  blooms: z14.number().int().min(1).max(24).default(7),
+  blooms: z15.number().int().min(1).max(24).default(7),
   /** How far a pool runs before it dries — its size against the sheet. */
-  spread: z14.number().min(0.1).max(1).default(0.7),
+  spread: z15.number().min(0.1).max(1).default(0.7),
   /** Softness of the wet edge. 0 is a hard cut, 1 is a pool still moving. */
-  bleed: z14.number().min(0).max(1).default(0.5),
+  bleed: z15.number().min(0).max(1).default(0.5),
   /** How much pigment is in the water. */
-  intensity: z14.number().min(0).max(1).default(0.55),
+  intensity: z15.number().min(0).max(1).default(0.55),
   /**
    * Edge darkening — the ring of pigment left where a pool dried.
    *
    * The signature of the medium, and the one thing a plain gradient cannot
    * fake. Without it a wash reads as an airbrush.
    */
-  edge: z14.number().min(0).max(1).default(0.6),
+  edge: z15.number().min(0).max(1).default(0.6),
   /** Pigment settling into the tooth of the paper. */
-  granulation: z14.number().min(0).max(1).default(0.35),
+  granulation: z15.number().min(0).max(1).default(0.35),
   /** Fixed so a preset paints the same wash every time. */
-  seed: z14.number().int().min(0).max(99).default(0)
+  seed: z15.number().int().min(0).max(99).default(0)
 });
-var blankContentBase = z14.object({
-  type: z14.literal("blank")
+var blankContentBase = z15.object({
+  type: z15.literal("blank")
 });
-var imageContentBase = z14.object({
-  type: z14.literal("image"),
+var imageContentBase = z15.object({
+  type: z15.literal("image"),
   /**
    * Empty means "no picture yet", and renders as bare stock rather than as
    * a failure. That is what lets a built-in preset be an image preset
@@ -946,30 +1119,30 @@ var imageContentBase = z14.object({
    * `postage-stamp` are containers for the caller's own art, handed over via
    * `<PaperField images={...} />` or `content.src`.
    */
-  src: z14.string().default(""),
-  fit: z14.enum(["cover", "contain"]).default("cover"),
+  src: z15.string().default(""),
+  fit: z15.enum(["cover", "contain"]).default("cover"),
   /** Read by the hidden DOM mirror and the no-WebGL fallback. */
-  alt: z14.string().optional()
+  alt: z15.string().optional()
 });
-var textContentBase = z14.object({
-  type: z14.literal("text"),
-  text: z14.string().default("Dear reader,"),
-  font: z14.string().default('Georgia, "Times New Roman", serif'),
+var textContentBase = z15.object({
+  type: z15.literal("text"),
+  text: z15.string().default("Dear reader,"),
+  font: z15.string().default('Georgia, "Times New Roman", serif'),
   /** px at texture resolution (long edge = 1024 logical px before DPR). */
-  size: z14.number().min(8).max(256).default(44),
-  weight: z14.number().min(100).max(900).default(400),
-  color: z14.string().default("#2b2620").describe("color"),
-  align: z14.enum(["left", "center", "right"]).default("left"),
+  size: z15.number().min(8).max(256).default(44),
+  weight: z15.number().min(100).max(900).default(400),
+  color: z15.string().default("#2b2620").describe("color"),
+  align: z15.enum(["left", "center", "right"]).default("left"),
   /** Fraction of the short edge. */
-  padding: z14.number().min(0).max(0.4).default(0.09),
-  lineHeight: z14.number().min(0.8).max(3).default(1.45),
+  padding: z15.number().min(0).max(0.4).default(0.09),
+  lineHeight: z15.number().min(0.8).max(3).default(1.45),
   /**
    * Letter-spacing, in em. The one control display type cannot do without:
    * a line set large enough to be read across a room needs its tracking
    * pulled IN, and a small line of uppercase small-print needs it pushed
    * out, and neither is achievable by changing the size.
    */
-  tracking: z14.number().min(-0.1).max(0.6).default(0),
+  tracking: z15.number().min(-0.1).max(0.6).default(0),
   /**
    * Where the block sits down the sheet.
    *
@@ -978,26 +1151,26 @@ var textContentBase = z14.object({
    * poster wants — a block of type optically centred in the sheet rather
    * than hung from its top edge.
    */
-  valign: z14.enum(["top", "center"]).default("top")
+  valign: z15.enum(["top", "center"]).default("top")
 });
-var cardContentBase = z14.object({
-  type: z14.literal("card"),
+var cardContentBase = z15.object({
+  type: z15.literal("card"),
   /** Small, tracked, uppercase by convention — the label at the top. */
-  title: z14.string().default(""),
+  title: z15.string().default(""),
   /** The card's reason for existing. */
-  body: z14.string().default(""),
+  body: z15.string().default(""),
   /** Attribution, catalogue number, date — the line in small print at the foot. */
-  note: z14.string().default(""),
+  note: z15.string().default(""),
   /** A hairline under the title. What separates a label from a paragraph. */
-  rule: z14.boolean().default(true),
+  rule: z15.boolean().default(true),
   /**
    * Ruled writing lines behind the body, as on an index card.
    *
    * Drawn UNDER the type and in the stock's own ink at low alpha, so they
    * read as printed on the card rather than as underlines on the words.
    */
-  ruled: z14.boolean().default(false),
-  font: z14.string().default('Georgia, "Times New Roman", serif'),
+  ruled: z15.boolean().default(false),
+  font: z15.string().default('Georgia, "Times New Roman", serif'),
   /**
    * Body size, px at texture resolution. Title and note derive from it.
    *
@@ -1007,28 +1180,28 @@ var cardContentBase = z14.object({
    * third of the stock empty above and below it, which reads as a page that
    * was cropped rather than as a card that was set.
    */
-  size: z14.number().min(8).max(256).default(58),
-  color: z14.string().default("#2b2620").describe("color"),
-  align: z14.enum(["left", "center"]).default("left"),
-  padding: z14.number().min(0).max(0.4).default(0.1)
+  size: z15.number().min(8).max(256).default(58),
+  color: z15.string().default("#2b2620").describe("color"),
+  align: z15.enum(["left", "center"]).default("left"),
+  padding: z15.number().min(0).max(0.4).default(0.1)
 });
-var receiptContentBase = z14.object({
-  type: z14.literal("receipt"),
-  store: z14.string().default("PAPERLAB"),
-  address: z14.string().default("124 PAPER ST"),
-  items: z14.array(z14.object({ name: z14.string(), price: z14.number() })).default([
+var receiptContentBase = z15.object({
+  type: z15.literal("receipt"),
+  store: z15.string().default("PAPERLAB"),
+  address: z15.string().default("124 PAPER ST"),
+  items: z15.array(z15.object({ name: z15.string(), price: z15.number() })).default([
     { name: "CURL, TRUE", price: 12 },
     { name: "ROLL, TIGHT", price: 8.5 },
     { name: "SHEET, ONE", price: 0.99 }
   ]),
-  taxRate: z14.number().min(0).max(1).default(0.08),
-  barcode: z14.boolean().default(true),
+  taxRate: z15.number().min(0).max(1).default(0.08),
+  barcode: z15.boolean().default(true),
   /** Fixed so presets render deterministically; omit for "now". */
-  timestamp: z14.string().optional(),
-  footer: z14.string().default("KEEP FOR YOUR RECORDS")
+  timestamp: z15.string().optional(),
+  footer: z15.string().default("KEEP FOR YOUR RECORDS")
 });
 var withWash = { wash: washSchema.optional() };
-var backContentSchema = z14.discriminatedUnion("type", [
+var backContentSchema = z15.discriminatedUnion("type", [
   blankContentBase.extend(withWash),
   imageContentBase.extend(withWash),
   textContentBase.extend(withWash),
@@ -1041,7 +1214,7 @@ var imageContentSchema = imageContentBase.extend(withBack);
 var textContentSchema = textContentBase.extend(withBack);
 var cardContentSchema = cardContentBase.extend(withBack);
 var receiptContentSchema = receiptContentBase.extend(withBack);
-var contentSchema = z14.discriminatedUnion("type", [
+var contentSchema = z15.discriminatedUnion("type", [
   blankContentSchema,
   imageContentSchema,
   textContentSchema,
@@ -1057,80 +1230,146 @@ function contentSchemaFor(type) {
   return option;
 }
 var paperEdges = ["top", "right", "bottom", "left"];
-var surfaceSchema = z14.object({
+var surfaceSchema = z15.object({
   /** Paper fiber noise, 0..1. */
-  grain: z14.number().min(0).max(1).optional(),
+  grain: z15.number().min(0).max(1).optional(),
   /** Light passing through the sheet from behind, 0..1. Stock defaults apply. */
-  translucency: z14.number().min(0).max(1).optional(),
+  translucency: z15.number().min(0).max(1).optional(),
   /** Torn-edge alpha with a lightened fiber band. */
-  deckle: z14.object({
-    edges: z14.array(z14.enum(paperEdges)).default(["bottom"]),
-    roughness: z14.number().min(0).max(1).default(0.5)
+  deckle: z15.object({
+    edges: z15.array(z15.enum(paperEdges)).default(["bottom"]),
+    roughness: z15.number().min(0).max(1).default(0.5)
   }).optional(),
   /** Visual AO/highlight companion to the fold deformer. */
-  creaseLines: z14.object({
+  creaseLines: z15.object({
     /** Crease line direction, degrees (0 = horizontal lines). */
-    angle: z14.number().min(-360).max(360).default(0),
+    angle: z15.number().min(-360).max(360).default(0),
     /** Positions across the sheet, 0..1 fractions. */
-    positions: z14.array(z14.number().min(0).max(1)).default([1 / 3, 2 / 3]),
-    strength: z14.number().min(0).max(1).default(0.5)
+    positions: z15.array(z15.number().min(0).max(1)).default([1 / 3, 2 / 3]),
+    strength: z15.number().min(0).max(1).default(0.5)
   }).optional(),
   /** Yellowing + foxing spots, 0..1. */
-  aging: z14.number().min(0).max(1).optional(),
+  aging: z15.number().min(0).max(1).optional(),
   /** Reversed front-content ghost on the backside, 0..1. Stock defaults apply. */
-  showThrough: z14.number().min(0).max(1).optional(),
+  showThrough: z15.number().min(0).max(1).optional(),
   /**
    * Postage-stamp perforation: alpha-punched semicircular holes along chosen
    * edges. `state` flips an edge to a ripped-through profile (torn) — set
    * automatically when a paper detaches from a `sheet` field, manual wins.
    */
-  perforation: z14.object({
-    edges: z14.union([z14.array(z14.enum(paperEdges)), z14.literal("all")]).default("all"),
+  perforation: z15.object({
+    edges: z15.union([z15.array(z15.enum(paperEdges)), z15.literal("all")]).default("all"),
     /** World units — default tuned to stamp scale. */
-    holeRadius: z14.number().min(2e-3).max(0.1).default(0.016),
-    spacing: z14.number().min(0.01).max(0.5).default(0.055),
-    state: z14.object({
-      top: z14.enum(["intact", "torn"]).optional(),
-      right: z14.enum(["intact", "torn"]).optional(),
-      bottom: z14.enum(["intact", "torn"]).optional(),
-      left: z14.enum(["intact", "torn"]).optional()
+    holeRadius: z15.number().min(2e-3).max(0.1).default(0.016),
+    spacing: z15.number().min(0.01).max(0.5).default(0.055),
+    state: z15.object({
+      top: z15.enum(["intact", "torn"]).optional(),
+      right: z15.enum(["intact", "torn"]).optional(),
+      bottom: z15.enum(["intact", "torn"]).optional(),
+      left: z15.enum(["intact", "torn"]).optional()
     }).default({})
   }).optional()
 });
-var behaviorConfigSchema = z14.discriminatedUnion("type", [
-  peelOptionsSchema.extend({ type: z14.literal("peel") }),
-  unrollOptionsSchema.extend({ type: z14.literal("unroll") }),
-  flipOptionsSchema.extend({ type: z14.literal("flip") }),
-  letterFoldOptionsSchema.extend({ type: z14.literal("letter-fold") }),
-  hangOptionsSchema.extend({ type: z14.literal("hang") }),
-  flyOptionsSchema.extend({ type: z14.literal("fly") }),
-  fallOptionsSchema.extend({ type: z14.literal("fall") }),
-  carryOptionsSchema.extend({ type: z14.literal("carry") }),
-  flightOptionsSchema.extend({ type: z14.literal("flight") }),
-  crumpleBehaviorOptionsSchema.extend({ type: z14.literal("crumple") }),
-  settleOptionsSchema.extend({ type: z14.literal("settle") }),
-  ribbonOptionsSchema.extend({ type: z14.literal("ribbon") })
+var creaseSchema = z15.object({
+  angle: z15.number().min(-360).max(360).default(90),
+  offset: z15.number().min(-20).max(20).default(0),
+  /**
+   * The residual fold angle in degrees, signed — how far open the crease
+   * still sits once nothing is holding the paper. This is the whole of what
+   * a crease IS: geometry and shading both read it, and it is what makes the
+   * field authorable by hand (a dog-ear is a crease with a big `depth` near
+   * a corner) rather than only recordable.
+   */
+  depth: z15.number().min(-180).max(180).default(12)
+});
+var memorySchema = z15.object({
+  /**
+   * How much of a fold this paper keeps, 0..1, over the stock's own
+   * {@link Stock.takesSet}. Kraft holds a crease hard; vellum springs most
+   * of the way back.
+   */
+  set: z15.number().min(0).max(1).optional(),
+  /**
+   * The creases themselves. Recorded by folding the paper (see
+   * `onCrease`), or written by hand — a preset can ship already creased.
+   *
+   * Capped at four because that is what the crease shader carries, and a
+   * cap the schema states is better than one the renderer applies silently.
+   */
+  creases: z15.array(creaseSchema).max(4).default([])
+});
+var behaviorConfigSchema = z15.discriminatedUnion("type", [
+  peelOptionsSchema.extend({ type: z15.literal("peel") }),
+  unrollOptionsSchema.extend({ type: z15.literal("unroll") }),
+  flipOptionsSchema.extend({ type: z15.literal("flip") }),
+  letterFoldOptionsSchema.extend({ type: z15.literal("letter-fold") }),
+  hangOptionsSchema.extend({ type: z15.literal("hang") }),
+  flyOptionsSchema.extend({ type: z15.literal("fly") }),
+  fallOptionsSchema.extend({ type: z15.literal("fall") }),
+  carryOptionsSchema.extend({ type: z15.literal("carry") }),
+  flightOptionsSchema.extend({ type: z15.literal("flight") }),
+  crumpleBehaviorOptionsSchema.extend({ type: z15.literal("crumple") }),
+  settleOptionsSchema.extend({ type: z15.literal("settle") }),
+  ribbonOptionsSchema.extend({ type: z15.literal("ribbon") })
 ]);
-var deformerInstanceSchema = z14.object({
-  type: z14.string(),
-  options: z14.record(z14.unknown()).default({}),
-  enabled: z14.boolean().default(true)
+var deformerInstanceSchema = z15.object({
+  type: z15.string(),
+  options: z15.record(z15.string(), z15.unknown()).default({}),
+  enabled: z15.boolean().default(true)
 });
 var physicsNames = ["none", "float", "tumble", "dangle", "taped", "breeze"];
-var clothConfigSchema = z14.object({
-  type: z14.literal("cloth"),
-  pins: z14.enum(["top-edge", "top-corners", "corner", "none"]).default("top-edge"),
-  wind: z14.number().min(0).max(1).default(0.3),
+var clothConfigSchema = z15.object({
+  type: z15.literal("cloth"),
+  pins: z15.enum(["top-edge", "top-corners", "corner", "none"]).default("top-edge"),
+  wind: z15.number().min(0).max(1).default(0.3),
   /** Bend stiffness: 1 = crisp paper, 0 = silk. */
-  stiffness: z14.number().min(0).max(1).default(0.8),
-  gravity: z14.number().min(0).max(2).default(1),
+  stiffness: z15.number().min(0).max(1).default(0.8),
+  gravity: z15.number().min(0).max(2).default(1),
   /** Local-space ground plane the sheet settles onto. */
-  floor: z14.number().min(-5).max(0).default(-1.4)
+  floor: z15.number().min(-5).max(0).default(-1.4)
+});
+var stripConfigSchema = z15.object({
+  type: z15.literal("strip"),
+  /** How far the page has scrolled, in world units of paper asked for. */
+  scroll: z15.number().min(-1e3).max(1e3).default(0),
+  /** Thin layers and many turns, or few and fat. */
+  tightness: z15.number().min(0).max(1).default(0.6),
+  /** Radius of the cardboard tube — the roll never pays out past it. */
+  core: z15.number().min(0.01).max(0.5).default(0.09),
+  /** Paper already hanging before the first scroll. A roll always has a leaf out. */
+  tail: z15.number().min(0).max(20).default(1.1),
+  /** Spacing of the perforations: one sheet's worth of strip, in world units. */
+  perforation: z15.number().min(0.05).max(5).default(1),
+  /**
+   * How much a perforation remembers being folded. 0 = a fresh roll, 1 = one
+   * that has been used.
+   *
+   * The default is high on purpose: below about 0.6 the landed paper flops
+   * over in flat panels and spreads across the floor, and at 0.7 it holds its
+   * folds and stacks into an accordion. The pile is the point.
+   */
+  crease: z15.number().min(0).max(1).default(0.7),
+  /** Bend stiffness between perforations. 1 = card, 0 = cloth. */
+  stiffness: z15.number().min(0).max(1).default(0.55),
+  /** Broadside air drag — what makes paper float down rather than drop. */
+  drag: z15.number().min(0).max(1).default(0.55),
+  gravity: z15.number().min(0).max(2).default(1),
+  /**
+   * How far below the roll the paper lands. A DISTANCE below the roll's axis,
+   * matching `unroll.floor`, not a signed y like `cloth.floor` — the roll
+   * family measures drops, and the composition is centred on the origin so
+   * an absolute y would not survive the offset anyway.
+   */
+  floor: z15.number().min(0.1).max(30).default(1.2),
+  /** How long the roll coasts after the scroll stops. */
+  inertia: z15.number().min(0).max(1).default(0.45)
 });
-var physicsSchema = z14.union([
-  z14.enum(physicsNames),
-  z14.literal("cloth").transform(() => clothConfigSchema.parse({ type: "cloth" })),
-  clothConfigSchema
+var physicsSchema = z15.union([
+  z15.enum(physicsNames),
+  z15.literal("cloth").transform(() => clothConfigSchema.parse({ type: "cloth" })),
+  z15.literal("strip").transform(() => stripConfigSchema.parse({ type: "strip" })),
+  clothConfigSchema,
+  stripConfigSchema
 ]);
 var lightingNames = [
   "studio",
@@ -1143,9 +1382,9 @@ var lightingNames = [
   "lightbox"
 ];
 var filmNames = ["agx", "neutral", "filmic"];
-var lightSchema = z14.object({
+var lightSchema = z15.object({
   /** Tone-mapping exposure — the stop the whole picture is printed at. */
-  exposure: z14.number().min(0.1).max(4).optional(),
+  exposure: z15.number().min(0.1).max(4).optional(),
   /**
    * The tone curve — the film, where `exposure` is the stop.
    *
@@ -1154,33 +1393,33 @@ var lightSchema = z14.object({
    * the wrong film: it desaturates and drags bright neutrals toward
    * yellow-green, which is the sepia cast a lit sheet used to pick up.
    */
-  film: z14.enum(filmNames).optional(),
+  film: z15.enum(filmNames).optional(),
   /** Key light strength. */
-  key: z14.number().min(0).max(12).optional(),
+  key: z15.number().min(0).max(12).optional(),
   /** Key light colour. */
-  color: z14.string().optional().describe("color"),
+  color: z15.string().optional().describe("color"),
   /**
    * Where the key stands, degrees around the vertical. 0° is straight in
    * front of the paper (+Z, beside the camera), 90° is off to the right,
    * and ±180° is directly behind it — which is where `nave` puts it, and
    * why that preset is carried by light coming THROUGH the paper.
    */
-  direction: z14.number().min(-180).max(180).optional(),
+  direction: z15.number().min(-180).max(180).optional(),
   /** How high the key stands, degrees above the horizon. */
-  height: z14.number().min(-30).max(89).optional(),
+  height: z15.number().min(-30).max(89).optional(),
   /** Flat fill from every direction at once. Cheap, and it kills form — reach for `studio` first. */
-  ambient: z14.number().min(0).max(2).optional(),
+  ambient: z15.number().min(0).max(2).optional(),
   /** The room's own light: an environment map built from `sky`. Directional fill, and the only thing paper's sheen has to reflect. */
-  studio: z14.number().min(0).max(3).optional(),
+  studio: z15.number().min(0).max(3).optional(),
   /** Distance haze, as a multiple of the preset's. 0 clears the air entirely; 2 halves the distance you can see. */
-  haze: z14.number().min(0).max(3).optional()
+  haze: z15.number().min(0).max(3).optional()
 });
-var backdropSchema = z14.object({
+var backdropSchema = z15.object({
   /** Behind everything, and behind the picture where it does not reach. */
-  color: z14.string().default("#171717").describe("color"),
+  color: z15.string().default("#171717").describe("color"),
   /** A URL, or an uploaded picture. Empty is the colour on its own. */
-  image: z14.string().default(""),
-  fit: z14.enum(["cover", "contain"]).default("cover"),
+  image: z15.string().default(""),
+  fit: z15.enum(["cover", "contain"]).default("cover"),
   /**
    * Toward the colour, so the paper stays the subject.
    *
@@ -1189,14 +1428,35 @@ var backdropSchema = z14.object({
    * of the light, and what this solves by mixing it back toward the ground
    * it sits on.
    */
-  fade: z14.number().min(0).max(1).default(0.25),
+  fade: z15.number().min(0).max(1).default(0.25),
   /** Out of focus, for the same reason. */
-  blur: z14.number().min(0).max(1).default(0.2)
+  blur: z15.number().min(0).max(1).default(0.2)
 });
-var sceneSchema = z14.object({
-  lighting: z14.enum(lightingNames).default("studio"),
+var sceneSchema = z15.object({
+  lighting: z15.enum(lightingNames).default("studio"),
   /** What is behind the sheet. Unset leaves the canvas alone. */
   backdrop: backdropSchema.optional(),
+  /**
+   * Degrees the whole composition is turned about its vertical axis, so a
+   * preset can choose the angle it is READ from.
+   *
+   * Every camera in the library is fixed and head-on — `<Paper>` sits at
+   * `(0, 0.35, 2.4)` looking down -Z, and neither it nor the editor fits a
+   * camera to its content. That is the right default for a sheet, which is
+   * flat and faces you. It is the wrong one for anything whose shape lives
+   * in DEPTH: the `strip` sim folds in z by construction, so head-on its
+   * roll and the whole accordion of its pile are edge-on and the preset
+   * renders as a blank white column.
+   *
+   * A camera field would have been the other way to fix it, and is worse: it
+   * is meaningless inside `<PaperField>` and `<PaperMesh>`, where the caller
+   * owns the camera and there may be a dozen papers sharing it. Turning the
+   * paper works everywhere, because it is a property of the paper.
+   *
+   * Additive with the `rotation` prop rather than overriding it — the prop
+   * is the caller's, and a preset does not get to overrule it.
+   */
+  turn: z15.number().min(-180).max(180).default(0),
   /**
    * Overrides on the named preset — the same authorable half stage mode has
    * always had, and which a lone sheet had no way to reach.
@@ -1210,56 +1470,65 @@ var sceneSchema = z14.object({
 });
 var coreStateNames = ["rest", "hover", "pressed", "picked", "placed"];
 var isStateName = (s) => coreStateNames.includes(s) || s.startsWith("custom:");
-var stateNameSchema = z14.string().refine(isStateName, {
+var stateNameSchema = z15.string().refine(isStateName, {
   message: `state names are ${coreStateNames.join(", ")} or "custom:<name>"`
 });
-var stateTransitionSchema = z14.object({
-  duration: z14.number().min(0).max(5).default(0.35),
+var stateTransitionSchema = z15.object({
+  duration: z15.number().min(0).max(5).default(0.35),
   /** GSAP ease name. */
-  ease: z14.string().default("power2.out")
+  ease: z15.string().default("power2.out")
 });
-var stateDefSchema = z14.object({
+var stateDefSchema = z15.object({
   /** Deep-partial override of the paper schema (behavior params, surface, …). */
-  overrides: z14.record(z14.unknown()).default({}),
+  overrides: z15.record(z15.string(), z15.unknown()).default({}),
   /** Transition INTO this state. */
-  transition: stateTransitionSchema.default({}),
+  transition: stateTransitionSchema.prefault({}),
   /** Chained actions after arriving. v1: 'emit:<event>' only. */
-  onEnter: z14.array(z14.string().regex(/^emit:[\w-]+$/, 'v1 actions are "emit:<event>"')).default([])
+  onEnter: z15.array(z15.string().regex(/^emit:[\w-]+$/, 'v1 actions are "emit:<event>"')).default([])
 });
-var paperStatesSchema = z14.object({
+var paperStatesSchema = z15.object({
   initial: stateNameSchema.default("rest"),
-  states: z14.record(z14.string(), stateDefSchema).default({}).refine((rec) => Object.keys(rec).every(isStateName), {
+  states: z15.record(z15.string(), stateDefSchema).default({}).refine((rec) => Object.keys(rec).every(isStateName), {
     message: `state names are ${coreStateNames.join(", ")} or "custom:<name>"`
   }),
   /** World-units drag distance that flips pressed → picked (pick-enabled behaviors only). */
-  pickThreshold: z14.number().min(5e-3).max(1).default(0.1)
+  pickThreshold: z15.number().min(5e-3).max(1).default(0.1)
 });
-var metaSchema = z14.object({
-  name: z14.string().default("untitled"),
-  author: z14.string().optional(),
-  version: z14.string().default("0"),
-  tags: z14.array(z14.string()).default([])
+var metaSchema = z15.object({
+  name: z15.string().default("untitled"),
+  author: z15.string().optional(),
+  version: z15.string().default("0"),
+  tags: z15.array(z15.string()).default([])
 });
-var paperConfigSchema = z14.object({
-  meta: metaSchema.default({}),
-  sheet: sheetSchema.default({}),
+var paperConfigSchema = z15.object({
+  meta: metaSchema.prefault({}),
+  sheet: sheetSchema.prefault({}),
   stock: stockSchema.default("printer"),
   content: contentSchema.default({ type: "blank" }),
   /** A behavior OR a raw deformer stack — if both are present, `deformers` wins (it's the fork). */
   behavior: behaviorConfigSchema.optional(),
-  deformers: z14.array(deformerInstanceSchema).optional(),
+  deformers: z15.array(deformerInstanceSchema).optional(),
   surface: surfaceSchema.default({}),
+  /**
+   * What the sheet remembers being folded — creases outlive the fold.
+   *
+   * Present by default, and on: paper that forgets is the bug this exists
+   * to fix, so remembering is not something a preset should have to ask
+   * for. `memory: { set: 0 }` is the opt-out, and it is what every sheet in
+   * the library did before this shipped.
+   */
+  memory: memorySchema.prefault({}),
   physics: physicsSchema.default("none"),
-  scene: sceneSchema.default({}),
-  onTwos: z14.boolean().default(false),
+  scene: sceneSchema.prefault({}),
+  onTwos: z15.boolean().default(false),
   /** Interaction state machine — overrides-on-base diffs. */
   states: paperStatesSchema.optional()
 }).superRefine((config, ctx) => {
-  if (typeof config.physics === "object" && (config.behavior || config.deformers)) {
+  if (typeof config.physics === "object" && config.physics.type === "strip" && (config.behavior || config.deformers)) {
     ctx.addIssue({
-      code: z14.ZodIssueCode.custom,
+      code: z15.ZodIssueCode.custom,
       path: ["physics"],
-      message: "cloth physics and behavior/deformers are exclusive \u2014 cloth owns the vertices (pick Shape OR Simulation)"
+      message: "the strip simulation and behavior/deformers are exclusive \u2014 the roll owns the vertices, and its rows are chain nodes rather than the sheet's own grid (pick Shape OR Strip)"
     });
   }
   if (config.states) {
@@ -1268,7 +1537,7 @@ var paperConfigSchema = z14.object({
       if (!def) continue;
       if (def.overrides.states !== void 0) {
         ctx.addIssue({
-          code: z14.ZodIssueCode.custom,
+          code: z15.ZodIssueCode.custom,
           path: ["states", "states", name, "overrides"],
           message: "state overrides cannot override `states` (no nested state machines)"
         });
@@ -1279,7 +1548,7 @@ var paperConfigSchema = z14.object({
       if (!result.success) {
         const first = result.error.issues[0];
         ctx.addIssue({
-          code: z14.ZodIssueCode.custom,
+          code: z15.ZodIssueCode.custom,
           path: ["states", "states", name, "overrides"],
           message: `state "${name}" overrides don't validate against the paper schema: ${first ? `${first.path.join(".")} \u2014 ${first.message}` : "invalid"}`
         });
@@ -1310,7 +1579,9 @@ var stocks = {
     banding: 0,
     defaultSurface: { grain: 0.12 },
     showThrough: 0,
-    adhesive: false
+    adhesive: false,
+    // Office bond creases cleanly and holds it — the reference paper.
+    takesSet: 0.6
   },
   thermal: {
     id: "thermal",
@@ -1323,7 +1594,9 @@ var stocks = {
     banding: 0.35,
     defaultSurface: { aging: 0.1 },
     showThrough: 0.06,
-    adhesive: false
+    adhesive: false,
+    // Thin and already curled off a roll; a fold in it stays folded.
+    takesSet: 0.65
   },
   kraft: {
     id: "kraft",
@@ -1336,7 +1609,9 @@ var stocks = {
     banding: 0,
     defaultSurface: { grain: 0.5 },
     showThrough: 0,
-    adhesive: false
+    adhesive: false,
+    // Thick and fibrous. The crease is a break, and it never comes back.
+    takesSet: 0.85
   },
   newsprint: {
     id: "newsprint",
@@ -1349,7 +1624,9 @@ var stocks = {
     banding: 0,
     defaultSurface: { grain: 0.7, aging: 0.15 },
     showThrough: 0.06,
-    adhesive: false
+    adhesive: false,
+    // Soft, short-fibred, and barely sprung — it crumples rather than resists.
+    takesSet: 0.8
   },
   vellum: {
     id: "vellum",
@@ -1362,7 +1639,9 @@ var stocks = {
     banding: 0,
     defaultSurface: {},
     showThrough: 0.55,
-    adhesive: false
+    adhesive: false,
+    // Translucent and plasticky: it fights the fold and mostly wins.
+    takesSet: 0.25
   },
   "photo-gloss": {
     id: "photo-gloss",
@@ -1375,7 +1654,9 @@ var stocks = {
     banding: 0,
     defaultSurface: {},
     showThrough: 0,
-    adhesive: false
+    adhesive: false,
+    // The coating resists, then cracks white — little angle kept, lots of mark.
+    takesSet: 0.3
   },
   // Photo-gloss-like face, glossy near-white glue underside. The default
   // carrier for perforated stamp sheets.
@@ -1390,7 +1671,9 @@ var stocks = {
     banding: 0,
     defaultSurface: {},
     showThrough: 0,
-    adhesive: true
+    adhesive: true,
+    // A face sheet on a release liner; the liner does most of the remembering.
+    takesSet: 0.5
   }
 };
 function getStock(name) {
@@ -1417,6 +1700,183 @@ var builtins = {
     behavior: { type: "unroll", progress: 0.55, tightness: 0.55, sway: 0.3 },
     surface: { deckle: { edges: ["bottom"], roughness: 0.6 } }
   },
+  /**
+   * A roll on a holder with a leaf already out, meant to be driven by scroll:
+   * bind `behavior.progress` to how far down the page you are and the paper
+   * pays out while the roll runs down toward its tube.
+   *
+   * The three parts that make it read as a real roll rather than a curled
+   * sheet: `fixed` keeps the roll on its holder and moves the paper instead,
+   * `tail` means there is always a leaf to take hold of, and `floor` gives
+   * the drop somewhere to land — paper that reaches the ground creases and
+   * lies down rather than hanging into the void forever. A `core` a third of
+   * the full radius is a real cardboard tube, so the roll still looks like a
+   * roll after it has been used down.
+   */
+  "paper-roll": {
+    meta: { name: "Paper roll", tags: ["roll", "unroll", "scroll", "hero"] },
+    sheet: { width: 1, height: 5 },
+    stock: "newsprint",
+    content: { type: "blank" },
+    behavior: {
+      type: "unroll",
+      progress: 0.25,
+      tightness: 0.8,
+      sway: 0.15,
+      from: "top",
+      fixed: true,
+      core: 0.12,
+      tail: 0.5,
+      floor: 2.4
+    },
+    surface: { deckle: { edges: ["bottom"], roughness: 0.5 } }
+  },
+  /**
+   * The one that is a SIMULATION rather than a shape.
+   *
+   * `paper-roll` above draws this same object with a deformer stack, and for
+   * a roll paying out against a wall that is the cheaper and better answer.
+   * This preset exists for the half that geometry cannot reach: what happens
+   * once the paper hits the ground. A deformer can bend a sheet along a curve
+   * you have already chosen; it cannot discover that a strip under
+   * compression buckles at its weakest hinge, and it cannot let one fold land
+   * on the one beneath it. Both of those are what a pile IS.
+   *
+   * Bind `physics.scroll` to the page and the roll turns:
+   *
+   * ```tsx
+   * const [scroll, setScroll] = useState(0)
+   * useEffect(() => {
+   *   const onScroll = () => setScroll(window.scrollY / 120)
+   *   window.addEventListener('scroll', onScroll, { passive: true })
+   *   return () => window.removeEventListener('scroll', onScroll)
+   * }, [])
+   * <Paper preset="toilet-roll" physics={{ type: 'strip', scroll }} />
+   * ```
+   *
+   * It is a MONOTONIC world-unit number, not a 0..1 progress — the sim
+   * differentiates it, so scrolling back up rewinds the roll and drags the
+   * pile taut before it lifts.
+   *
+   * The proportions are the real object's: a panel as wide as it is long, so
+   * `perforation` equals the sheet width and the strip tears into squares.
+   */
+  "toilet-roll": {
+    meta: { name: "Toilet roll", tags: ["roll", "scroll", "simulation", "hero"] },
+    // The proportions are a real roll's, at the scale the library is viewed
+    // at: `<Paper>` and the editor both look at the origin through about two
+    // world units and neither fits a camera to its content, so the whole
+    // composition — roll, drop and pile — has to live inside that. A panel is
+    // as wide as it is long and the roll is about a panel across, which is
+    // what a toilet roll is.
+    //
+    // Twenty-three panels of paper. Not a real roll's several hundred, but
+    // enough that a full page of scrolling does not empty it: one scroll unit
+    // is about one unit of paper on a fresh roll, so this is a couple of
+    // screens' worth before the tube shows.
+    sheet: { width: 0.6, height: 14 },
+    stock: "printer",
+    content: { type: "blank" },
+    physics: {
+      type: "strip",
+      scroll: 0,
+      // Wound tightly enough to hold this much paper at a believable size: the
+      // outer radius lands at 0.61 of the panel width against a real roll's
+      // 0.57, over about nine visible turns.
+      //
+      // `tightness` is doing double duty and the trade is worth knowing about.
+      // A layer gap IS the paper's thickness, so it also sets how far apart
+      // self-collision holds two folds — wind tighter for a neater roll and
+      // the pile on the floor gets flatter, looser for a fatter pile and the
+      // roll coarsens. This is the middle of that.
+      //
+      // It is ALSO the roll's rim, and that is the reason not to raise it on
+      // looks alone. A layer gap is a real space between two wound turns, so
+      // the roll's end face is concentric rings with nothing between them,
+      // and off head-on you see between them — a fine sawtooth around the
+      // rim that winding tighter genuinely reduces. It was tried. Tightening
+      // to 0.78 also moves the roll's proportion to 0.553 of a panel width,
+      // nearer a real roll's 0.57 than this is, so it looked like a free win
+      // — and it throws the pile 1.33 units out in x against the 0.874 a
+      // square parent can see, spreading 5.9 panel-widths. Framing beats the
+      // rim. The sawtooth is what a roll wound from ONE zero-thickness
+      // ribbon costs; it is not tuned away, and a caller who wants it gone
+      // wants a thicker `stock` or fewer, fatter turns.
+      tightness: 0.65,
+      // A real cardboard tube, and a floor on how tight the spiral ever winds.
+      // The innermost wrap is the coarsest thing in the roll — the same
+      // arc-length step spans a bigger angle the smaller the radius — so the
+      // core is what stops a nearly-empty roll turning back into a polygon.
+      core: 0.12,
+      // A panel and a half already hanging. A roll on a holder always has a
+      // leaf out; starting from a bare cylinder reads as one still wrapped.
+      tail: 0.9,
+      perforation: 0.6,
+      // The four numbers below were chosen TOGETHER, and by worst case rather
+      // than by a good-looking run. A pile is chaotic: change `crease` by
+      // 0.05 and one 14-second scroll can spread 2.0 panel-widths of floor or
+      // 4.2, so a single trajectory is a sample and not a measurement. These
+      // are scored over nine — three scroll depths crossed with three feed
+      // rates — on how far the composition ever gets from the origin.
+      //
+      // What that fixed: the shipped set spread 2.9 panel-widths on average
+      // and 4.0 at worst, and threw paper 1.60 units out in z. It ran off the
+      // side of the frame and kept going. These hold 2.2 average, 2.8 worst,
+      // and 1.09 out — while keeping the pile's height (about ten layers)
+      // intact, which is the thing all of this exists to show.
+      //
+      // The most load-bearing of them. Below about 0.6 the landed paper flops
+      // over in flat panels and runs away across the floor instead of folding
+      // back; high is what makes the perforations hold and the pile
+      // accordion. A used roll remembering its creases is the whole effect.
+      crease: 0.9,
+      // Low enough that a panel buckles rather than steering the pile: at 0.5
+      // the sheet was stiff enough to push the folds already down along the
+      // floor ahead of it, which is what "spreads across four panels" was.
+      stiffness: 0.4,
+      // High: paper is light and broad, and this is what separates it from a
+      // rope hanging off a drum. It also damps the sideways travel that
+      // carried the pile out of frame.
+      drag: 0.85,
+      gravity: 1,
+      // The drop, measured from the roll's axis. Together with the roll's own
+      // radius this IS the height of the composition, which is centred on the
+      // origin — so keep their sum under about 1.7 or the roll and the pile
+      // fall outside the ~1.75 units `<Paper>`'s fixed camera can see.
+      //
+      // Shortened from 1.2, and it is the single most effective number here:
+      // a longer fall is more airtime for the strip to pick a direction and
+      // glide, so it landed still travelling and slid. Worst-case spread goes
+      // 4.2 panel-widths to 3.1 and the pile keeps its full depth. It buys
+      // vertical room as well, which is what lets the roll sit further up.
+      floor: 0.85,
+      inertia: 0.5
+    },
+    surface: { grain: 0.25 },
+    // The preset is unreadable without this, and that is not a figure of
+    // speech: the strip sim folds in DEPTH, and every camera in the library
+    // is fixed and head-on, so `<Paper preset="toilet-roll" />` framed the
+    // roll end-on and the entire accordion edge-on and rendered a blank white
+    // column. This is the three-quarter view the pile actually reads from —
+    // enough to see along the folds and around the roll's rim, not so much
+    // that the strip's face turns away.
+    //
+    // The ceiling is framing, not taste. Turning swaps the pile's DEPTH for
+    // WIDTH, and depth is free — the camera has plenty — while width is not.
+    // Measured over fifteen scroll trajectories the pile reaches 1.27 units
+    // of depth at worst, and `halfWidth·cos θ + 1.27·sin θ` crosses the 0.874
+    // half-view a square parent gets at 28°. Twenty-five leaves real margin
+    // (0.809) and gives up almost nothing of the angle.
+    //
+    // Do not raise it without re-measuring that depth: the two numbers are
+    // coupled, and the pile's depth is not stable under small changes to the
+    // physics — see the note on `floor`.
+    //
+    // A parent narrower than square still crops the pile's far edge. That is
+    // the honest limit of a fixed camera, and the caller's answer is their
+    // own `rotation` prop, which this composes with rather than overrides.
+    scene: { turn: 25 }
+  },
   "letter-fold": {
     meta: { name: "Letter fold", tags: ["fold", "text"] },
     sheet: { width: 1, height: 1.4 },
@@ -1426,7 +1886,24 @@ var builtins = {
       text: "Dear you,\n\nSome things are worth folding carefully.\n\nYours,\nN."
     },
     behavior: { type: "letter-fold", progress: 0.4, crease: 0.3 },
-    surface: { creaseLines: { angle: 0, positions: [1 / 3, 2 / 3], strength: 0.5 } }
+    // A letter that has been folded before. These were painted-on
+    // `creaseLines` until the paper could carry real ones — two marks in the
+    // shader at exactly the two places the tri-fold bends, which is a good
+    // impression of a crease right up until you unfold the letter and it
+    // comes back perfectly flat. As memory they bend the sheet as well as
+    // marking it, and folding the letter deepens the creases it already has
+    // rather than drawing a second pair on top of them.
+    //
+    // The lines are `letterFold`'s own: travel down and up, each a sixth of
+    // the sheet from the middle. Shallower than a fold leaves (printer keeps
+    // about 20°) because this letter has been folded once and put away, not
+    // folded and reopened in front of you.
+    memory: {
+      creases: [
+        { angle: 270, offset: 1.4 / 6, depth: 13 },
+        { angle: 90, offset: 1.4 / 6, depth: 11 }
+      ]
+    }
   },
   /**
    * The wash, shown rather than described.
@@ -1732,77 +2209,6 @@ async function ensureFont(font, size) {
 // src/deformers/registry.ts
 import { z as z21 } from "zod";
 
-// src/deformers/roll.ts
-import { z as z15 } from "zod";
-var rollOptionsSchema = z15.object({
-  /** Direction of rolling in the sheet plane, degrees. 0 = +x, 90 = +y. */
-  angle: z15.number().min(-360).max(360).default(90),
-  /** Signed distance (along the roll direction, from sheet center) where the roll begins. */
-  boundary: z15.number().min(-20).max(20).default(0),
-  /** Cylinder radius — sharpness of the roll. */
-  radius: z15.number().min(0.01).max(2).default(0.12),
-  /** Radius growth per radian so multi-turn rolls spiral instead of z-fighting. */
-  spiral: z15.number().min(0).max(0.2).default(0.015)
-});
-var DEG2 = Math.PI / 180;
-var roll = {
-  id: "roll",
-  label: "Roll",
-  defaults: rollOptionsSchema.parse({}),
-  optionsSchema: rollOptionsSchema,
-  geometry: {
-    minSegments: 48,
-    // The winding radius is the tightest curvature on the sheet — `spiral`
-    // only grows it as the roll winds outward, so the first turn is the one
-    // that sets the density.
-    autoSegments: (o, sheet2) => segmentsForArc(spanAlong(sheet2, o.angle), o.radius),
-    axis: (o) => o.angle
-  },
-  displace(out, _uv, o) {
-    const dirX = Math.cos(o.angle * DEG2);
-    const dirY = Math.sin(o.angle * DEG2);
-    const d = out.x * dirX + out.y * dirY;
-    const s = d - o.boundary;
-    if (s <= 0) return;
-    const theta = s / o.radius;
-    const r = o.radius + o.spiral * theta;
-    const sin = Math.sin(theta);
-    const cos = Math.cos(theta);
-    const newD = o.boundary + (r - out.z) * sin;
-    const newZ = r * (1 - cos) + out.z * cos;
-    out.x += dirX * (newD - d);
-    out.y += dirY * (newD - d);
-    out.z = newZ;
-  },
-  glsl: {
-    chunk: (
-      /* glsl */
-      `
-void FN(inout vec3 p, vec2 uv, float t) {
-  vec2 dir = vec2(cos(U_angle), sin(U_angle));
-  float d = dot(p.xy, dir);
-  float s = d - U_boundary;
-  if (s <= 0.0) return;
-  float theta = s / U_radius;
-  float r = U_radius + U_spiral * theta;
-  float sn = sin(theta);
-  float cs = cos(theta);
-  float newD = U_boundary + (r - p.z) * sn;
-  float newZ = r * (1.0 - cs) + p.z * cs;
-  p.xy += dir * (newD - d);
-  p.z = newZ;
-}
-`
-    ),
-    uniforms: (o) => ({
-      angle: o.angle * DEG2,
-      boundary: o.boundary,
-      radius: o.radius,
-      spiral: o.spiral
-    })
-  }
-};
-
 // src/deformers/bend.ts
 import { z as z16 } from "zod";
 var bendOptionsSchema = z16.object({
@@ -1984,7 +2390,7 @@ var waveOptionsSchema = z18.object({
   pinnedEdge: z18.enum(["none", "top", "bottom", "left", "right"]).default("none")
 });
 var DEG5 = Math.PI / 180;
-var TAU = Math.PI * 2;
+var TAU2 = Math.PI * 2;
 var wave = {
   id: "wave",
   label: "Wave",
@@ -2011,7 +2417,7 @@ var wave = {
     const dirX = Math.cos(o.angle * DEG5);
     const dirY = Math.sin(o.angle * DEG5);
     const d = out.x * dirX + out.y * dirY;
-    const phase = (d / o.wavelength - o.speed * ctx.t) * TAU;
+    const phase = (d / o.wavelength - o.speed * ctx.t) * TAU2;
     let env = 1;
     if (o.pinnedEdge === "top") env = 1 - uv.y;
     else if (o.pinnedEdge === "bottom") env = uv.y;
@@ -2067,7 +2473,7 @@ var drapeOptionsSchema = z19.object({
   gather: z19.number().min(0).max(1).default(0.5),
   pinnedEdge: z19.enum(["top", "bottom"]).default("top")
 });
-var TAU2 = Math.PI * 2;
+var TAU3 = Math.PI * 2;
 var drape = {
   id: "drape",
   label: "Drape",
@@ -2095,7 +2501,7 @@ var drape = {
     if (o.amplitude === 0) return;
     const drop = o.pinnedEdge === "top" ? 1 - uv.y : uv.y;
     const depth = drop ** o.falloff;
-    const u = uv.x * TAU2 * o.folds;
+    const u = uv.x * TAU3 * o.folds;
     const fold2 = Math.sin(u) + o.irregular * 0.6 * Math.sin(u * 1.7 + 2.1);
     out.z += o.amplitude * depth * fold2;
     const pinch = o.gather * depth * Math.min(o.amplitude * o.folds * 0.8, 0.6);
@@ -2298,6 +2704,185 @@ function stackIsAnimated(stack) {
   return stack.some((i) => i.enabled !== false && registry.get(i.type)?.animated);
 }
 
+// src/deformers/memory.ts
+var MAX_SET = 0.2;
+var CREASE_RADIUS = 0.03;
+var CREASE_MIN_GROWTH = 45;
+var CREASE_DRIFT = 0.02;
+var CREASE_DRIFT_ANGLE = 2;
+var MIN_DEPTH = 1;
+var MAX_CREASES = 4;
+function canonicalLine(angle, offset) {
+  let a = (angle % 360 + 360) % 360;
+  let o = offset;
+  if (a >= 180) {
+    a -= 180;
+    o = -o;
+  }
+  return [a, o];
+}
+function sameLine(a, b) {
+  const [aa, ao] = canonicalLine(a.angle, a.offset);
+  const [ba, bo] = canonicalLine(b.angle, b.offset);
+  const d = Math.abs(aa - ba);
+  const angleClose = Math.min(d, 180 - d) <= CREASE_DRIFT_ANGLE;
+  return angleClose && Math.abs(ao - bo) <= CREASE_DRIFT;
+}
+function applyMemory(stack, creases) {
+  if (creases.length === 0) return stack;
+  let out = stack;
+  const loose = [];
+  for (const crease of creases) {
+    if (Math.abs(crease.depth) < MIN_DEPTH) continue;
+    const index = out.findIndex(
+      (i) => i.type === "fold" && i.enabled !== false && sameLine(i.options, crease)
+    );
+    if (index === -1) {
+      loose.push(crease);
+      continue;
+    }
+    const live = out[index];
+    const options = live.options;
+    if (Math.abs(options.foldAngle) >= Math.abs(crease.depth)) continue;
+    if (out === stack) out = [...stack];
+    out[index] = { ...live, options: { ...options, foldAngle: crease.depth } };
+  }
+  if (loose.length === 0) return out;
+  return [...loose.map(toFold), ...out];
+}
+function toFold(crease) {
+  return {
+    type: "fold",
+    options: {
+      angle: crease.angle,
+      offset: crease.offset,
+      foldAngle: crease.depth,
+      radius: CREASE_RADIUS
+    }
+  };
+}
+var CreaseTracker = class {
+  slots = /* @__PURE__ */ new Map();
+  recorded = [];
+  authored = [];
+  /** What `observe` last handed out, so an echo can be told from an edit. */
+  lastReported = [];
+  constructor(authored = []) {
+    this.authored = authored;
+  }
+  /**
+   * Forget how the paper got here without forgetting the creases.
+   *
+   * Called when the stack is replaced wholesale (a new behavior, a new
+   * sheet): the slots describe folds that no longer exist, but a crease is a
+   * property of the paper and survives being put down and picked up.
+   */
+  reset(authored = this.creases) {
+    this.slots.clear();
+    this.recorded = [];
+    this.authored = authored;
+  }
+  /**
+   * Take on a crease set that came from outside, and work out which kind of
+   * outside it was — because the two kinds want opposite things.
+   *
+   * It is USUALLY this tracker's own recording coming back, a frame or two
+   * after `onCrease` handed it to the host. Then the slots must survive: the
+   * fold that made the crease is very likely still closing, and resetting
+   * its peak on the host's echo would stall the crease halfway into the
+   * fold that was making it.
+   *
+   * But it can also be somebody EDITING the paper — a depth dragged down in
+   * a panel, a shared link opened, a state's overrides settling. Then the
+   * slots are the wrong story to keep. `merge` takes the deeper of two
+   * creases on a line, so a recording of 20° would quietly outvote a human
+   * asking for 5° and the slider would appear not to work; and it would go
+   * on outvoting it, because the fold that recorded the 20 is still sitting
+   * in a slot. An edit means the paper is what it is now, and the next
+   * crease has to be earned by folding it again.
+   *
+   * The two are told apart by what we last reported. Anything else is an
+   * edit, which is the safe way round: mistaking an echo for an edit costs
+   * a crease that gets re-recorded on the next fold, while mistaking an edit
+   * for an echo costs a control that does not work.
+   */
+  adopt(creases) {
+    if (!same(creases, this.lastReported)) this.slots.clear();
+    this.authored = creases;
+    this.recorded = [];
+  }
+  /** Everything the sheet currently carries, authored and recorded merged. */
+  get creases() {
+    return merge(this.authored, this.recorded);
+  }
+  /**
+   * Take one frame's reading. Returns true when the crease set changed by
+   * enough to be worth telling anyone about.
+   */
+  observe(stack, set) {
+    if (set <= 0) return false;
+    for (let i = 0; i < stack.length; i++) {
+      const instance = stack[i];
+      if (instance.type !== "fold" || instance.enabled === false) continue;
+      const o = instance.options;
+      const magnitude = Math.abs(o.foldAngle);
+      const slot = this.slots.get(i);
+      if (!slot || Math.abs(slot.angle - o.angle) > CREASE_DRIFT_ANGLE || Math.abs(slot.offset - o.offset) > CREASE_DRIFT) {
+        this.slots.set(i, {
+          angle: o.angle,
+          offset: o.offset,
+          trough: magnitude,
+          bestGrowth: 0,
+          bestPeak: magnitude,
+          sign: o.foldAngle < 0 ? -1 : 1
+        });
+        continue;
+      }
+      if (magnitude < slot.trough) slot.trough = magnitude;
+      const growth = magnitude - slot.trough;
+      if (growth > slot.bestGrowth) {
+        slot.bestGrowth = growth;
+        slot.bestPeak = magnitude;
+        slot.sign = o.foldAngle < 0 ? -1 : 1;
+      }
+    }
+    const next = [];
+    for (const slot of this.slots.values()) {
+      if (slot.bestGrowth < CREASE_MIN_GROWTH) continue;
+      const depth = slot.sign * slot.bestPeak * set * MAX_SET;
+      if (Math.abs(depth) < MIN_DEPTH) continue;
+      next.push({ angle: slot.angle, offset: slot.offset, depth });
+    }
+    if (same(next, this.recorded)) return false;
+    this.recorded = next;
+    this.lastReported = this.creases;
+    return true;
+  }
+};
+function merge(authored, recorded) {
+  const out = [];
+  for (const crease of [...recorded, ...authored]) {
+    const existing = out.find((c) => sameLine(c, crease));
+    if (!existing) {
+      out.push({ ...crease });
+      continue;
+    }
+    if (Math.abs(crease.depth) > Math.abs(existing.depth)) existing.depth = crease.depth;
+  }
+  if (out.length > MAX_CREASES) {
+    out.sort((a, b) => Math.abs(b.depth) - Math.abs(a.depth));
+    out.length = MAX_CREASES;
+  }
+  return out;
+}
+function same(a, b) {
+  if (a.length !== b.length) return false;
+  return a.every((crease, i) => {
+    const other = b[i];
+    return sameLine(crease, other) && Math.abs(crease.depth - other.depth) < 0.5;
+  });
+}
+
 // src/behaviors/registry.ts
 var registry2 = /* @__PURE__ */ new Map();
 function registerBehavior(behavior) {
@@ -2337,56 +2922,774 @@ var idlePresets = {
       pose.rotation[1] = Math.sin(t * 0.31) * 0.16;
       pose.rotation[2] = Math.sin(t * 0.23 + 1.2) * 0.05;
     }
-  },
-  tumble: {
-    id: "tumble",
-    label: "Tumble",
-    transform(t, pose) {
-      pose.rotation[0] = Math.sin(t * 0.5 + 1) * 0.6;
-      pose.rotation[2] = Math.sin(t * 0.7) * 0.5;
-      pose.position[1] = Math.sin(t * 1.4) * 0.07;
-      pose.position[0] = Math.sin(t * 0.35) * 0.14;
-    },
-    stack: () => [
-      {
-        type: "wave",
-        options: { amplitude: 0.02, wavelength: 0.9, speed: 0.9, angle: 25, pinnedEdge: "none" }
+  },
+  tumble: {
+    id: "tumble",
+    label: "Tumble",
+    transform(t, pose) {
+      pose.rotation[0] = Math.sin(t * 0.5 + 1) * 0.6;
+      pose.rotation[2] = Math.sin(t * 0.7) * 0.5;
+      pose.position[1] = Math.sin(t * 1.4) * 0.07;
+      pose.position[0] = Math.sin(t * 0.35) * 0.14;
+    },
+    stack: () => [
+      {
+        type: "wave",
+        options: { amplitude: 0.02, wavelength: 0.9, speed: 0.9, angle: 25, pinnedEdge: "none" }
+      }
+    ]
+  },
+  dangle: {
+    id: "dangle",
+    label: "Dangle",
+    transform(t, pose) {
+      pose.rotation[2] = Math.sin(t * 1.5) * 0.06;
+      pose.rotation[0] = Math.sin(t * 1.1 + 0.7) * 0.03;
+    }
+  },
+  taped: {
+    id: "taped",
+    label: "Taped",
+    // Taped at the top of a wall: the free bottom edge breathes.
+    stack: () => [
+      {
+        type: "wave",
+        options: { amplitude: 0.025, wavelength: 1.2, speed: 0.45, angle: 90, pinnedEdge: "top" }
+      }
+    ]
+  },
+  breeze: {
+    id: "breeze",
+    label: "Breeze",
+    stack: () => [
+      {
+        type: "wave",
+        options: { amplitude: 0.035, wavelength: 0.5, speed: 1, angle: 20, pinnedEdge: "none" }
+      }
+    ]
+  }
+};
+function getIdlePreset(name) {
+  return idlePresets[name];
+}
+
+// src/physics/strip.ts
+var FIXED_DT = 1 / 120;
+var SOLVER_ITERATIONS = 8;
+var SLEEP_EPSILON = 1e-7;
+var SLEEP_FRAMES = 45;
+var LOOSE2 = 0.055;
+var TIGHT2 = 0.012;
+var NODES_PER_PANEL = 16;
+var MAX_NODES = 440;
+var MIN_NODES = 8;
+var REFERENCE_SEGMENT = 0.0375;
+var TANGENT_SPAN = 0.09;
+var PULL_STIFFNESS = 0.35;
+var COLLIDING_ITERATIONS = 4;
+var COLLISION_RELAXATION = 0.35;
+function safeSpiralRadius(segment, thickness) {
+  return thickness > 0 ? segment * segment / (4 * thickness) : 0;
+}
+function layerThickness2(tightness) {
+  return LOOSE2 - Math.min(1, Math.max(0, tightness)) * (LOOSE2 - TIGHT2);
+}
+function stripNodeCount(length, perforation) {
+  const seg = Math.max(perforation, 1e-3) / NODES_PER_PANEL;
+  return Math.min(MAX_NODES, Math.max(MIN_NODES, Math.round(length / seg) + 1));
+}
+function maxStripLength(perforation) {
+  const seg = Math.max(perforation, 1e-3) / NODES_PER_PANEL;
+  return (MAX_NODES - 1 - 0.5) * seg;
+}
+var StripSim = class {
+  /** Chain length. Node 0 is the deepest wrap; node `count-1` is the free tip. */
+  count;
+  /** Rest spacing between neighbours, in world units. */
+  segment;
+  /** Node centreline, y/z interleaved. x is implicit: the strip never twists. */
+  pos;
+  prev;
+  /** Arc distance from the tip, per node. */
+  arc;
+  /** 1 where a perforation hinges, and the sign of the crease it remembers. */
+  perforated;
+  /** Bend gain correction for this chain's node spacing. See {@link REFERENCE_SEGMENT}. */
+  bendScale;
+  /** Half-width, in nodes, of the window the drag tangent is measured over. */
+  tangentNodes;
+  halfWidth;
+  totalLength;
+  /**
+   * Paper that can never be paid out, because its inner end is glued to the
+   * tube — which is true of every roll you have ever used.
+   *
+   * Without it the roll pays out to nothing, `firstFreeIndex` reaches 0, and
+   * every node the roll was made of becomes free paper and falls: the whole
+   * roll drops off its holder and lands flat on the pile. One wrap held back
+   * leaves a cylinder at the core radius on the holder, which is what an
+   * empty roll looks like and the closest this library can get to drawing a
+   * cardboard tube out of the one sheet it has.
+   */
+  tubeStub;
+  params;
+  /** Paid-out length: how much paper is off the roll. */
+  paid;
+  /** Angular velocity of the roll, rad/s. The thing that coasts. */
+  omega = 0;
+  /**
+   * Whether anything has turned the roll yet — a scroll delta or a hand.
+   *
+   * `tail` is the opening pose, and editing it should re-pose the roll; but
+   * once the host has scrolled, `paid` is the simulation's own state and
+   * re-posing would yank the paper back out of the pile.
+   */
+  driven = false;
+  lastScroll;
+  primed = false;
+  /** Node held by the pointer, or -1. Kinematic while held, like a wound node. */
+  grabbed = -1;
+  grabY = 0;
+  grabZ = 0;
+  stillFrames = 0;
+  accumulator = 0;
+  time = 0;
+  asleep = false;
+  // Spatial hash for self-collision. Sized once, refilled in place — the
+  // per-substep collision pass allocates nothing.
+  cellOf;
+  bucketStart;
+  bucketItems;
+  bucketFill;
+  tableSize;
+  constructor(length, width, params) {
+    this.params = { ...params };
+    this.totalLength = length;
+    this.halfWidth = width / 2;
+    this.count = stripNodeCount(length, params.perforation);
+    this.segment = length / (this.count - 1);
+    this.bendScale = Math.min(1, this.segment / REFERENCE_SEGMENT);
+    this.tangentNodes = Math.max(1, Math.round(TANGENT_SPAN / this.segment));
+    this.pos = new Float64Array(this.count * 2);
+    this.prev = new Float64Array(this.count * 2);
+    this.arc = new Float64Array(this.count);
+    this.perforated = new Int8Array(this.count);
+    for (let i = 0; i < this.count; i++) {
+      this.arc[i] = (this.count - 1 - i) * this.segment;
+    }
+    const spacing = Math.max(params.perforation, this.segment * 2);
+    for (let i = 0; i < this.count - 1; i++) {
+      const here = Math.floor(this.arc[i] / spacing);
+      const next = Math.floor(this.arc[i + 1] / spacing);
+      if (here !== next) this.perforated[i] = here % 2 === 0 ? 1 : -1;
+    }
+    this.tableSize = 1 << Math.ceil(Math.log2(Math.max(16, this.count * 2)));
+    this.cellOf = new Int32Array(this.count);
+    this.bucketStart = new Int32Array(this.tableSize + 1);
+    this.bucketItems = new Int32Array(this.count);
+    this.bucketFill = new Int32Array(this.tableSize);
+    this.tubeStub = this.stubFor(params.core);
+    this.paid = Math.min(params.tail, this.usableLength);
+    this.lastScroll = params.scroll;
+    this.layOut();
+  }
+  /**
+   * Local-space y the pile builds on, after centring. A host placing a
+   * shadow catcher or a contact shadow needs this; it cannot derive it,
+   * because the composition is offset to sit on the origin.
+   */
+  get floorY() {
+    return -this.params.floor + this.centreOffset;
+  }
+  /**
+   * How far the whole composition is lifted so that it straddles the origin.
+   *
+   * The roll's axis is the sim's origin, which would park a long drop
+   * entirely below the frame — `<Paper>` and the editor both look at the
+   * origin through about two world units, and neither fits a camera to the
+   * content. `unroll` learned the same lesson and left a note about it: a
+   * composition anchored anywhere but the origin needs a bespoke camera at
+   * every call site.
+   *
+   * Measured against the FULL radius rather than the current one, so it is a
+   * constant for a given config. Deriving it from the live radius would drift
+   * the entire pile upward as the roll ran down.
+   */
+  get centreOffset() {
+    return (this.params.floor - this.outerRadius) / 2;
+  }
+  /**
+   * The same centring, along the axis the pile actually grows in.
+   *
+   * Everything here is built around the DROP LINE — the z the paper leaves
+   * the roll at — and that line is not the origin and does not stay put. It
+   * starts at 0 on a full roll and travels back to `core - outerRadius` as
+   * the roll runs down (see {@link tangentZ}), because the spiral's centre is
+   * fixed and the tangent point walks in toward it. The pile builds around
+   * wherever the line has been, so a composition that ignores this is offset
+   * by half that travel before a single fold has landed, and z is DEPTH —
+   * the axis a fixed head-on camera has the least room in.
+   *
+   * A constant for a given config, for the reason {@link centreOffset} is:
+   * derived from the live radius it would slide the whole composition
+   * backwards as the roll emptied, which reads far worse than sitting still
+   * slightly off centre. Centring the line's travel splits the difference
+   * between a full roll and an empty one.
+   */
+  get centreShift() {
+    return (this.outerRadius - this.params.core) / 2;
+  }
+  /** Outer radius of what is still wound. Shrinks to `core` as the roll empties. */
+  get radius() {
+    return rollRadius(this.totalLength - this.paid, this.params.core, layerThickness2(this.params.tightness));
+  }
+  /** Radius of the full roll. Fixes the spiral's centre, which must not move. */
+  get outerRadius() {
+    return rollRadius(this.totalLength, this.params.core, layerThickness2(this.params.tightness));
+  }
+  /**
+   * The wrap that never leaves: one full turn around the core, but never so
+   * much of a short sheet that there is nothing left to unroll.
+   *
+   * A method rather than a constant because `core` is a live control. It was
+   * a constructor-time `readonly`, which meant dragging `core` moved the
+   * radius the spiral is drawn at while `usableLength` and the end stop kept
+   * answering for the old tube — the roll would run past its own floor, or
+   * stop short of it, depending on which way the slider went.
+   */
+  stubFor(core) {
+    return Math.min(Math.PI * 2 * core, this.totalLength * 0.3);
+  }
+  /** Paper that can actually leave the roll — everything but the glued stub. */
+  get usableLength() {
+    return this.totalLength - this.tubeStub;
+  }
+  /** How much paper is left to give. `0` is down to the tube, `1` is untouched. */
+  get remaining() {
+    return 1 - this.paid / this.usableLength;
+  }
+  /**
+   * Where the paper leaves the roll: the frontmost point of the current
+   * outer wrap. The spiral's CENTRE is fixed (a lesson the `roll` deformer
+   * paid for — see its notes), so as the roll runs down the tangent point
+   * travels back toward the holder and the strip hangs closer to it. That
+   * drift is real and worth keeping.
+   */
+  get tangentZ() {
+    return this.radius - this.outerRadius;
+  }
+  /** Place every node: the wound ones on the spiral, the free ones straight down. */
+  layOut() {
+    const firstFree = this.firstFreeIndex();
+    for (let i = 0; i < this.count; i++) {
+      const p = i * 2;
+      if (i < firstFree) {
+        this.spiralPoint(this.arc[i] - this.paid, p, this.pos);
+      } else {
+        this.pos[p] = -(this.paid - this.arc[i]);
+        this.pos[p + 1] = this.tangentZ;
+      }
+    }
+    this.prev.set(this.pos);
+  }
+  /** First node that has come off the roll. Everything below it is kinematic. */
+  firstFreeIndex() {
+    const free = Math.ceil(this.count - 1 - this.paid / this.segment);
+    return Math.min(this.count - 1, Math.max(0, free));
+  }
+  /**
+   * Position of a point `wound` along the spiral from the tangent point,
+   * written into `out` at offset `o`.
+   *
+   * Angle 0 is the tangent point at the front of the roll; winding runs up
+   * over the top, which is the "over" hang. The radius falls by one layer
+   * per turn, so the wraps are concentric and exactly a thickness apart.
+   */
+  spiralPoint(wound, o, out) {
+    const r0 = this.radius;
+    const thickness = layerThickness2(this.params.tightness);
+    const k = thickness / (Math.PI * 2);
+    const phi = windAngle(Math.max(0, wound), r0, k);
+    const floor = Math.max(this.params.core, safeSpiralRadius(this.segment, thickness));
+    const r = Math.max(floor, r0 - k * phi);
+    out[o] = r * Math.sin(phi);
+    out[o + 1] = -this.outerRadius + r * Math.cos(phi);
+  }
+  setParams(params) {
+    let changed = false;
+    const tailBefore = this.params.tail;
+    for (const key of [
+      "scroll",
+      "tightness",
+      "core",
+      "tail",
+      "crease",
+      "stiffness",
+      "drag",
+      "gravity",
+      "floor",
+      "inertia"
+    ]) {
+      const value = params[key];
+      if (value !== void 0 && value !== this.params[key]) {
+        this.params[key] = value;
+        changed = true;
+      }
+    }
+    if (params.core !== void 0) {
+      this.tubeStub = this.stubFor(params.core);
+      this.paid = Math.min(this.paid, this.usableLength);
+    }
+    if (params.tail !== void 0 && tailBefore !== this.params.tail) {
+      if (!this.driven) {
+        this.paid = Math.min(this.params.tail, this.usableLength);
+        this.layOut();
+      }
+    }
+    if (changed) this.wake();
+  }
+  wake() {
+    this.asleep = false;
+    this.stillFrames = 0;
+  }
+  /**
+   * Take hold of the paper at a point, in the same y–z the vertex buffer is
+   * written in — mesh-local coordinates, the lift already applied. Returns the
+   * node caught, or -1 when there is no free paper to catch.
+   *
+   * Speaking the buffer's coordinates rather than the solver's is the whole
+   * contract here: a caller has a raycast hit on the mesh and nothing else,
+   * and the centring lift is an internal detail it has no way to know.
+   *
+   * Only paper that has left the roll can be caught — a wound node belongs to
+   * the spiral, and pinning one would be pinning the roll itself.
+   */
+  grabNearest(y, z25) {
+    const firstFree = this.firstFreeIndex();
+    const localY = y - this.centreOffset;
+    const localZ = z25 - this.centreShift;
+    let best = -1;
+    let bestDist = Infinity;
+    for (let i = firstFree; i < this.count; i++) {
+      const dy = this.pos[i * 2] - localY;
+      const dz = this.pos[i * 2 + 1] - localZ;
+      const d = dy * dy + dz * dz;
+      if (d < bestDist) {
+        bestDist = d;
+        best = i;
+      }
+    }
+    this.grabbed = best;
+    this.grabY = localY;
+    this.grabZ = localZ;
+    this.wake();
+    return best;
+  }
+  moveGrab(y, z25) {
+    if (this.grabbed < 0) return;
+    this.grabY = y - this.centreOffset;
+    this.grabZ = z25 - this.centreShift;
+    this.wake();
+  }
+  release() {
+    this.grabbed = -1;
+  }
+  /** Whether a pointer currently holds the paper. */
+  get held() {
+    return this.grabbed >= 0;
+  }
+  step(delta) {
+    if (this.params.scroll !== this.lastScroll) this.wake();
+    if (this.asleep) return;
+    this.accumulator = Math.min(this.accumulator + delta, FIXED_DT * 4);
+    while (this.accumulator >= FIXED_DT) {
+      this.substep(FIXED_DT);
+      this.accumulator -= FIXED_DT;
+    }
+  }
+  substep(dt) {
+    this.time += dt;
+    this.driveRoll(dt);
+    this.pullFeed(dt);
+    this.integrate(dt);
+    const firstFree = this.firstFreeIndex();
+    this.pinWound(firstFree);
+    for (let iter = 0; iter < SOLVER_ITERATIONS; iter++) {
+      this.solveDistance(firstFree);
+      this.solveBend(firstFree);
+      if (iter >= SOLVER_ITERATIONS - COLLIDING_ITERATIONS) {
+        this.solveSelfCollision(firstFree);
+        this.solveFloor(firstFree);
       }
-    ]
-  },
-  dangle: {
-    id: "dangle",
-    label: "Dangle",
-    transform(t, pose) {
-      pose.rotation[2] = Math.sin(t * 1.5) * 0.06;
-      pose.rotation[0] = Math.sin(t * 1.1 + 0.7) * 0.03;
+      this.pinWound(firstFree);
     }
-  },
-  taped: {
-    id: "taped",
-    label: "Taped",
-    // Taped at the top of a wall: the free bottom edge breathes.
-    stack: () => [
-      {
-        type: "wave",
-        options: { amplitude: 0.025, wavelength: 1.2, speed: 0.45, angle: 90, pinnedEdge: "top" }
+    this.solveFloor(firstFree);
+  }
+  /**
+   * Turn the roll. Scroll enters as an angle the roll OWES, which a leaky
+   * integrator spends into angular velocity — so a steady scroll gives a
+   * steady spin and a flick spikes and coasts down.
+   *
+   * `ΔL = R·Δθ` with the CURRENT radius, which is why the radius has to be
+   * read inside the loop: a nearly-empty roll spins fast and gives up very
+   * little paper for the same scroll, and that is the whole tell that a roll
+   * is running out.
+   */
+  driveRoll(dt) {
+    const scroll = this.params.scroll;
+    if (!this.primed) {
+      this.lastScroll = scroll;
+      this.primed = true;
+    }
+    const impulse = (scroll - this.lastScroll) / this.outerRadius;
+    this.lastScroll = scroll;
+    const tau = 0.012 + this.params.inertia * 0.55;
+    this.omega = this.omega * Math.exp(-dt / tau) + impulse / tau;
+    if (Math.abs(this.omega) < 1e-6) this.omega = 0;
+    const next = this.paid + this.radius * this.omega * dt;
+    if (next !== this.paid) this.driven = true;
+    this.paid = Math.min(this.usableLength, Math.max(0, next));
+    if (this.paid === 0 || this.paid === this.usableLength) this.omega = 0;
+  }
+  /**
+   * Take hold of the paper and pull, and the roll turns — the interaction the
+   * real object is famous for.
+   *
+   * It is driven by TENSION rather than by mapping hand travel to an angle.
+   * Paper does not stretch, so if the hand is further from the roll than there
+   * is paper to reach it, the only way the constraint can be satisfied is for
+   * the roll to give up more. That one rule gets the whole behaviour for free:
+   * a slow pull feeds smoothly, a fast yank spins the roll and it carries on
+   * after release, and pushing the paper back toward the roll does nothing at
+   * all — which is exactly right, because slack does not rewind a roll. Only
+   * scrolling up does.
+   */
+  pullFeed(dt) {
+    if (this.grabbed < 0 || this.grabbed < this.firstFreeIndex()) return;
+    const reach = Math.hypot(this.grabY, this.grabZ - this.tangentZ);
+    const available = this.paid - this.arc[this.grabbed];
+    const over = reach - available;
+    if (over <= 1e-6) return;
+    const feed = Math.min(over * PULL_STIFFNESS, this.usableLength - this.paid);
+    if (feed <= 0) return;
+    this.paid += feed;
+    this.omega = feed / (this.radius * dt);
+  }
+  /**
+   * Verlet with ANISOTROPIC drag. A strip of paper barely notices the air
+   * when it moves along its own length and is stopped almost dead when it
+   * moves broadside, which is the difference between paper that floats down
+   * and a rope that drops. Damping the velocity uniformly — the obvious
+   * thing, and what cloth does — gets neither.
+   */
+  integrate(dt) {
+    const { gravity, drag } = this.params;
+    const p = this.pos;
+    const dt2 = dt * dt;
+    const firstFree = this.firstFreeIndex();
+    const across = Math.exp(-(0.6 + drag * 11) * dt);
+    const along = Math.exp(-(0.4 + drag * 0.8) * dt);
+    let travel = 0;
+    for (let i = firstFree; i < this.count; i++) {
+      const o = i * 2;
+      if (i === this.grabbed) {
+        p[o] = this.grabY;
+        p[o + 1] = this.grabZ;
+        continue;
       }
-    ]
-  },
-  breeze: {
-    id: "breeze",
-    label: "Breeze",
-    stack: () => [
-      {
-        type: "wave",
-        options: { amplitude: 0.035, wavelength: 0.5, speed: 1, angle: 20, pinnedEdge: "none" }
+      const y = p[o];
+      const z25 = p[o + 1];
+      let vy = y - this.prev[o];
+      let vz = z25 - this.prev[o + 1];
+      const a = Math.max(firstFree, i - this.tangentNodes) * 2;
+      const b = Math.min(this.count - 1, i + this.tangentNodes) * 2;
+      let ty = p[b] - p[a];
+      let tz = p[b + 1] - p[a + 1];
+      const len = Math.hypot(ty, tz);
+      if (len > 1e-9) {
+        ty /= len;
+        tz /= len;
+        const vt = vy * ty + vz * tz;
+        const ny = vy - vt * ty;
+        const nz = vz - vt * tz;
+        vy = vt * ty * along + ny * across;
+        vz = vt * tz * along + nz * across;
       }
-    ]
+      this.prev[o] = y;
+      this.prev[o + 1] = z25;
+      const noise = Math.sin(this.time * 2.3 + i * 1.7) * 6e-5;
+      p[o] = y + vy - gravity * 3.2 * dt2;
+      p[o + 1] = z25 + vz + noise;
+      travel = Math.max(travel, vy * vy + vz * vz);
+    }
+    if (this.omega === 0 && this.grabbed < 0) {
+      if (travel < SLEEP_EPSILON) {
+        if (++this.stillFrames > SLEEP_FRAMES) this.asleep = true;
+      } else this.stillFrames = 0;
+    } else this.stillFrames = 0;
+  }
+  /** Wound nodes are the roll's, not the solver's: rewrite them every pass. */
+  pinWound(firstFree) {
+    for (let i = 0; i < firstFree; i++) {
+      this.spiralPoint(this.arc[i] - this.paid, i * 2, this.pos);
+    }
+    const tz = this.tangentZ;
+    for (let i = firstFree; i < Math.min(this.count, firstFree + 2); i++) {
+      if (i === this.grabbed) continue;
+      const o = i * 2;
+      this.pos[o + 1] = this.pos[o + 1] + (tz - this.pos[o + 1]) * 0.5;
+    }
+    if (this.grabbed >= firstFree) {
+      this.pos[this.grabbed * 2] = this.grabY;
+      this.pos[this.grabbed * 2 + 1] = this.grabZ;
+    }
+  }
+  /** Paper does not stretch. Distance constraints run at full strength. */
+  solveDistance(firstFree) {
+    const p = this.pos;
+    const rest = this.segment;
+    for (let i = Math.max(0, firstFree - 1); i < this.count - 1; i++) {
+      const a = i * 2;
+      const b = (i + 1) * 2;
+      const dy = p[b] - p[a];
+      const dz = p[b + 1] - p[a + 1];
+      const dist = Math.hypot(dy, dz);
+      if (dist < 1e-9) continue;
+      const diff = (dist - rest) / dist * 0.5;
+      const aFixed = i < firstFree || i === this.grabbed;
+      const bFixed = i + 1 === this.grabbed;
+      if (aFixed && bFixed) continue;
+      const aw = aFixed ? 0 : bFixed ? 2 : 1;
+      const bw = bFixed ? 0 : aFixed ? 2 : 1;
+      p[a] = p[a] + dy * diff * aw;
+      p[a + 1] = p[a + 1] + dz * diff * aw;
+      p[b] = p[b] - dy * diff * bw;
+      p[b + 1] = p[b + 1] - dz * diff * bw;
+    }
+  }
+  /**
+   * The bend constraint, and the reason this is not a rope preset.
+   *
+   * Every joint wants to be straight. A joint AT A PERFORATION wants it far
+   * less, and may want a slight fold instead — those are the hinges the pile
+   * folds at, and the alternating sign is what turns a heap into an
+   * accordion. Uniform stiffness gives a coil; no stiffness gives a rope.
+   */
+  solveBend(firstFree) {
+    const p = this.pos;
+    const { stiffness, crease } = this.params;
+    const start = Math.max(firstFree + 1, 1);
+    for (let i = start; i < this.count - 1; i++) {
+      const hinge = this.perforated[i];
+      const k = (hinge !== 0 ? stiffness * 0.06 : stiffness) * 0.45 * this.bendScale;
+      if (k <= 0) continue;
+      const a = (i - 1) * 2;
+      const m = i * 2;
+      const b = (i + 1) * 2;
+      let ty = (p[a] + p[b]) * 0.5;
+      let tz = (p[a + 1] + p[b + 1]) * 0.5;
+      if (hinge !== 0 && crease > 0) {
+        let cy = p[b] - p[a];
+        let cz = p[b + 1] - p[a + 1];
+        const len = Math.hypot(cy, cz);
+        if (len > 1e-9) {
+          cy /= len;
+          cz /= len;
+          const bow = crease * this.segment * 0.35 * hinge;
+          ty += -cz * bow;
+          tz += cy * bow;
+        }
+      }
+      const dy = (ty - p[m]) * k;
+      const dz = (tz - p[m + 1]) * k;
+      if (i !== this.grabbed) {
+        p[m] = p[m] + dy;
+        p[m + 1] = p[m + 1] + dz;
+      }
+      if (i - 1 >= firstFree && i - 1 !== this.grabbed) {
+        p[a] = p[a] - dy * 0.5;
+        p[a + 1] = p[a + 1] - dz * 0.5;
+      }
+      if (i + 1 !== this.grabbed) {
+        p[b] = p[b] - dy * 0.5;
+        p[b + 1] = p[b + 1] - dz * 0.5;
+      }
+    }
+  }
+  /**
+   * Folds stack on each other instead of passing through. Without this the
+   * pile collapses into a single flat line on the floor and there is nothing
+   * to look at, which is the entire reason the preset exists.
+   *
+   * **Segment against segment, not node against node.** The obvious version
+   * puts a sphere on every node and pushes overlapping pairs apart, and it
+   * leaks: paper is thinner than the chain is finely cut — the layer gap here
+   * is 0.027 against a node spacing of 0.037 — so those spheres do not touch
+   * each other, and the chain is a string of beads with gaps between them
+   * rather than a continuous tube. Another fold threads straight through a
+   * gap, and once it is through, the point test pushes it out the far side
+   * instead of back. It shows up exactly as a sheet edge buried in a surface.
+   *
+   * Testing the SEGMENTS closes the gaps, because a segment is the whole
+   * length of paper between two nodes and not just its ends. The cost is a
+   * closest-approach solve per candidate pair instead of a subtraction, which
+   * is why the hash cell is sized to `segment + d`: a pair that can possibly
+   * touch has its midpoints inside that, so a 3×3 neighbourhood is a complete
+   * search rather than a hopeful one.
+   *
+   * Spatial hash over preallocated arrays, refilled by counting sort — no
+   * allocation, and it does not degrade when the whole strip lands in one
+   * cell, which is exactly what a pile IS.
+   */
+  solveSelfCollision(firstFree) {
+    this.freeFrom = firstFree;
+    const p = this.pos;
+    const d = Math.max(layerThickness2(this.params.tightness), 1e-4);
+    const n = this.count;
+    const last = n - 2;
+    if (last < firstFree + 2) return;
+    const cell = this.segment + d;
+    const inv = 1 / cell;
+    const table = this.tableSize;
+    const mask = table - 1;
+    const starts = this.bucketStart;
+    const items = this.bucketItems;
+    const placed = this.bucketFill;
+    starts.fill(0);
+    placed.fill(0);
+    for (let i = firstFree; i <= last; i++) {
+      const my = (p[i * 2] + p[(i + 1) * 2]) * 0.5;
+      const mz = (p[i * 2 + 1] + p[(i + 1) * 2 + 1]) * 0.5;
+      const h = (Math.floor(my * inv) * 92837111 ^ Math.floor(mz * inv) * 689287499) >>> 0 & mask;
+      this.cellOf[i] = h;
+      starts[h + 1]++;
+    }
+    for (let c = 0; c < table; c++) starts[c + 1] += starts[c];
+    for (let i = firstFree; i <= last; i++) {
+      const h = this.cellOf[i];
+      items[starts[h] + placed[h]++] = i;
+    }
+    for (let i = firstFree; i <= last; i++) {
+      const my = (p[i * 2] + p[(i + 1) * 2]) * 0.5;
+      const mz = (p[i * 2 + 1] + p[(i + 1) * 2 + 1]) * 0.5;
+      const cy = Math.floor(my * inv);
+      const cz = Math.floor(mz * inv);
+      for (let oy = -1; oy <= 1; oy++) {
+        for (let oz = -1; oz <= 1; oz++) {
+          const h = ((cy + oy) * 92837111 ^ (cz + oz) * 689287499) >>> 0 & mask;
+          const end = starts[h + 1];
+          for (let e = starts[h]; e < end; e++) {
+            const j = items[e];
+            if (j >= i + 2) this.separate(i, j, d);
+          }
+        }
+      }
+    }
+  }
+  /**
+   * Push segments `(i, i+1)` and `(j, j+1)` apart to `d`, if they are closer.
+   *
+   * Closest approach between two 2D segments, then the correction shared over
+   * the four endpoints by how near each is to the touching point — so a fold
+   * caught at its middle moves bodily, and one grazed at its tip barely
+   * pivots. Wound and held nodes are the roll's and the hand's, so they take
+   * none of it and their partner takes the lot.
+   */
+  separate(i, j, d) {
+    const p = this.pos;
+    const a = i * 2;
+    const b = (i + 1) * 2;
+    const c = j * 2;
+    const e = (j + 1) * 2;
+    const uy = p[b] - p[a];
+    const uz = p[b + 1] - p[a + 1];
+    const vy = p[e] - p[c];
+    const vz = p[e + 1] - p[c + 1];
+    const wy = p[a] - p[c];
+    const wz = p[a + 1] - p[c + 1];
+    const uu = uy * uy + uz * uz;
+    const vv = vy * vy + vz * vz;
+    if (uu < 1e-12 || vv < 1e-12) return;
+    const uv = uy * vy + uz * vz;
+    const uw = uy * wy + uz * wz;
+    const vw = vy * wy + vz * wz;
+    const denom = uu * vv - uv * uv;
+    let s = denom > 1e-12 ? (uv * vw - vv * uw) / denom : 0;
+    s = s < 0 ? 0 : s > 1 ? 1 : s;
+    let t = (uv * s + vw) / vv;
+    if (t < 0) {
+      t = 0;
+      s = -uw / uu;
+    } else if (t > 1) {
+      t = 1;
+      s = (uv - uw) / uu;
+    }
+    s = s < 0 ? 0 : s > 1 ? 1 : s;
+    let ny = p[c] + vy * t - (p[a] + uy * s);
+    let nz = p[c + 1] + vz * t - (p[a + 1] + uz * s);
+    let dist = Math.hypot(ny, nz);
+    if (dist >= d) return;
+    if (dist < 1e-9) {
+      ny = -uz;
+      nz = uy;
+      dist = Math.hypot(ny, nz);
+      if (dist < 1e-12) return;
+      ny = -ny;
+      nz = -nz;
+    }
+    const push = (d - dist) / dist * COLLISION_RELAXATION;
+    const gy = ny * push;
+    const gz = nz * push;
+    const ki = 0.5 / ((1 - s) * (1 - s) + s * s);
+    const kj = 0.5 / ((1 - t) * (1 - t) + t * t);
+    this.nudge(i, -gy * (1 - s) * ki, -gz * (1 - s) * ki);
+    this.nudge(i + 1, -gy * s * ki, -gz * s * ki);
+    this.nudge(j, gy * (1 - t) * kj, gz * (1 - t) * kj);
+    this.nudge(j + 1, gy * t * kj, gz * t * kj);
+  }
+  /** First free node for the substep in flight — `nudge` runs in the innermost
+   *  collision loop and must not recompute it per call. */
+  freeFrom = 0;
+  /** Move a node, unless the roll or the hand owns it. */
+  nudge(i, dy, dz) {
+    if (i === this.grabbed || i < this.freeFrom) return;
+    this.pos[i * 2] = this.pos[i * 2] + dy;
+    this.pos[i * 2 + 1] = this.pos[i * 2 + 1] + dz;
+  }
+  /** Restitution 0, friction high. Paper lands and stays; it does not slide. */
+  solveFloor(firstFree) {
+    const p = this.pos;
+    const floor = -this.params.floor;
+    for (let i = firstFree; i < this.count; i++) {
+      const o = i * 2;
+      if (i === this.grabbed || p[o] >= floor) continue;
+      p[o] = floor;
+      this.prev[o] = floor;
+      this.prev[o + 1] = this.prev[o + 1] + (p[o + 1] - this.prev[o + 1]) * 0.92;
+    }
+  }
+  /**
+   * Write the chain into a 2×N quad strip, in PlaneGeometry vertex order:
+   * row-major, top row first, x left→right. Row `i` is node `i`, so the
+   * content texture runs down the strip and folds with it.
+   */
+  writeInto(out) {
+    const lift = this.centreOffset;
+    const shift = this.centreShift;
+    for (let i = 0; i < this.count; i++) {
+      const o = i * 2;
+      const y = this.pos[o] + lift;
+      const z25 = this.pos[o + 1] + shift;
+      const v = i * 6;
+      out[v] = -this.halfWidth;
+      out[v + 1] = y;
+      out[v + 2] = z25;
+      out[v + 3] = this.halfWidth;
+      out[v + 4] = y;
+      out[v + 5] = z25;
+    }
   }
 };
-function getIdlePreset(name) {
-  return idlePresets[name];
-}
 
 // src/scene/lighting.ts
 var lightingPresets = {
@@ -2637,8 +3940,8 @@ function barcodeBars(seed) {
 var money = (v) => v.toFixed(2);
 function paintReceipt(ctx, w, h, content, stock) {
   const ink = stock.inkColor;
-  const pad = w * 0.09;
-  const colWidth = w - pad * 2;
+  const pad2 = w * 0.09;
+  const colWidth = w - pad2 * 2;
   const base = Math.round(w / 15);
   const mono = (size, weight = 400) => `${weight} ${size}px ui-monospace, Menlo, Consolas, monospace`;
   let y = h * 0.045;
@@ -2651,9 +3954,9 @@ function paintReceipt(ctx, w, h, content, stock) {
   const row = (left, right, size = base) => {
     ctx.font = mono(size);
     ctx.textAlign = "left";
-    ctx.fillText(left, pad, y);
+    ctx.fillText(left, pad2, y);
     ctx.textAlign = "right";
-    ctx.fillText(right, w - pad, y);
+    ctx.fillText(right, w - pad2, y);
   };
   const divider = () => {
     ctx.font = mono(base);
@@ -3212,9 +4515,9 @@ var NOTE_TRACKING = 0.06;
 function paintCard(ctx, w, h, content, stock, dpr) {
   const ink = content.color === "#2b2620" ? stock.inkColor : content.color;
   const size = content.size * dpr;
-  const pad = content.padding * Math.min(w, h);
-  const maxWidth = w - pad * 2;
-  const x = content.align === "center" ? w / 2 : pad;
+  const pad2 = content.padding * Math.min(w, h);
+  const maxWidth = w - pad2 * 2;
+  const x = content.align === "center" ? w / 2 : pad2;
   ctx.textAlign = content.align === "center" ? "center" : "left";
   ctx.textBaseline = "alphabetic";
   const titleSize = size * TITLE_RATIO;
@@ -3226,7 +4529,7 @@ function paintCard(ctx, w, h, content, stock, dpr) {
   const noteBlock = content.note ? noteSize * 2.4 : 0;
   const bodyBlock = bodyLines.length * bodyStep;
   const total = titleBlock + ruleBlock + bodyBlock + noteBlock;
-  let y = Math.max(pad, (h - total) / 2) + size * 0.9;
+  let y = Math.max(pad2, (h - total) / 2) + size * 0.9;
   if (content.title) {
     ctx.font = `${titleSize}px ${content.font}`;
     ctx.letterSpacing = `${TITLE_TRACKING}em`;
@@ -3242,8 +4545,8 @@ function paintCard(ctx, w, h, content, stock, dpr) {
       ctx.globalAlpha = 0.28;
       ctx.lineWidth = Math.max(1, dpr * 0.75);
       ctx.beginPath();
-      ctx.moveTo(content.align === "center" ? w / 2 - maxWidth / 2 : pad, y - titleSize * 0.5);
-      ctx.lineTo(content.align === "center" ? w / 2 + maxWidth / 2 : pad + maxWidth, y - titleSize * 0.5);
+      ctx.moveTo(content.align === "center" ? w / 2 - maxWidth / 2 : pad2, y - titleSize * 0.5);
+      ctx.lineTo(content.align === "center" ? w / 2 + maxWidth / 2 : pad2 + maxWidth, y - titleSize * 0.5);
       ctx.stroke();
       ctx.restore();
       y += ruleBlock;
@@ -3257,8 +4560,8 @@ function paintCard(ctx, w, h, content, stock, dpr) {
     for (let i = 0; i < bodyLines.length; i++) {
       const lineY = y + i * bodyStep + size * 0.28;
       ctx.beginPath();
-      ctx.moveTo(pad, lineY);
-      ctx.lineTo(pad + maxWidth, lineY);
+      ctx.moveTo(pad2, lineY);
+      ctx.lineTo(pad2 + maxWidth, lineY);
       ctx.stroke();
     }
     ctx.restore();
@@ -3266,7 +4569,7 @@ function paintCard(ctx, w, h, content, stock, dpr) {
   ctx.font = `${size}px ${content.font}`;
   ctx.fillStyle = ink;
   for (const line of bodyLines) {
-    if (y > h - pad) break;
+    if (y > h - pad2) break;
     ctx.fillText(line, x, y);
     y += bodyStep;
   }
@@ -3274,7 +4577,7 @@ function paintCard(ctx, w, h, content, stock, dpr) {
     ctx.font = `${noteSize}px ${content.font}`;
     ctx.letterSpacing = `${NOTE_TRACKING}em`;
     ctx.globalAlpha = 0.6;
-    ctx.fillText(content.note, x, Math.min(y + noteSize * 1.4, h - pad));
+    ctx.fillText(content.note, x, Math.min(y + noteSize * 1.4, h - pad2));
     ctx.globalAlpha = 1;
     ctx.letterSpacing = "0em";
   }
@@ -3404,23 +4707,23 @@ function paintImage(ctx, w, h, img, fit) {
 }
 function paintText(ctx, w, h, content, stock) {
   const size = content.size * DPR;
-  const pad = content.padding * Math.min(w, h);
+  const pad2 = content.padding * Math.min(w, h);
   const font = `${content.weight} ${size}px ${content.font}`;
   ctx.font = font;
   ctx.fillStyle = content.color === "#2b2620" ? stock.inkColor : content.color;
   ctx.textBaseline = "top";
   ctx.textAlign = content.align;
   ctx.letterSpacing = `${content.tracking}em`;
-  const maxWidth = w - pad * 2;
-  const x = content.align === "left" ? pad : content.align === "right" ? w - pad : w / 2;
+  const maxWidth = w - pad2 * 2;
+  const x = content.align === "left" ? pad2 : content.align === "right" ? w - pad2 : w / 2;
   const lineStep = size * content.lineHeight;
   const lines = wrapLines(ctx, content.text, maxWidth, font);
   ctx.font = font;
   ctx.letterSpacing = `${content.tracking}em`;
   const block = lines.length * lineStep;
-  let y = content.valign === "center" ? Math.max(pad, (h - block) / 2) : pad;
+  let y = content.valign === "center" ? Math.max(pad2, (h - block) / 2) : pad2;
   for (const line of lines) {
-    if (y > h - pad) break;
+    if (y > h - pad2) break;
     ctx.fillText(line, x, y);
     y += lineStep;
   }
@@ -3560,15 +4863,51 @@ function take(out, deformer, options, sheet2, demand) {
   if (y > out[1]) out[1] = y;
 }
 
+// src/surface/creases.ts
+var MAX_SHADED = 4;
+function resolveCreases(surface, creases, sheet2) {
+  const out = [];
+  const lines = surface.creaseLines;
+  if (lines) {
+    const angle = lines.angle + 90;
+    const span = spanAlong(sheet2, angle);
+    for (const position of lines.positions) {
+      out.push({ angle, offset: (position - 0.5) * span, strength: lines.strength });
+    }
+  }
+  for (const crease of creases) {
+    out.push(creaseShading(crease));
+  }
+  if (out.length > MAX_SHADED) out.length = MAX_SHADED;
+  return out;
+}
+function creaseShading(crease) {
+  return {
+    angle: crease.angle,
+    offset: crease.offset,
+    strength: Math.max(-1, Math.min(1, -crease.depth / (90 * MAX_SET)))
+  };
+}
+
 // src/physics/cloth.ts
-var FIXED_DT = 1 / 120;
-var SOLVER_ITERATIONS = 5;
-var SLEEP_EPSILON = 1e-6;
-var SLEEP_FRAMES = 45;
+var FIXED_DT2 = 1 / 120;
+var SOLVER_ITERATIONS2 = 5;
+var AERO_TURBULENCE = 0.15;
+var GRAB_RADIUS = 0.05;
+var SLEEP_EPSILON2 = 1e-6;
+var SLEEP_FRAMES2 = 45;
+function grabFalloff(distance, radius) {
+  const t = Math.min(1, Math.max(0, distance / radius));
+  const s = 1 - t;
+  return s * s * (3 - 2 * s);
+}
 var ClothSim = class {
   cols;
   rows;
   count;
+  /** The sheet this grid was laid out on. Read by {@link adopt}. */
+  width;
+  height;
   positions;
   prev;
   pinned;
@@ -3579,17 +4918,47 @@ var ClothSim = class {
   accumulator = 0;
   stillFrames = 0;
   grabbedIndex = -1;
+  /**
+   * A normal per particle, refreshed once a frame.
+   *
+   * The sim needs these for one thing only — how much wind each part of the
+   * sheet is actually catching — and it needs its OWN rather than the mesh's,
+   * because the mesh's are computed after the fact by the adapter and a
+   * deformer may be running over the top of them by then. Once a frame rather
+   * than once a substep: paper does not turn far in eight milliseconds, and
+   * this is the only part of the step that is not a constraint solve.
+   */
+  normals;
+  /**
+   * How hard each particle is held, 0..1. Zero for all but the handful under
+   * a hand, so it doubles as the inverse mass the constraint solver wants:
+   * a particle is as immovable as it is held.
+   */
+  grabWeights;
+  /** Just the held ones, so nothing iterates the whole sheet to find six. */
+  grabbed = [];
+  /** Each held particle's offset from the one under the cursor, at grab time. */
+  grabOffsets = new Float32Array(0);
+  /** Where the hand was at the start of the last step, and how fast it moved. */
+  grabAt = new Float32Array(3);
+  grabWas = new Float32Array(3);
+  grabVelocity = new Float32Array(3);
   /** True when the sim has settled and steps are skipped. */
   asleep = false;
   constructor(cols, rows, width, height, pins, params) {
     this.cols = cols;
     this.rows = rows;
     this.count = cols * rows;
+    this.width = width;
+    this.height = height;
     this.params = { ...params };
     this.positions = new Float32Array(this.count * 3);
     this.prev = new Float32Array(this.count * 3);
     this.pinned = new Uint8Array(this.count);
     this.pinTargets = new Float32Array(this.count * 3);
+    this.grabWeights = new Float32Array(this.count);
+    this.normals = new Float32Array(this.count * 3);
+    for (let i = 0; i < this.count; i++) this.normals[i * 3 + 2] = 1;
     for (let r = 0; r < rows; r++) {
       for (let c = 0; c < cols; c++) {
         const i3 = (r * cols + c) * 3;
@@ -3629,6 +4998,54 @@ var ClothSim = class {
     }
     if (pins === "corner") pin(0, 0);
   }
+  /**
+   * Carry a previous sim's drape across a rebuild.
+   *
+   * Sheet dimensions are a GEOMETRY dependency, so changing them builds a new
+   * mesh and a new sim, and a new sim starts flat — which means a draped sheet
+   * snaps rigid the instant it is resized. Nothing about the physics requires
+   * that; it is only that nobody had carried the state over.
+   *
+   * What carries is the FREE particles, scaled by how much the sheet grew:
+   * the constraints' rest lengths are laid out afresh at the new size, so
+   * scaling the drape by the same ratio leaves every constraint exactly as
+   * violated as it was and the sim simply continues. Pinned particles keep
+   * the new layout's own rest positions instead — a pin holds a CORNER, and
+   * the corner is where the resized sheet says it is.
+   *
+   * Refused in one case only: a different grid, because there is no
+   * correspondence between the two sets of particles and the nearest thing to
+   * one would be a guess. Everything else carries — a resize, a change of
+   * pins, a deformer appearing on top. The sheet's state belongs to the sheet,
+   * and none of those is a reason to have never fallen.
+   *
+   * That matters most for the one that is not a resize at all: a shape
+   * arriving over a simulation rebuilds the mesh (the stack has its own
+   * opinion about tessellation) without touching a single thing the physics
+   * knows about. Resetting there would mean the sheet snapped flat the instant
+   * you tried to fold the sheet you were holding, which is the whole point of
+   * being able to.
+   *
+   * Returns whether it took.
+   */
+  adopt(previous) {
+    if (!previous || previous.cols !== this.cols || previous.rows !== this.rows) return false;
+    const sx = previous.width > 0 ? this.width / previous.width : 1;
+    const sy = previous.height > 0 ? this.height / previous.height : 1;
+    const sz = (sx + sy) / 2;
+    for (let i = 0; i < this.count; i++) {
+      if (this.pinned[i]) continue;
+      const i3 = i * 3;
+      this.positions[i3] = previous.positions[i3] * sx;
+      this.positions[i3 + 1] = previous.positions[i3 + 1] * sy;
+      this.positions[i3 + 2] = previous.positions[i3 + 2] * sz;
+      this.prev[i3] = previous.prev[i3] * sx;
+      this.prev[i3 + 1] = previous.prev[i3 + 1] * sy;
+      this.prev[i3 + 2] = previous.prev[i3 + 2] * sz;
+    }
+    this.wake();
+    return true;
+  }
   setParams(params) {
     let changed = false;
     for (const key of ["stiffness", "gravity", "wind", "floor"]) {
@@ -3644,6 +5061,69 @@ var ClothSim = class {
     this.asleep = false;
     this.stillFrames = 0;
   }
+  /**
+   * Take hold of the sheet at one particle.
+   *
+   * Separate from {@link grabNearest} because the particle a hand grabbed is
+   * not always the particle nearest the point it touched: with a deformer
+   * running over the simulation, what the pointer hit was a RENDERED vertex,
+   * and the vertex it hit is the particle of the same index — the stack maps
+   * a point to a point and never reorders them.
+   *
+   * What is taken hold of is a PATCH around that particle, not the particle
+   * alone — see {@link GRAB_RADIUS}. The patch is measured across the GRID
+   * rather than through space, because a hand holds a piece of the sheet and
+   * keeps holding the same piece: measured through space, a fold that brought
+   * a far corner near the fingers would silently add it to the grip.
+   */
+  grab(index) {
+    this.grabbedIndex = index >= 0 && index < this.count ? index : -1;
+    this.grabWeights.fill(0);
+    this.grabbed = [];
+    if (this.grabbedIndex < 0) {
+      this.grabOffsets = new Float32Array(0);
+      this.wake();
+      return -1;
+    }
+    const cellX = this.cols > 1 ? this.width / (this.cols - 1) : this.width;
+    const cellY = this.rows > 1 ? this.height / (this.rows - 1) : this.height;
+    const cell = Math.max(cellX, cellY, 1e-6);
+    const radius = Math.min(
+      Math.max(GRAB_RADIUS, cell * 1.5),
+      Math.max(cell, Math.min(this.width, this.height) * 0.2)
+    );
+    const centreRow = Math.floor(this.grabbedIndex / this.cols);
+    const centreCol = this.grabbedIndex % this.cols;
+    const spanRows = Math.ceil(radius / cellY);
+    const spanCols = Math.ceil(radius / cellX);
+    const offsets = [];
+    const anchor = this.grabbedIndex * 3;
+    for (let r = centreRow - spanRows; r <= centreRow + spanRows; r++) {
+      if (r < 0 || r >= this.rows) continue;
+      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;
+        const distance = Math.hypot((c - centreCol) * cellX, (r - centreRow) * cellY);
+        const weight = i === this.grabbedIndex ? 1 : grabFalloff(distance, radius);
+        if (weight <= 0) continue;
+        this.grabWeights[i] = weight;
+        this.grabbed.push(i);
+        const i3 = i * 3;
+        offsets.push(
+          this.positions[i3] - this.positions[anchor],
+          this.positions[i3 + 1] - this.positions[anchor + 1],
+          this.positions[i3 + 2] - this.positions[anchor + 2]
+        );
+      }
+    }
+    this.grabOffsets = Float32Array.from(offsets);
+    this.grabAt.set(this.positions.subarray(anchor, anchor + 3));
+    this.grabWas.set(this.grabAt);
+    this.grabVelocity.fill(0);
+    this.wake();
+    return this.grabbedIndex;
+  }
   /** Nearest particle to a local-space point — the grab interface. */
   grabNearest(x, y, z25) {
     let best = -1;
@@ -3658,30 +5138,108 @@ var ClothSim = class {
         best = i;
       }
     }
-    this.grabbedIndex = best;
-    this.wake();
-    return best;
+    return this.grab(best);
+  }
+  /** How hard one particle is being held, 0..1 — for tests and for the adapter. */
+  grabWeightAt(index) {
+    return this.grabWeights[index] ?? 0;
   }
+  /** Where the fingers are now. The patch follows, each particle by its weight. */
   moveGrab(x, y, z25) {
     if (this.grabbedIndex < 0) return;
-    const i3 = this.grabbedIndex * 3;
-    this.positions[i3] = x;
-    this.positions[i3 + 1] = y;
-    this.positions[i3 + 2] = z25;
-    this.prev[i3] = x;
-    this.prev[i3 + 1] = y;
-    this.prev[i3 + 2] = z25;
+    this.grabAt[0] = x;
+    this.grabAt[1] = y;
+    this.grabAt[2] = z25;
     this.wake();
   }
+  /**
+   * Let go — and let go at SPEED.
+   *
+   * This used to drop the paper dead. Every held particle had its previous
+   * position overwritten with its current one on the way past, and in a verlet
+   * integrator the gap between those two IS the velocity, so a sheet whipped
+   * across the frame and released came to a perfect standstill and then fell
+   * straight down. Whatever you did with your hand, the paper had never heard
+   * of it.
+   *
+   * The hand's velocity is measured per second (see {@link step}) and spent
+   * here, converted into the one-substep gap the integrator reads it back out
+   * of. Measured per second rather than per frame because a frame is not a
+   * fixed length and a substep is: throwing the same sheet at the same speed
+   * must not depend on what the frame rate happened to be.
+   */
   release() {
+    for (const i of this.grabbed) {
+      const i3 = i * 3;
+      const held = this.grabWeights[i];
+      this.prev[i3] = this.positions[i3] - this.grabVelocity[0] * FIXED_DT2 * held;
+      this.prev[i3 + 1] = this.positions[i3 + 1] - this.grabVelocity[1] * FIXED_DT2 * held;
+      this.prev[i3 + 2] = this.positions[i3 + 2] - this.grabVelocity[2] * FIXED_DT2 * held;
+    }
     this.grabbedIndex = -1;
+    this.grabbed = [];
+    this.grabWeights.fill(0);
+    this.grabVelocity.fill(0);
+    this.wake();
   }
   step(delta) {
     if (this.asleep) return;
-    this.accumulator = Math.min(this.accumulator + delta, FIXED_DT * 4);
-    while (this.accumulator >= FIXED_DT) {
-      this.substep(FIXED_DT);
-      this.accumulator -= FIXED_DT;
+    if (this.grabbedIndex >= 0 && delta > 0) {
+      for (let axis = 0; axis < 3; axis++) {
+        this.grabVelocity[axis] = (this.grabAt[axis] - this.grabWas[axis]) / delta;
+      }
+      this.grabWas.set(this.grabAt);
+    }
+    this.updateNormals();
+    this.accumulator = Math.min(this.accumulator + delta, FIXED_DT2 * 4);
+    while (this.accumulator >= FIXED_DT2) {
+      this.substep(FIXED_DT2);
+      this.accumulator -= FIXED_DT2;
+    }
+  }
+  /**
+   * Which way each part of the sheet is facing, by central difference across
+   * the grid.
+   *
+   * Clamped at the edges rather than wrapped or skipped: an edge particle
+   * takes the one-sided difference, which is the same normal its neighbour
+   * has, and an edge with no normal is an edge the wind cannot push.
+   *
+   * Which SIDE the normal points at is deliberately not worried about. The
+   * force below is `n (n·v)`, a quadratic form, and that is unchanged by
+   * flipping n — which is exactly right for paper, a surface with no front as
+   * far as the air is concerned.
+   */
+  updateNormals() {
+    const p = this.positions;
+    const n = this.normals;
+    for (let r = 0; r < this.rows; r++) {
+      for (let c = 0; c < this.cols; c++) {
+        const left = (r * this.cols + (c > 0 ? c - 1 : c)) * 3;
+        const right = (r * this.cols + (c < this.cols - 1 ? c + 1 : c)) * 3;
+        const up = ((r > 0 ? r - 1 : r) * this.cols + c) * 3;
+        const down = ((r < this.rows - 1 ? r + 1 : r) * this.cols + c) * 3;
+        const ux = p[right] - p[left];
+        const uy = p[right + 1] - p[left + 1];
+        const uz = p[right + 2] - p[left + 2];
+        const vx = p[down] - p[up];
+        const vy = p[down + 1] - p[up + 1];
+        const vz = p[down + 2] - p[up + 2];
+        const nx = vy * uz - vz * uy;
+        const ny = vz * ux - vx * uz;
+        const nz = vx * uy - vy * ux;
+        const length = Math.sqrt(nx * nx + ny * ny + nz * nz);
+        const i3 = (r * this.cols + c) * 3;
+        if (length > 1e-12) {
+          n[i3] = nx / length;
+          n[i3 + 1] = ny / length;
+          n[i3 + 2] = nz / length;
+        } else {
+          n[i3] = 0;
+          n[i3 + 1] = 0;
+          n[i3 + 2] = 0;
+        }
+      }
     }
   }
   substep(dt) {
@@ -3693,12 +5251,10 @@ var ClothSim = class {
     let maxTravel = 0;
     for (let i = 0; i < this.count; i++) {
       const i3 = i * 3;
-      if (this.pinned[i] || i === this.grabbedIndex) {
-        if (this.pinned[i]) {
-          p[i3] = this.pinTargets[i3];
-          p[i3 + 1] = this.pinTargets[i3 + 1];
-          p[i3 + 2] = this.pinTargets[i3 + 2];
-        }
+      if (this.pinned[i]) {
+        p[i3] = this.pinTargets[i3];
+        p[i3 + 1] = this.pinTargets[i3 + 1];
+        p[i3 + 2] = this.pinTargets[i3 + 2];
         this.prev[i3] = p[i3];
         this.prev[i3 + 1] = p[i3 + 1];
         this.prev[i3 + 2] = p[i3 + 2];
@@ -3707,21 +5263,39 @@ var ClothSim = class {
       const x = p[i3];
       const y = p[i3 + 1];
       const z25 = p[i3 + 2];
-      const gust2 = wind * (0.55 + 0.45 * Math.sin(this.time * 1.7 + x * 2.1 + y * 1.3)) * 0.9;
-      const ax = gust2 * 0.25;
-      const az = gust2;
       const vx = (x - this.prev[i3]) * damping;
       const vy = (y - this.prev[i3 + 1]) * damping;
       const vz = (z25 - this.prev[i3 + 2]) * damping;
+      const gust2 = wind * (0.55 + 0.45 * Math.sin(this.time * 1.7 + x * 2.1 + y * 1.3)) * 0.9;
+      const relX = gust2 * 0.25 - vx / dt;
+      const relY = -vy / dt;
+      const relZ = gust2 - vz / dt;
+      const nx = this.normals[i3];
+      const ny = this.normals[i3 + 1];
+      const nz = this.normals[i3 + 2];
+      const facing = nx * relX + ny * relY + nz * relZ;
+      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;
       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 - gravity * 3.2 * dt2;
+      p[i3 + 1] = y + vy + (ay - gravity * 3.2) * dt2;
       p[i3 + 2] = z25 + vz + az * dt2;
       maxTravel = Math.max(maxTravel, vx * vx + vy * vy + vz * vz);
     }
-    for (let iter = 0; iter < SOLVER_ITERATIONS; iter++) {
+    for (let k = 0; k < this.grabbed.length; k++) {
+      const i = this.grabbed[k];
+      const i3 = i * 3;
+      const k3 = k * 3;
+      const held = this.grabWeights[i];
+      for (let axis = 0; axis < 3; axis++) {
+        const target = this.grabAt[axis] + this.grabOffsets[k3 + axis];
+        p[i3 + axis] = p[i3 + axis] + (target - p[i3 + axis]) * held;
+      }
+    }
+    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;
@@ -3731,12 +5305,13 @@ var ClothSim = class {
         const dz = p[b3 + 2] - p[a3 + 2];
         const dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
         if (dist === 0) continue;
-        const diff = (dist - c.rest) / dist * 0.5 * k;
-        const aPinned = this.pinned[c.a] || c.a === this.grabbedIndex;
-        const bPinned = this.pinned[c.b] || c.b === this.grabbedIndex;
-        if (aPinned && bPinned) continue;
-        const aw = aPinned ? 0 : bPinned ? 2 : 1;
-        const bw = bPinned ? 0 : aPinned ? 2 : 1;
+        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 total = ma + mb;
+        if (total <= 0) continue;
+        const diff = (dist - c.rest) / dist / total * k;
+        const aw = ma;
+        const bw = mb;
         p[a3] = p[a3] + dx * diff * aw;
         p[a3 + 1] = p[a3 + 1] + dy * diff * aw;
         p[a3 + 2] = p[a3 + 2] + dz * diff * aw;
@@ -3754,8 +5329,8 @@ var ClothSim = class {
       }
     }
     if (wind === 0 && this.grabbedIndex < 0) {
-      if (maxTravel < SLEEP_EPSILON) {
-        if (++this.stillFrames > SLEEP_FRAMES) this.asleep = true;
+      if (maxTravel < SLEEP_EPSILON2) {
+        if (++this.stillFrames > SLEEP_FRAMES2) this.asleep = true;
       } else {
         this.stillFrames = 0;
       }
@@ -3844,6 +5419,7 @@ function translucencyUniforms(translucency, lighting) {
 }
 
 // src/surface/compose.ts
+var SHADED_CREASE = 0.35;
 var VERTEX = (
   /* glsl */
   `
@@ -3860,6 +5436,89 @@ var HELPERS = (
   `
 varying vec2 vPaperUv;
 uniform float uBackDarken;
+uniform vec2 uSheetSize;
+
+/**
+ * Where this fragment is on the sheet, in the sheet's OWN local space \u2014
+ * the same coordinates the deformers displace, centred on the sheet.
+ *
+ * Every effect below measures in these rather than in UV, and the difference
+ * is not cosmetic. UV divides the sheet's aspect out, so a 1.2 x 1.5 sheet is
+ * a unit square as far as the shader is concerned: fibre drawn round comes out
+ * stretched, a tear bites deeper into the short edge than the long one, and a
+ * crease line scored at 45 degrees renders at 51. Worse, all three change when
+ * the sheet is RESIZED, which makes the paper's own material a function of how
+ * big the piece is. Grain is a property of the stock and a crease is a broken
+ * fibre; neither knows how large a sheet it was cut from.
+ */
+vec2 plLocal() {
+  return (vPaperUv - 0.5) * uSheetSize;
+}
+
+/**
+ * The paper's relief, in world units above the sheet the mesh describes.
+ *
+ * Accumulated by whichever effects have a shape as well as a colour, and
+ * spent once at the end of main by {@link plPerturb}. One shared field rather
+ * than a perturbation per effect, because two effects that both tilt the
+ * surface tilt it TOGETHER \u2014 a crease across a grained sheet is one surface,
+ * not a crease lit on top of a grain lit on top of the paper.
+ */
+float plHeight;
+
+/**
+ * The relief, turned into the normal the lighting actually runs on.
+ *
+ * This is the change that makes the surface effects respond to light at all.
+ * They used to be painted: a crease multiplied a grey band into the albedo
+ * and added a fixed white sheen beside it, so the mark looked identical from
+ * every angle and under every rig, and turning the sheet under the key light
+ * did nothing to it. Real creased paper is two facets meeting at a line \u2014
+ * swing it and the crease flips from a dark line to a bright one. Only a
+ * normal can do that, so now the effects describe a HEIGHT and the standard
+ * material lights it.
+ *
+ * The maths is Mikkelsen's surface-gradient bump, which is what three's own
+ * perturbNormalArb implements, with one deliberate difference: three
+ * normalises the screen-space position derivatives, which makes a bump map
+ * look the same at any scale and is the right call for a texture. Ours is a
+ * real depth in world units \u2014 a crease is as deep as it is however close you
+ * stand \u2014 so the raw derivatives stay, and the ratio between them and the
+ * height's is a true surface slope.
+ *
+ * Analytic height plus screen derivatives also anti-aliases itself for free:
+ * as a crease shrinks below a pixel the derivative flattens and the mark
+ * fades, rather than crawling.
+ */
+vec3 plPerturb(vec3 n, float height) {
+  vec2 dH = vec2(dFdx(height), dFdy(height));
+  if (dH.x == 0.0 && dH.y == 0.0) return n;
+  // View-space position: the varying is its negation, by three's convention.
+  vec3 sigmaX = dFdx(-vViewPosition);
+  vec3 sigmaY = dFdy(-vViewPosition);
+  vec3 r1 = cross(sigmaY, n);
+  vec3 r2 = cross(n, sigmaX);
+  float det = dot(sigmaX, r1) * (gl_FrontFacing ? 1.0 : -1.0);
+  if (abs(det) < 1e-12) return n;
+  vec3 grad = sign(det) * (dH.x * r1 + dH.y * r2);
+  return normalize(abs(det) * n - grad);
+}
+
+/**
+ * A gaussian bell of unit width, pre-filtered against this fragment's own
+ * footprint.
+ *
+ * Convolving a gaussian with the pixel broadens it and flattens it by the
+ * same factor, which conserves the integral: a crease seen from across the
+ * room dims instead of breaking into a dotted line. s is the distance
+ * across the feature in units of its own width, so a caller only ever has to
+ * decide how wide the thing is.
+ */
+float plBell(float s) {
+  float px = fwidth(s);
+  float widen = sqrt(1.0 + px * px);
+  return exp(-(s * s) / (widen * widen)) / widen;
+}
 
 float plHash(vec2 p) {
   return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453123);
@@ -3900,12 +5559,54 @@ var GRAIN_CHUNK = (
 uniform float uGrainAmount;
 uniform float uGrainBanding;
 
+/**
+ * Fibre density, per world unit.
+ *
+ * Per WORLD UNIT and not per UV, which is the whole fix: the fibre in a sheet
+ * is the stock's, and it does not get coarser because someone cut a bigger
+ * piece or stretch oval because the piece is taller than it is wide.
+ *
+ * The number is carried over from when it was a UV frequency, so a sheet one
+ * world unit wide is unchanged across its width. Its height is not, and that
+ * is the point: a 1.4-tall sheet used to fit the same 240 cycles into a
+ * longer span and its fibre ran visibly coarser the other way.
+ */
+const float PL_FIBRE = 240.0;
+
+/**
+ * The coarser structure underneath it \u2014 paper's tooth, the part that has a
+ * SHAPE and not just a colour.
+ *
+ * Separate from the fibre, and much lower, for a reason worth writing down:
+ * the relief is differentiated in screen space, and a field at the fibre's own
+ * frequency is a few pixels per cycle at any sane viewing distance, so its
+ * derivative is noise and the sheet would sparkle. The tooth is safely above
+ * the sampling rate, and it is the scale at which paper actually catches a
+ * raking light anyway.
+ */
+const float PL_TOOTH = 70.0;
+
+/**
+ * How far the tooth stands proud, in world units, at full grain.
+ *
+ * Real paper's surface relief is tens of microns. Against a sheet whose width
+ * is one world unit \u2014 call it A4 \u2014 0.00035 is about 70 microns, and at the
+ * tooth's wavelength that is a surface tilting by four degrees or so. Enough
+ * to break a specular highlight into paper, not enough to look pebbled.
+ */
+const float PL_TOOTH_RELIEF = 0.00035;
+
 void plGrain(inout vec4 color, inout float rough) {
-  float fiber = plFbm(vPaperUv * 240.0);
-  float fleck = plNoise(vPaperUv * 900.0);
+  vec2 local = plLocal();
+  float fiber = plFbm(local * PL_FIBRE);
+  float fleck = plNoise(local * (PL_FIBRE * 3.75));
   float g = mix(0.5, fiber * 0.75 + fleck * 0.25, uGrainAmount);
   color.rgb *= 0.92 + g * 0.16;
   rough = clamp(rough + (g - 0.5) * uGrainAmount * 0.35, 0.0, 1.0);
+  // The tooth, handed to the lighting rather than drawn. A single octave: the
+  // relief only needs the scale the eye reads as texture, and the fbm above
+  // is already carrying everything finer as colour.
+  plHeight += (plNoise(local * PL_TOOTH) - 0.5) * PL_TOOTH_RELIEF * uGrainAmount;
   // Thermal-printer banding: faint horizontal density stripes.
   if (uGrainBanding > 0.0) {
     float band = sin(vPaperUv.y * 700.0) * 0.5 + 0.5;
@@ -3920,18 +5621,33 @@ var DECKLE_CHUNK = (
 uniform vec4 uDeckleEdges; // top, right, bottom, left
 uniform float uDeckleRoughness;
 
+/** Gnaw frequency along a torn edge, per world unit \u2014 see {@link plLocal}. */
+const float PL_DECKLE_GNAW = 26.0;
+
 void plDeckle(inout vec4 color) {
   // Distance to each selected edge, gnawed by low-frequency noise.
-  float depth = 0.012 + uDeckleRoughness * 0.05;
+  //
+  // The depth is in world units, taken against the sheet's mean dimension.
+  // Against the MEAN rather than each edge's own span, which is what UV
+  // amounted to: one roughness used to bite a third deeper into the short
+  // edges of a 1 x 1.4 sheet than the long ones, for no reason anybody chose.
+  //
+  // Still proportional to the sheet rather than absolute, which is a decision
+  // and not an oversight. A real deckle is a fibre length and would be the
+  // same depth on any size of sheet; roughness is a 0..1 knob someone types,
+  // and an absolute one would vanish on a poster and swallow a stamp.
+  float depth = (0.012 + uDeckleRoughness * 0.05) * (uSheetSize.x + uSheetSize.y) * 0.5;
   float tear = 1.0;
   float fiberBand = 0.0;
   vec4 dists = vec4(1.0 - vPaperUv.y, 1.0 - vPaperUv.x, vPaperUv.y, vPaperUv.x);
   vec4 alongs = vec4(vPaperUv.x, vPaperUv.y, vPaperUv.x, vPaperUv.y);
+  vec4 distScale = vec4(uSheetSize.y, uSheetSize.x, uSheetSize.y, uSheetSize.x);
+  vec4 alongScale = vec4(uSheetSize.x, uSheetSize.y, uSheetSize.x, uSheetSize.y);
   for (int e = 0; e < 4; e++) {
     if (uDeckleEdges[e] < 0.5) continue;
-    float n = plFbm(vec2(alongs[e] * 26.0, float(e) * 7.31)) - 0.5;
+    float n = plFbm(vec2(alongs[e] * alongScale[e] * PL_DECKLE_GNAW, float(e) * 7.31)) - 0.5;
     float boundary = depth * (0.55 + n * 1.6);
-    float d = dists[e] - boundary;
+    float d = dists[e] * distScale[e] - boundary;
     tear = min(tear, step(0.0, d));
     // Lightened fiber band just inside the tear.
     fiberBand = max(fiberBand, smoothstep(depth * 1.4, 0.0, d) * step(0.0, d));
@@ -3944,23 +5660,55 @@ void plDeckle(inout vec4 color) {
 var CREASE_CHUNK = (
   /* glsl */
   `
-uniform float uCreaseAngle;
-uniform float uCreaseStrength;
-uniform float uCreasePositions[4];
+uniform float uCreaseAngles[4];
+uniform float uCreaseStrengths[4];
+uniform float uCreaseOffsets[4];
+uniform float uCreaseWidth;
 uniform int uCreaseCount;
 
+/**
+ * Peak tilt of a crease's own facets, as a slope.
+ *
+ * A gaussian groove of amplitude A and width w reaches a maximum slope of
+ * about 0.86 A/w, so an amplitude of 0.55 w peaks near 25 degrees \u2014 steep
+ * enough that turning the sheet visibly flips the line from dark to bright,
+ * shallow enough that it never reads as a fold in its own right. Held as a
+ * SLOPE rather than a depth because that is the quantity the lighting
+ * responds to, and the only one that stays honest when the width changes.
+ */
+const float PL_CREASE_TILT = 0.55;
+
+/** How much grime a crease traps, at full strength. */
+const float PL_CREASE_SOIL = 0.1;
+
 void plCrease(inout vec4 color, inout float rough) {
-  vec2 dir = vec2(cos(uCreaseAngle), sin(uCreaseAngle));
-  // Coordinate across the crease lines (0..1 over the sheet).
-  float t = dot(vPaperUv - 0.5, vec2(-dir.y, dir.x)) + 0.5;
+  vec2 p = plLocal();
   for (int i = 0; i < 4; i++) {
     if (i >= uCreaseCount) break;
-    float d = abs(t - uCreasePositions[i]);
-    float shadow = smoothstep(0.014, 0.0, d);
-    float sheen = smoothstep(0.02, 0.006, d) - smoothstep(0.006, 0.0, d);
-    color.rgb *= 1.0 - shadow * uCreaseStrength * 0.28;
-    color.rgb += sheen * uCreaseStrength * 0.05;
-    rough = clamp(rough + shadow * uCreaseStrength * 0.2, 0.0, 1.0);
+    vec2 dir = vec2(cos(uCreaseAngles[i]), sin(uCreaseAngles[i]));
+    // The identical measurement the fold deformer displaces by: signed
+    // distance across the line, in the sheet's own space. Shading and
+    // geometry cannot place a crease differently when the number they place
+    // it by is the same number.
+    float s = (dot(p, dir) - uCreaseOffsets[i]) / uCreaseWidth;
+    float strength = uCreaseStrengths[i];
+    float bell = plBell(s);
+
+    // The relief. This is the fine burnished line where the fibres broke, and
+    // it is deliberately narrower than the hinge the fold deformer bends
+    // over: the mesh carries the wide bend, the shader carries the crease
+    // inside it, and the two add up instead of competing. Signed, so a
+    // mountain stands proud and a valley cuts in \u2014 the same crease read from
+    // the other side of the sheet is the other one.
+    plHeight += strength * uCreaseWidth * PL_CREASE_TILT * bell;
+
+    // What is left for the albedo once the lighting is doing the work: a
+    // crease collects dirt and its broken fibres scatter wider. The grey band
+    // and the painted-on sheen that used to live here were standing in for a
+    // normal, and there is one now.
+    float mark = bell * abs(strength);
+    color.rgb *= 1.0 - mark * PL_CREASE_SOIL;
+    rough = clamp(rough + mark * 0.3, 0.0, 1.0);
   }
 }
 `
@@ -3972,7 +5720,6 @@ uniform vec4 uPerfEdges;   // top, right, bottom, left enabled
 uniform vec4 uPerfTorn;    // 1 = ripped-through profile, 0 = clean punches
 uniform float uPerfRadius; // world units
 uniform float uPerfSpacing;
-uniform vec2 uSheetSize;
 
 void plPerforation(inout vec4 color) {
   // Per-edge distance/along coordinates, converted from UV to world units so
@@ -4023,11 +5770,10 @@ void plAging(inout vec4 color) {
 }
 `
 );
-function composeSurface(surface, stock, thickness, maps = { hasFrontMap: false, hasBackMap: false }, sheet2 = { width: 1, height: 1.4 }, lighting = "studio") {
+function composeSurface(surface, stock, thickness, maps = { hasFrontMap: false, hasBackMap: false }, sheet2 = { width: 1, height: 1.4 }, lighting = "studio", creases = resolveCreases(surface, [], sheet2)) {
   const grain = surface.grain ?? stock.defaultSurface.grain;
   const aging = surface.aging ?? stock.defaultSurface.aging;
   const deckle = surface.deckle;
-  const creases = surface.creaseLines;
   const perforation = surface.perforation;
   const banding = stock.banding;
   const showThrough = stock.adhesive ? 0 : surface.showThrough ?? stock.showThrough;
@@ -4040,6 +5786,9 @@ function composeSurface(surface, stock, thickness, maps = { hasFrontMap: false,
       value: stock.adhesive ? 1 : 1 - Math.min(0.45, 0.12 + thickness * 0.9) * stock.opacity
     },
     uStockColor: { value: new THREE5.Color(stock.color) },
+    // Always present, not just when something asks for it: every effect that
+    // measures anything measures in the sheet's own space now — see plLocal.
+    uSheetSize: { value: new THREE5.Vector2(sheet2.width, sheet2.height) },
     uOpacity: { value: stock.opacity },
     uShowThrough: { value: showThrough },
     // Always compiled in: the shader early-outs at zero translucency, which
@@ -4072,21 +5821,22 @@ function composeSurface(surface, stock, thickness, maps = { hasFrontMap: false,
     };
     uniforms.uPerfRadius = { value: perforation.holeRadius };
     uniforms.uPerfSpacing = { value: perforation.spacing };
-    uniforms.uSheetSize = { value: new THREE5.Vector2(sheet2.width, sheet2.height) };
   }
-  if (creases) {
+  if (creases.length > 0) {
     chunks.push(CREASE_CHUNK);
     calls.push("plCrease(csm_DiffuseColor, csm_Roughness);");
-    uniforms.uCreaseAngle = { value: creases.angle * Math.PI / 180 };
-    uniforms.uCreaseStrength = { value: creases.strength };
-    uniforms.uCreasePositions = { value: padPositions(creases.positions) };
-    uniforms.uCreaseCount = { value: Math.min(creases.positions.length, 4) };
+    uniforms.uCreaseAngles = { value: pad(creases.map((c) => c.angle * Math.PI / 180)) };
+    uniforms.uCreaseStrengths = { value: pad(creases.map((c) => c.strength)) };
+    uniforms.uCreaseOffsets = { value: pad(creases.map((c) => c.offset)) };
+    uniforms.uCreaseWidth = { value: CREASE_RADIUS * SHADED_CREASE };
+    uniforms.uCreaseCount = { value: Math.min(creases.length, 4) };
   }
   if (aging !== void 0) {
     chunks.push(AGING_CHUNK);
     calls.push("plAging(csm_DiffuseColor);");
     uniforms.uAgingAmount = { value: aging };
   }
+  const relief = grain !== void 0 || creases.length > 0;
   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 = (
@@ -4101,6 +5851,7 @@ ${maps.hasBackMap && !stock.adhesive ? "uniform sampler2D uBackMap;" : ""}
 ${TRANSLUCENCY_FRAGMENT}
 ${chunks.join("\n")}
 void main() {
+  plHeight = 0.0;
   vec3 front = ${frontExpr};
   if (gl_FrontFacing) {
     csm_DiffuseColor = vec4(front, uOpacity);
@@ -4109,6 +5860,7 @@ void main() {
     csm_DiffuseColor = vec4(backBase * mix(vec3(1.0), front, uShowThrough), uOpacity);
   }
   ${calls.join("\n  ")}
+${relief ? "  // The relief every effect above described, spent once \u2014 see plPerturb.\n  csm_FragNormal = plPerturb(csm_FragNormal, plHeight);" : ""}
   if (!gl_FrontFacing) csm_DiffuseColor.rgb *= uBackDarken;
   ${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.
@@ -4120,7 +5872,7 @@ void main() {
     structureKey: `${[
       grain !== void 0 || banding > 0 ? "g" : "",
       deckle ? "d" : "",
-      creases ? "c" : "",
+      creases.length > 0 ? "c" : "",
       aging !== void 0 ? "a" : "",
       perforation ? "p" : "",
       stock.adhesive ? "A" : ""
@@ -4131,9 +5883,9 @@ void main() {
     alphaTest: deckle || perforation ? 0.5 : 0
   };
 }
-function padPositions(positions) {
-  const out = positions.slice(0, 4);
-  while (out.length < 4) out.push(-1);
+function pad(values, fill = 0) {
+  const out = values.slice(0, 4);
+  while (out.length < 4) out.push(fill);
   return out;
 }
 
@@ -4146,7 +5898,8 @@ function PaperMaterial({
   surface,
   thickness,
   sheet: sheet2,
-  lighting = "studio"
+  lighting = "studio",
+  creases
 }) {
   const rig = useLightRig(lighting);
   const composed = composeSurface(
@@ -4158,7 +5911,8 @@ function PaperMaterial({
       hasBackMap: Boolean(backTexture)
     },
     sheet2,
-    rig
+    rig,
+    creases ?? resolveCreases(surface, [], sheet2 ?? { width: 1, height: 1.4 })
   );
   const bound = useMemo2(() => composed.uniforms, [composed.structureKey]);
   useEffect4(() => {
@@ -4216,6 +5970,7 @@ function configInputs(props) {
     props.behavior ?? null,
     props.deformers ?? null,
     props.surface ?? null,
+    props.memory ?? null,
     props.scene ?? null,
     props.physics ?? null,
     props.onTwos ?? null
@@ -4234,6 +5989,7 @@ function resolveConfig(props) {
   if (props.behavior) overrides.behavior = props.behavior;
   if (props.deformers) overrides.deformers = props.deformers;
   if (props.surface) overrides.surface = { ...base.surface, ...props.surface };
+  if (props.memory) overrides.memory = { ...base.memory, ...props.memory };
   if (props.scene) overrides.scene = { ...base.scene, ...props.scene };
   if (props.physics) overrides.physics = props.physics;
   if (props.onTwos !== void 0) overrides.onTwos = props.onTwos;
@@ -4261,7 +6017,9 @@ var PaperMesh = forwardRef(function PaperMesh2(props, ref) {
   machineRef.current = machine;
   const resolvedRef = useRef3(resolved);
   resolvedRef.current = resolved;
-  const isCloth = !reduced && typeof config.physics === "object";
+  const simKind = !reduced && typeof config.physics === "object" ? config.physics.type : null;
+  const isCloth = simKind === "cloth";
+  const isStrip = simKind === "strip";
   const idle = !reduced && typeof config.physics === "string" && config.physics !== "none" ? getIdlePreset(config.physics) : null;
   const meshRef = useRef3(null);
   const groupRef = useRef3(null);
@@ -4273,19 +6031,33 @@ var PaperMesh = forwardRef(function PaperMesh2(props, ref) {
   const draggingRef = useRef3(null);
   const configRef = useRef3(config);
   configRef.current = config;
+  const baseRotation = useMemo3(() => {
+    const [rx, ry, rz] = props.rotation ?? [0, 0, 0];
+    return [rx, ry + config.scene.turn * Math.PI / 180, rz];
+  }, [props.rotation, config.scene.turn]);
   const controls = useThree((s) => s.controls);
   const camera = useThree((s) => s.camera);
   const behaviorKey = JSON.stringify(config.behavior ?? null);
   const deformersKey = JSON.stringify(config.deformers ?? null);
   const sheetKey = JSON.stringify(config.sheet);
-  const physicsKey = JSON.stringify(config.physics);
+  const physicsKey = typeof config.physics === "object" ? config.physics.type : config.physics;
+  const memoryKey = config.memory.creases.map((c) => `${c.angle}:${c.offset}`).join("|");
+  const creaseKey = config.memory.creases.map((c) => `${c.angle}:${c.offset}:${c.depth}`).join("|");
+  const creasesRef = useRef3(null);
+  creasesRef.current ??= new CreaseTracker(config.memory.creases);
+  const creases = creasesRef.current;
   useEffect5(() => {
     if (!draggingRef.current && !playingRef.current) overridesRef.current = {};
+    creases.reset();
     dirtyRef.current = true;
   }, [behaviorKey, deformersKey, sheetKey, physicsKey]);
+  useEffect5(() => {
+    creases.adopt(configRef.current.memory.creases);
+    dirtyRef.current = true;
+  }, [creaseKey]);
   const { minSegments, autoSegments, animatedStack } = useMemo3(() => {
     const cfg = configRef.current;
-    const probe2 = buildStack(cfg, {});
+    const probe2 = withMemory(buildStack(cfg, {}), cfg);
     if (!probe2) {
       return {
         minSegments: [2, 2],
@@ -4298,7 +6070,7 @@ var PaperMesh = forwardRef(function PaperMesh2(props, ref) {
     if (cfg.behavior && !cfg.deformers) {
       const param = getBehavior(cfg.behavior.type).progressParam;
       for (const p of PROGRESS_SAMPLES) {
-        const at = buildStack(cfg, { [param]: p });
+        const at = withMemory(buildStack(cfg, { [param]: p }), cfg);
         if (!at) continue;
         const [x, y] = stackAutoSegments(at, cfg.sheet);
         if (x > want[0]) want[0] = x;
@@ -4311,30 +6083,65 @@ var PaperMesh = forwardRef(function PaperMesh2(props, ref) {
       autoSegments: want,
       animatedStack: animated
     };
-  }, [behaviorKey, deformersKey, physicsKey]);
+  }, [behaviorKey, deformersKey, physicsKey, memoryKey]);
   const geometry = useMemo3(() => {
+    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);
+    }
     if (!isCloth) return createSheetGeometry(config.sheet, minSegments, autoSegments);
-    const [sx, sy] = resolveSegments(config.sheet, 2);
+    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);
-  }, [sheetKey, minSegments, autoSegments, isCloth]);
+  }, [
+    sheetKey,
+    minSegments,
+    autoSegments,
+    isCloth,
+    isStrip,
+    isStrip ? config.physics.perforation : 0
+  ]);
   useEffect5(() => () => geometry.dispose(), [geometry]);
   const basePositions = useMemo3(
     () => Float32Array.from(geometry.attributes.position.array),
     [geometry]
   );
+  const stripSim = useMemo3(() => {
+    if (!isStrip) return null;
+    const strip = configRef.current.physics;
+    return new StripSim(config.sheet.height, config.sheet.width, {
+      scroll: strip.scroll,
+      tightness: strip.tightness,
+      core: strip.core,
+      tail: strip.tail,
+      perforation: strip.perforation,
+      crease: strip.crease,
+      stiffness: strip.stiffness,
+      drag: strip.drag,
+      gravity: strip.gravity,
+      floor: strip.floor,
+      inertia: strip.inertia
+    });
+  }, [geometry, isStrip]);
+  const lastSimRef = useRef3(null);
   const sim = useMemo3(() => {
     if (!isCloth) return null;
     const cloth = configRef.current.physics;
     const cols = geometry.parameters.widthSegments + 1;
     const rows = geometry.parameters.heightSegments + 1;
-    return new ClothSim(cols, rows, config.sheet.width, config.sheet.height, cloth.pins, {
+    const next = new ClothSim(cols, rows, config.sheet.width, config.sheet.height, cloth.pins, {
       stiffness: cloth.stiffness,
       gravity: cloth.gravity,
       wind: cloth.wind,
       floor: cloth.floor
     });
+    next.adopt(lastSimRef.current);
+    return next;
   }, [geometry, isCloth, isCloth ? config.physics.pins : ""]);
+  useEffect5(() => {
+    lastSimRef.current = sim;
+  }, [sim]);
   const stock = getStock(config.stock);
   const texture = useContentTexture(config.content, config.sheet, stock);
   const backTexture = useContentTexture(config.content.back, config.sheet, stock);
@@ -4429,6 +6236,10 @@ var PaperMesh = forwardRef(function PaperMesh2(props, ref) {
     placeProgrammatic: () => machineRef.current?.placeProgrammatic() ?? false,
     returnProgrammatic: () => machineRef.current?.returnProgrammatic() ?? false
   }));
+  const shadedCreases = useMemo3(
+    () => 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) => {
     const cfg = liveConfig();
@@ -4441,10 +6252,10 @@ var PaperMesh = forwardRef(function PaperMesh2(props, ref) {
       idle?.transform?.(now, pose);
       if (hasBehaviorTransform) {
         const o = effectiveOptions(now);
-        if (o) behavior.transform(o, now, pose);
+        if (o) behavior.transform(o, now, pose, cfg.sheet);
       }
       const base = props.position ?? [0, 0, 0];
-      const baseRot = props.rotation ?? [0, 0, 0];
+      const baseRot = baseRotation;
       groupRef.current.position.set(
         base[0] + pose.position[0],
         base[1] + pose.position[1],
@@ -4456,6 +6267,56 @@ var PaperMesh = forwardRef(function PaperMesh2(props, ref) {
         baseRot[2] + pose.rotation[2]
       );
     }
+    if (isStrip && stripSim) {
+      const strip = cfg.physics;
+      stripSim.setParams({
+        scroll: strip.scroll,
+        tightness: strip.tightness,
+        core: strip.core,
+        tail: strip.tail,
+        crease: strip.crease,
+        stiffness: strip.stiffness,
+        drag: strip.drag,
+        gravity: strip.gravity,
+        floor: strip.floor,
+        inertia: strip.inertia
+      });
+      stripSim.step(delta);
+      if (!stripSim.asleep) {
+        const position = geometry.attributes.position;
+        stripSim.writeInto(position.array);
+        position.needsUpdate = true;
+        computeSheetNormals(geometry);
+        geometry.computeBoundingSphere();
+      }
+      return;
+    }
+    const applyShape = (base, force) => {
+      const animated = !reduced && animatedStack;
+      const hasLoop = !reduced && Boolean(cfg.behavior && behavior?.loop);
+      const machineAnimating = Boolean(machineRef.current?.transitioning);
+      if (!force && !dirtyRef.current && !hasLoop && !animated && !machineAnimating) return false;
+      const raw = buildStack(cfg, overridesRef.current, behavior, now);
+      const setAmount = cfg.memory.set ?? stock.takesSet;
+      if (raw && creases.observe(raw, setAmount)) props.onCrease?.(creases.creases);
+      const stack = withMemory(raw, cfg, creases.creases);
+      if (!stack) return false;
+      dirtyRef.current = false;
+      const ctx = { t: now, sheet: cfg.sheet };
+      applyDeformerStack(geometry, base, stack, ctx);
+      if (props.interactive && behavior?.handles) {
+        const o = effectiveOptions(now);
+        behavior.handles.forEach((h, i) => {
+          const mesh = handleRefs.current[i];
+          if (!mesh || !o) return;
+          const [u, v] = h.anchor(o, cfg.sheet);
+          anchorScratch.set((u - 0.5) * cfg.sheet.width, (v - 0.5) * cfg.sheet.height, 0);
+          displacePoint(anchorScratch, u, v, stack, ctx);
+          mesh.position.copy(anchorScratch);
+        });
+      }
+      return true;
+    };
     if (isCloth && sim) {
       const cloth = cfg.physics;
       sim.setParams({
@@ -4465,7 +6326,8 @@ var PaperMesh = forwardRef(function PaperMesh2(props, ref) {
         floor: cloth.floor
       });
       sim.step(delta);
-      if (!sim.asleep) {
+      const moved = !sim.asleep;
+      if (!applyShape(sim.positions, moved) && moved) {
         const position = geometry.attributes.position;
         position.array.set(sim.positions);
         position.needsUpdate = true;
@@ -4473,26 +6335,7 @@ var PaperMesh = forwardRef(function PaperMesh2(props, ref) {
       }
       return;
     }
-    const animated = !reduced && animatedStack;
-    const hasLoop = !reduced && Boolean(cfg.behavior && behavior?.loop);
-    const machineAnimating = Boolean(machineRef.current?.transitioning);
-    if (!dirtyRef.current && !hasLoop && !animated && !machineAnimating) return;
-    const stack = buildStack(cfg, overridesRef.current, behavior, now);
-    if (!stack) return;
-    dirtyRef.current = false;
-    const ctx = { t: now, sheet: cfg.sheet };
-    applyDeformerStack(geometry, basePositions, stack, ctx);
-    if (props.interactive && behavior?.handles) {
-      const o = effectiveOptions(now);
-      behavior.handles.forEach((h, i) => {
-        const mesh = handleRefs.current[i];
-        if (!mesh || !o) return;
-        const [u, v] = h.anchor(o, cfg.sheet);
-        anchorScratch.set((u - 0.5) * cfg.sheet.width, (v - 0.5) * cfg.sheet.height, 0);
-        displacePoint(anchorScratch, u, v, stack, ctx);
-        mesh.position.copy(anchorScratch);
-      });
-    }
+    applyShape(basePositions, false);
   });
   const localDragPoint = (e) => {
     const group = groupRef.current;
@@ -4516,13 +6359,22 @@ var PaperMesh = forwardRef(function PaperMesh2(props, ref) {
     if (typeof p === "number") props.onProgress?.(p);
   };
   const grabAnchor = useRef3(new THREE7.Vector3());
+  const grabOffset = useRef3(new THREE7.Vector3());
   const clothDown = (e) => {
     if (!isCloth || !sim || !props.interactive || !groupRef.current) return;
     e.stopPropagation();
     if (controls) controls.enabled = false;
     grabAnchor.current.copy(e.point);
     const local = groupRef.current.worldToLocal(worldScratch.copy(e.point));
-    sim.grabNearest(local.x, local.y, local.z);
+    const drawn = geometry.attributes.position.array;
+    const index = nearestVertex(drawn, sim.count, local.x, local.y, local.z);
+    sim.grab(index);
+    const i3 = index * 3;
+    grabOffset.current.set(
+      drawn[i3] - sim.positions[i3],
+      drawn[i3 + 1] - sim.positions[i3 + 1],
+      drawn[i3 + 2] - sim.positions[i3 + 2]
+    );
     draggingRef.current = "cloth";
     e.target.setPointerCapture(e.pointerId);
   };
@@ -4533,7 +6385,8 @@ var PaperMesh = forwardRef(function PaperMesh2(props, ref) {
     const hit = e.ray.intersectPlane(dragPlane, dragPoint);
     if (!hit) return;
     groupRef.current.worldToLocal(hit);
-    sim.moveGrab(hit.x, hit.y, hit.z);
+    const offset = grabOffset.current;
+    sim.moveGrab(hit.x - offset.x, hit.y - offset.y, hit.z - offset.z);
   };
   const clothUp = (e) => {
     if (draggingRef.current !== "cloth" || !sim) return;
@@ -4542,8 +6395,34 @@ var PaperMesh = forwardRef(function PaperMesh2(props, ref) {
     sim.release();
     e.target.releasePointerCapture(e.pointerId);
   };
+  const stripDown = (e) => {
+    if (!isStrip || !stripSim || !props.interactive || !groupRef.current) return;
+    e.stopPropagation();
+    const local = groupRef.current.worldToLocal(worldScratch.copy(e.point));
+    if (stripSim.grabNearest(local.y, local.z) < 0) return;
+    if (controls) controls.enabled = false;
+    grabAnchor.current.copy(e.point);
+    draggingRef.current = "strip";
+    e.target.setPointerCapture(e.pointerId);
+  };
+  const stripMove = (e) => {
+    if (draggingRef.current !== "strip" || !stripSim || !groupRef.current) return;
+    camera.getWorldDirection(planeNormal);
+    dragPlane.setFromNormalAndCoplanarPoint(planeNormal, grabAnchor.current);
+    const hit = e.ray.intersectPlane(dragPlane, dragPoint);
+    if (!hit) return;
+    groupRef.current.worldToLocal(hit);
+    stripSim.moveGrab(hit.y, hit.z);
+  };
+  const stripUp = (e) => {
+    if (draggingRef.current !== "strip" || !stripSim) return;
+    draggingRef.current = null;
+    if (controls) controls.enabled = true;
+    stripSim.release();
+    e.target.releasePointerCapture(e.pointerId);
+  };
   const sendState = (event) => machineRef.current?.send(event);
-  return /* @__PURE__ */ jsxs("group", { ref: groupRef, position: props.position, rotation: props.rotation, children: [
+  return /* @__PURE__ */ jsxs("group", { ref: groupRef, position: props.position, rotation: baseRotation, children: [
     /* @__PURE__ */ jsx4(
       "mesh",
       {
@@ -4554,13 +6433,15 @@ var PaperMesh = forwardRef(function PaperMesh2(props, ref) {
         frustumCulled: false,
         onPointerOver: statesLive ? () => sendState("enter") : void 0,
         onPointerOut: statesLive ? () => sendState("leave") : void 0,
-        onPointerDown: isCloth || statesLive ? (e) => {
+        onPointerDown: isCloth || isStrip || statesLive ? (e) => {
           if (isCloth) clothDown(e);
+          if (isStrip) stripDown(e);
           if (statesLive) sendState("down");
         } : void 0,
-        onPointerMove: isCloth ? clothMove : void 0,
-        onPointerUp: isCloth || statesLive ? (e) => {
+        onPointerMove: isCloth ? clothMove : isStrip ? stripMove : void 0,
+        onPointerUp: isCloth || isStrip || statesLive ? (e) => {
           if (isCloth) clothUp(e);
+          if (isStrip) stripUp(e);
           if (statesLive) sendState("up");
         } : void 0,
         children: /* @__PURE__ */ jsx4(
@@ -4572,12 +6453,17 @@ var PaperMesh = forwardRef(function PaperMesh2(props, ref) {
             surface: config.surface,
             thickness: config.sheet.thickness,
             sheet: config.sheet,
-            lighting: config.scene.lighting
+            lighting: config.scene.lighting,
+            creases: shadedCreases
           }
         )
       }
     ),
-    props.interactive && !isCloth && behavior?.handles?.map((h, i) => /* @__PURE__ */ jsxs(
+    props.interactive && // Any simulation, not cloth alone: a sim owns the vertices, so there
+    // 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(
       "mesh",
       {
         userData: { paperlabChrome: true },
@@ -4608,8 +6494,32 @@ var PaperMesh = forwardRef(function PaperMesh2(props, ref) {
     ))
   ] });
 });
+function withMemory(stack, config, creases = config.memory.creases) {
+  if (isStripConfig(config.physics)) return null;
+  const out = applyMemory(stack ?? [], creases);
+  return out.length > 0 ? out : null;
+}
+function nearestVertex(array, count, x, y, z25) {
+  let best = -1;
+  let bestDist = Infinity;
+  for (let i = 0; i < count; i++) {
+    const i3 = i * 3;
+    const dx = array[i3] - x;
+    const dy = array[i3 + 1] - y;
+    const dz = array[i3 + 2] - z25;
+    const d = dx * dx + dy * dy + dz * dz;
+    if (d < bestDist) {
+      bestDist = d;
+      best = i;
+    }
+  }
+  return best;
+}
+function isStripConfig(physics) {
+  return typeof physics === "object" && physics.type === "strip";
+}
 function buildStack(config, overrides, behavior, t = 0) {
-  if (typeof config.physics === "object") return null;
+  if (isStripConfig(config.physics)) return null;
   const idle = typeof config.physics === "string" && config.physics !== "none" ? getIdlePreset(config.physics) : null;
   const idleStack = idle?.stack?.() ?? [];
   let shapeStack = [];
@@ -5264,7 +7174,7 @@ function getWalkPath(options) {
 // src/field/layouts/index.ts
 import { z as z24 } from "zod";
 var DEFAULT_SHEET = { width: 1, height: 1.4 };
-var TAU3 = Math.PI * 2;
+var TAU4 = Math.PI * 2;
 var DEG7 = Math.PI / 180;
 function jitter2(seed, i) {
   let h = Math.imul(seed * 1e3 + i + 1 ^ 2654435769, 2654435761);
@@ -5284,7 +7194,7 @@ var ring = {
   defaults: ringSchema.parse({}),
   optionsSchema: ringSchema,
   pose(i, n, o, phase) {
-    const theta = (i / n + phase) * TAU3;
+    const theta = (i / n + phase) * TAU4;
     return {
       position: [Math.sin(theta) * o.radius, 0, Math.cos(theta) * o.radius],
       // Face radially OUTWARD so the papers nearest the camera show their
@@ -5445,7 +7355,7 @@ var sweepSchema = z24.object({
   from: z24.number().min(0).max(1).default(0),
   to: z24.number().min(0).max(1).default(1)
 });
-var sweep = {
+var sweep2 = {
   id: "sweep",
   label: "Sweep",
   defaults: sweepSchema.parse({}),
@@ -5560,7 +7470,7 @@ var rack = {
 };
 var colonnadeSchema = z24.object({
   /** The walk the colonnade is built along — see `stage/path`. */
-  path: walkPathSchema.default({}),
+  path: walkPathSchema.prefault({}),
   /** Half-width of the clear aisle: how far each banner stands off the walk line. */
   aisle: z24.number().min(0.2).max(20).default(2.4),
   /** How much that gap opens and closes along the walk. Nothing hung by hand is a corridor. */
@@ -5654,7 +7564,7 @@ registerLayout(spread);
 registerLayout(pile);
 registerLayout(wall);
 registerLayout(spill);
-registerLayout(sweep);
+registerLayout(sweep2);
 registerLayout(book);
 registerLayout(accordion);
 registerLayout(rack);
@@ -6116,7 +8026,8 @@ function FieldGroup({
         behaviorTransform.transform(
           { ...config.behavior, [behaviorTransform.progressParam]: progressRef.current },
           t,
-          pose2
+          pose2,
+          shared.sheet
         );
         scratchObj.position.x += pose2.position[0];
         scratchObj.position.y += pose2.position[1];
@@ -7021,6 +8932,8 @@ function diffConfig(config) {
   }
   if (config.deformers) out.deformers = config.deformers;
   if (Object.keys(config.surface).length > 0) out.surface = config.surface;
+  const memory = diffAgainst(config.memory, memorySchema.parse({}));
+  if (Object.keys(memory).length > 0) out.memory = memory;
   if (typeof config.physics === "object") {
     const defaults = clothConfigSchema.parse({ type: "cloth" });
     out.physics = { type: "cloth", ...diffAgainst(config.physics, defaults) };
@@ -7095,8 +9008,9 @@ function describeConfig(config) {
   if (config.content.type === "receipt") contentPhrase = `a store receipt for "${config.content.store}"`;
   const parts = [`${contentPhrase} on ${stock.label.toLowerCase()} paper stock (${size})`];
   if (typeof config.physics === "object") {
+    const sim = config.physics;
     parts.push(
-      config.physics.pins === "none" ? "falling and settling as cloth" : `pinned (${config.physics.pins}) and moving like cloth in wind`
+      sim.type === "strip" ? "paying off a roll as the page scrolls, folding at its perforations into a pile on the floor" : sim.pins === "none" ? "falling and settling as cloth" : `pinned (${sim.pins}) and moving like cloth in wind`
     );
   } else if (config.behavior) {
     const phrase = BEHAVIOR_PHRASES[config.behavior.type];
@@ -7167,9 +9081,12 @@ export {
   contentNames,
   contentSchemaFor,
   paperEdges,
+  creaseSchema,
+  memorySchema,
   behaviorConfigSchema,
   physicsNames,
   clothConfigSchema,
+  stripConfigSchema,
   lightingNames,
   lightSchema,
   backdropSchema,
@@ -7193,10 +9110,15 @@ export {
   getDeformer,
   listDeformers,
   displacePoint,
+  MAX_SET,
+  MAX_CREASES,
+  applyMemory,
+  CreaseTracker,
   registerBehavior,
   getBehavior,
   listBehaviors,
   idleNames,
+  maxStripLength,
   lightAngles,
   resolveLighting,
   LightRig,
@@ -7231,4 +9153,4 @@ export {
   describeConfig,
   buildAgentPayload
 };
-//# sourceMappingURL=chunk-HRXQTJFS.js.map
+//# sourceMappingURL=chunk-E22ILEDO.js.map