paperlab 0.0.1 → 0.2.0

package/dist/index.d.ts

@@ -6,6 +6,14 @@ import { z } from 'zod';
  * The zod schema is the single source of truth: it validates the public API,
  * generates editor panels, defines the `.paper` preset format, and feeds the docs.
  * If a feature can't serialize into this schema, it waits.
+ *
+ * Every schema here exports BOTH of its types, and the difference is
+ * load-bearing. `z.infer` is the parsed config — every default filled in,
+ * every field present — and it is what the renderer reads. `z.input` is what
+ * a caller is allowed to write, where anything with a default is optional,
+ * and it is what every public prop must take. Handing a component the
+ * inferred type instead demands that the caller supply every field of every
+ * nested object, which turns the documented one-liner into a type error.
  */
 declare const sheetSchema: z.ZodObject<{
     /** World units. A letter sheet is ~1 × 1.4, a receipt ~1 × 2.6. */
@@ -13,7 +21,12 @@ declare const sheetSchema: z.ZodObject<{
     height: z.ZodDefault<z.ZodNumber>;
     /** Visual thickness in mm-ish units; drives edge/shadow treatment, not geometry (yet). */
     thickness: z.ZodDefault<z.ZodNumber>;
-    /** 'auto' sizes the grid from the active deformers' needs. */
+    /**
+     * `'auto'` gives the LONG side 72 segments, whatever is on the sheet — a
+     * deformer's `minSegments` can only raise that floor, never lower it, so in
+     * practice a blank sheet is tessellated exactly as finely as a crumpled
+     * one. Set a number to take the decision yourself.
+     */
     segments: z.ZodDefault<z.ZodUnion<[z.ZodLiteral<"auto">, z.ZodNumber]>>;
     cornerRadius: z.ZodDefault<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
@@ -1071,6 +1084,8 @@ declare const contentSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
     } | undefined;
 }>]>;
 type ContentConfig = z.infer<typeof contentSchema>;
+/** What a caller may WRITE — defaults still unfilled. This is the prop type. */
+type ContentConfigInput = z.input<typeof contentSchema>;
 declare const paperEdges: readonly ["top", "right", "bottom", "left"];
 /**
  * Fragment-side effects, composed in registration order into one shader
@@ -1080,6 +1095,8 @@ declare const paperEdges: readonly ["top", "right", "bottom", "left"];
 declare const surfaceSchema: z.ZodObject<{
     /** Paper fiber noise, 0..1. */
     grain: z.ZodOptional<z.ZodNumber>;
+    /** Light passing through the sheet from behind, 0..1. Stock defaults apply. */
+    translucency: z.ZodOptional<z.ZodNumber>;
     /** Torn-edge alpha with a lightened fiber band. */
     deckle: z.ZodOptional<z.ZodObject<{
         edges: z.ZodDefault<z.ZodArray<z.ZodEnum<["top", "right", "bottom", "left"]>, "many">>;
@@ -1099,13 +1116,13 @@ declare const surfaceSchema: z.ZodObject<{
         positions: z.ZodDefault<z.ZodArray<z.ZodNumber, "many">>;
         strength: z.ZodDefault<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
+        strength: number;
         angle: number;
         positions: number[];
-        strength: number;
     }, {
+        strength?: number | undefined;
         angle?: number | undefined;
         positions?: number[] | undefined;
-        strength?: number | undefined;
     }>>;
     /** Yellowing + foxing spots, 0..1. */
     aging: z.ZodOptional<z.ZodNumber>;
@@ -1160,14 +1177,15 @@ declare const surfaceSchema: z.ZodObject<{
     }>>;
 }, "strip", z.ZodTypeAny, {
     grain?: number | undefined;
+    translucency?: number | undefined;
     deckle?: {
         edges: ("left" | "right" | "top" | "bottom")[];
         roughness: number;
     } | undefined;
     creaseLines?: {
+        strength: number;
         angle: number;
         positions: number[];
-        strength: number;
     } | undefined;
     aging?: number | undefined;
     showThrough?: number | undefined;
@@ -1184,14 +1202,15 @@ declare const surfaceSchema: z.ZodObject<{
     } | undefined;
 }, {
     grain?: number | undefined;
+    translucency?: number | undefined;
     deckle?: {
         edges?: ("left" | "right" | "top" | "bottom")[] | undefined;
         roughness?: number | undefined;
     } | undefined;
     creaseLines?: {
+        strength?: number | undefined;
         angle?: number | undefined;
         positions?: number[] | undefined;
-        strength?: number | undefined;
     } | undefined;
     aging?: number | undefined;
     showThrough?: number | undefined;
@@ -1208,6 +1227,7 @@ declare const surfaceSchema: z.ZodObject<{
     } | undefined;
 }>;
 type SurfaceConfig = z.infer<typeof surfaceSchema>;
+type SurfaceConfigInput = z.input<typeof surfaceSchema>;
 type PaperEdge = (typeof paperEdges)[number];
 declare const behaviorConfigSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
     progress: z.ZodDefault<z.ZodNumber>;
@@ -1356,8 +1376,28 @@ declare const behaviorConfigSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject
     tumble?: number | undefined;
     respawn?: boolean | undefined;
     range?: number | undefined;
+}>, z.ZodObject<{
+    progress: z.ZodDefault<z.ZodNumber>;
+    coarseness: z.ZodDefault<z.ZodNumber>;
+    ball: z.ZodDefault<z.ZodNumber>;
+    seed: z.ZodDefault<z.ZodNumber>;
+} & {
+    type: z.ZodLiteral<"crumple">;
+}, "strip", z.ZodTypeAny, {
+    type: "crumple";
+    progress: number;
+    coarseness: number;
+    ball: number;
+    seed: number;
+}, {
+    type: "crumple";
+    progress?: number | undefined;
+    coarseness?: number | undefined;
+    ball?: number | undefined;
+    seed?: number | undefined;
 }>]>;
 type BehaviorConfig = z.infer<typeof behaviorConfigSchema>;
+type BehaviorConfigInput = z.input<typeof behaviorConfigSchema>;
 /** Advanced escape hatch: a raw deformer stack (editing one forks the behavior). */
 declare const deformerInstanceSchema: z.ZodObject<{
     type: z.ZodString;
@@ -1373,6 +1413,7 @@ declare const deformerInstanceSchema: z.ZodObject<{
     enabled?: boolean | undefined;
 }>;
 type DeformerInstanceConfig = z.infer<typeof deformerInstanceSchema>;
+type DeformerInstanceConfigInput = z.input<typeof deformerInstanceSchema>;
 /** Kept in sync with `idleNames` in physics/idle.ts (asserted by test). */
 declare const physicsNames: readonly ["none", "float", "tumble", "dangle", "taped", "breeze"];
 declare const clothConfigSchema: z.ZodObject<{
@@ -1432,16 +1473,18 @@ declare const physicsSchema: z.ZodUnion<[z.ZodEnum<["none", "float", "tumble", "
     floor?: number | undefined;
 }>]>;
 type PhysicsConfig = z.infer<typeof physicsSchema>;
-declare const lightingNames: readonly ["studio", "window", "leaves", "goldenhour", "noir"];
+type PhysicsConfigInput = z.input<typeof physicsSchema>;
+declare const lightingNames: readonly ["studio", "window", "leaves", "goldenhour", "noir", "nave"];
 /** Scene-level presentation, serialized with the paper. */
 declare const sceneSchema: z.ZodObject<{
-    lighting: z.ZodDefault<z.ZodEnum<["studio", "window", "leaves", "goldenhour", "noir"]>>;
+    lighting: z.ZodDefault<z.ZodEnum<["studio", "window", "leaves", "goldenhour", "noir", "nave"]>>;
 }, "strip", z.ZodTypeAny, {
-    lighting: "studio" | "window" | "leaves" | "goldenhour" | "noir";
+    lighting: "studio" | "window" | "leaves" | "goldenhour" | "noir" | "nave";
 }, {
-    lighting?: "studio" | "window" | "leaves" | "goldenhour" | "noir" | undefined;
+    lighting?: "studio" | "window" | "leaves" | "goldenhour" | "noir" | "nave" | undefined;
 }>;
 type SceneConfig = z.infer<typeof sceneSchema>;
+type SceneConfigInput = z.input<typeof sceneSchema>;
 type LightingName = (typeof lightingNames)[number];
 /**
  * A state is a set of parameter overrides on the base preset — never a
@@ -1595,7 +1638,12 @@ declare const paperConfigSchema: z.ZodEffects<z.ZodObject<{
         height: z.ZodDefault<z.ZodNumber>;
         /** Visual thickness in mm-ish units; drives edge/shadow treatment, not geometry (yet). */
         thickness: z.ZodDefault<z.ZodNumber>;
-        /** 'auto' sizes the grid from the active deformers' needs. */
+        /**
+         * `'auto'` gives the LONG side 72 segments, whatever is on the sheet — a
+         * deformer's `minSegments` can only raise that floor, never lower it, so in
+         * practice a blank sheet is tessellated exactly as finely as a crumpled
+         * one. Set a number to take the decision yourself.
+         */
         segments: z.ZodDefault<z.ZodUnion<[z.ZodLiteral<"auto">, z.ZodNumber]>>;
         cornerRadius: z.ZodDefault<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
@@ -2494,6 +2542,25 @@ declare const paperConfigSchema: z.ZodEffects<z.ZodObject<{
         tumble?: number | undefined;
         respawn?: boolean | undefined;
         range?: number | undefined;
+    }>, z.ZodObject<{
+        progress: z.ZodDefault<z.ZodNumber>;
+        coarseness: z.ZodDefault<z.ZodNumber>;
+        ball: z.ZodDefault<z.ZodNumber>;
+        seed: z.ZodDefault<z.ZodNumber>;
+    } & {
+        type: z.ZodLiteral<"crumple">;
+    }, "strip", z.ZodTypeAny, {
+        type: "crumple";
+        progress: number;
+        coarseness: number;
+        ball: number;
+        seed: number;
+    }, {
+        type: "crumple";
+        progress?: number | undefined;
+        coarseness?: number | undefined;
+        ball?: number | undefined;
+        seed?: number | undefined;
     }>]>>;
     deformers: z.ZodOptional<z.ZodArray<z.ZodObject<{
         type: z.ZodString;
@@ -2511,6 +2578,8 @@ declare const paperConfigSchema: z.ZodEffects<z.ZodObject<{
     surface: z.ZodDefault<z.ZodObject<{
         /** Paper fiber noise, 0..1. */
         grain: z.ZodOptional<z.ZodNumber>;
+        /** Light passing through the sheet from behind, 0..1. Stock defaults apply. */
+        translucency: z.ZodOptional<z.ZodNumber>;
         /** Torn-edge alpha with a lightened fiber band. */
         deckle: z.ZodOptional<z.ZodObject<{
             edges: z.ZodDefault<z.ZodArray<z.ZodEnum<["top", "right", "bottom", "left"]>, "many">>;
@@ -2530,13 +2599,13 @@ declare const paperConfigSchema: z.ZodEffects<z.ZodObject<{
             positions: z.ZodDefault<z.ZodArray<z.ZodNumber, "many">>;
             strength: z.ZodDefault<z.ZodNumber>;
         }, "strip", z.ZodTypeAny, {
+            strength: number;
             angle: number;
             positions: number[];
-            strength: number;
         }, {
+            strength?: number | undefined;
             angle?: number | undefined;
             positions?: number[] | undefined;
-            strength?: number | undefined;
         }>>;
         /** Yellowing + foxing spots, 0..1. */
         aging: z.ZodOptional<z.ZodNumber>;
@@ -2591,14 +2660,15 @@ declare const paperConfigSchema: z.ZodEffects<z.ZodObject<{
         }>>;
     }, "strip", z.ZodTypeAny, {
         grain?: number | undefined;
+        translucency?: number | undefined;
         deckle?: {
             edges: ("left" | "right" | "top" | "bottom")[];
             roughness: number;
         } | undefined;
         creaseLines?: {
+            strength: number;
             angle: number;
             positions: number[];
-            strength: number;
         } | undefined;
         aging?: number | undefined;
         showThrough?: number | undefined;
@@ -2615,14 +2685,15 @@ declare const paperConfigSchema: z.ZodEffects<z.ZodObject<{
         } | undefined;
     }, {
         grain?: number | undefined;
+        translucency?: number | undefined;
         deckle?: {
             edges?: ("left" | "right" | "top" | "bottom")[] | undefined;
             roughness?: number | undefined;
         } | undefined;
         creaseLines?: {
+            strength?: number | undefined;
             angle?: number | undefined;
             positions?: number[] | undefined;
-            strength?: number | undefined;
         } | undefined;
         aging?: number | undefined;
         showThrough?: number | undefined;
@@ -2670,11 +2741,11 @@ declare const paperConfigSchema: z.ZodEffects<z.ZodObject<{
         floor?: number | undefined;
     }>]>>;
     scene: z.ZodDefault<z.ZodObject<{
-        lighting: z.ZodDefault<z.ZodEnum<["studio", "window", "leaves", "goldenhour", "noir"]>>;
+        lighting: z.ZodDefault<z.ZodEnum<["studio", "window", "leaves", "goldenhour", "noir", "nave"]>>;
     }, "strip", z.ZodTypeAny, {
-        lighting: "studio" | "window" | "leaves" | "goldenhour" | "noir";
+        lighting: "studio" | "window" | "leaves" | "goldenhour" | "noir" | "nave";
     }, {
-        lighting?: "studio" | "window" | "leaves" | "goldenhour" | "noir" | undefined;
+        lighting?: "studio" | "window" | "leaves" | "goldenhour" | "noir" | "nave" | undefined;
     }>>;
     onTwos: z.ZodDefault<z.ZodBoolean>;
     /** Interaction state machine — overrides-on-base diffs (spec M6 §1). */
@@ -2918,14 +2989,15 @@ declare const paperConfigSchema: z.ZodEffects<z.ZodObject<{
     };
     surface: {
         grain?: number | undefined;
+        translucency?: number | undefined;
         deckle?: {
             edges: ("left" | "right" | "top" | "bottom")[];
             roughness: number;
         } | undefined;
         creaseLines?: {
+            strength: number;
             angle: number;
             positions: number[];
-            strength: number;
         } | undefined;
         aging?: number | undefined;
         showThrough?: number | undefined;
@@ -2950,7 +3022,7 @@ declare const paperConfigSchema: z.ZodEffects<z.ZodObject<{
         floor: number;
     };
     scene: {
-        lighting: "studio" | "window" | "leaves" | "goldenhour" | "noir";
+        lighting: "studio" | "window" | "leaves" | "goldenhour" | "noir" | "nave";
     };
     onTwos: boolean;
     states?: {
@@ -3011,6 +3083,12 @@ declare const paperConfigSchema: z.ZodEffects<z.ZodObject<{
         tumble: number;
         respawn: boolean;
         range: number;
+    } | {
+        type: "crumple";
+        progress: number;
+        coarseness: number;
+        ball: number;
+        seed: number;
     } | undefined;
     deformers?: {
         type: string;
@@ -3240,6 +3318,12 @@ declare const paperConfigSchema: z.ZodEffects<z.ZodObject<{
         tumble?: number | undefined;
         respawn?: boolean | undefined;
         range?: number | undefined;
+    } | {
+        type: "crumple";
+        progress?: number | undefined;
+        coarseness?: number | undefined;
+        ball?: number | undefined;
+        seed?: number | undefined;
     } | undefined;
     deformers?: {
         type: string;
@@ -3248,14 +3332,15 @@ declare const paperConfigSchema: z.ZodEffects<z.ZodObject<{
     }[] | undefined;
     surface?: {
         grain?: number | undefined;
+        translucency?: number | undefined;
         deckle?: {
             edges?: ("left" | "right" | "top" | "bottom")[] | undefined;
             roughness?: number | undefined;
         } | undefined;
         creaseLines?: {
+            strength?: number | undefined;
             angle?: number | undefined;
             positions?: number[] | undefined;
-            strength?: number | undefined;
         } | undefined;
         aging?: number | undefined;
         showThrough?: number | undefined;
@@ -3280,7 +3365,7 @@ declare const paperConfigSchema: z.ZodEffects<z.ZodObject<{
         floor?: number | undefined;
     } | undefined;
     scene?: {
-        lighting?: "studio" | "window" | "leaves" | "goldenhour" | "noir" | undefined;
+        lighting?: "studio" | "window" | "leaves" | "goldenhour" | "noir" | "nave" | undefined;
     } | undefined;
     onTwos?: boolean | undefined;
 }>, {
@@ -3450,14 +3535,15 @@ declare const paperConfigSchema: z.ZodEffects<z.ZodObject<{
     };
     surface: {
         grain?: number | undefined;
+        translucency?: number | undefined;
         deckle?: {
             edges: ("left" | "right" | "top" | "bottom")[];
             roughness: number;
         } | undefined;
         creaseLines?: {
+            strength: number;
             angle: number;
             positions: number[];
-            strength: number;
         } | undefined;
         aging?: number | undefined;
         showThrough?: number | undefined;
@@ -3482,7 +3568,7 @@ declare const paperConfigSchema: z.ZodEffects<z.ZodObject<{
         floor: number;
     };
     scene: {
-        lighting: "studio" | "window" | "leaves" | "goldenhour" | "noir";
+        lighting: "studio" | "window" | "leaves" | "goldenhour" | "noir" | "nave";
     };
     onTwos: boolean;
     states?: {
@@ -3543,6 +3629,12 @@ declare const paperConfigSchema: z.ZodEffects<z.ZodObject<{
         tumble: number;
         respawn: boolean;
         range: number;
+    } | {
+        type: "crumple";
+        progress: number;
+        coarseness: number;
+        ball: number;
+        seed: number;
     } | undefined;
     deformers?: {
         type: string;
@@ -3772,6 +3864,12 @@ declare const paperConfigSchema: z.ZodEffects<z.ZodObject<{
         tumble?: number | undefined;
         respawn?: boolean | undefined;
         range?: number | undefined;
+    } | {
+        type: "crumple";
+        progress?: number | undefined;
+        coarseness?: number | undefined;
+        ball?: number | undefined;
+        seed?: number | undefined;
     } | undefined;
     deformers?: {
         type: string;
@@ -3780,14 +3878,15 @@ declare const paperConfigSchema: z.ZodEffects<z.ZodObject<{
     }[] | undefined;
     surface?: {
         grain?: number | undefined;
+        translucency?: number | undefined;
         deckle?: {
             edges?: ("left" | "right" | "top" | "bottom")[] | undefined;
             roughness?: number | undefined;
         } | undefined;
         creaseLines?: {
+            strength?: number | undefined;
             angle?: number | undefined;
             positions?: number[] | undefined;
-            strength?: number | undefined;
         } | undefined;
         aging?: number | undefined;
         showThrough?: number | undefined;
@@ -3812,7 +3911,7 @@ declare const paperConfigSchema: z.ZodEffects<z.ZodObject<{
         floor?: number | undefined;
     } | undefined;
     scene?: {
-        lighting?: "studio" | "window" | "leaves" | "goldenhour" | "noir" | undefined;
+        lighting?: "studio" | "window" | "leaves" | "goldenhour" | "noir" | "nave" | undefined;
     } | undefined;
     onTwos?: boolean | undefined;
 }>;
@@ -3941,10 +4040,20 @@ interface PaperMeshProps {
     preset?: string | PaperConfigInput;
     sheet?: Partial<SheetConfig>;
     stock?: StockName;
-    content?: ContentConfig;
-    behavior?: BehaviorConfig;
-    deformers?: DeformerInstanceConfig[];
-    physics?: PhysicsConfig | 'cloth';
+    /**
+     * These take the schema's INPUT types, not its parsed ones: writing
+     * `content={{ type: 'text', text: 'hi' }}` has to compile, and with the
+     * inferred type it does not — it demands every field of every nested
+     * object. Every default stays a default.
+     */
+    content?: ContentConfigInput;
+    behavior?: BehaviorConfigInput;
+    deformers?: DeformerInstanceConfigInput[];
+    /** Fragment-side effects: grain, aging, deckle, creases, perforation. */
+    surface?: SurfaceConfigInput;
+    /** Scene-level presentation that travels with the paper (lighting). */
+    scene?: SceneConfigInput;
+    physics?: PhysicsConfigInput | 'cloth';
     onTwos?: boolean;
     /** Show draggable behavior handles; cloth sheets become grabbable. */
     interactive?: boolean;
@@ -4093,6 +4202,18 @@ interface SheetDims {
     width: number;
     height: number;
 }
+/**
+ * The options type of a registry entry whose concrete shape is unknowable at
+ * the storage site. The registries are heterogeneous — every behavior,
+ * deformer and layout declares its own options — and this is the only top type
+ * that admits all of them. `unknown` collapses `keyof O & string` (a
+ * behavior's `progressParam`) to `never`, and `Record<string, unknown>` is
+ * rejected in both directions: an entry's own `stack`/`pose` demands its own
+ * keys, and an interface-declared options type has no implicit index
+ * signature. Narrowing this would close the registries to the community
+ * extensions they exist for.
+ */
+type AnyOptions = any;
 interface DeformerContext {
     /** Seconds since the paper mounted. */
     t: number;
@@ -4115,6 +4236,14 @@ interface Deformer<O = Record<string, unknown>> {
     glsl?: {
         chunk: string;
         uniforms(o: O): Record<string, unknown>;
+        /**
+         * The option whose uniform scales with a field instance's per-sheet
+         * `bias` (0 = flat, 1 = exactly as configured), letting one instanced
+         * draw call bend every sheet differently. Deformers whose strength has
+         * no linear form omit this and ignore bias — `roll` is arc-length-exact,
+         * so a "half roll" is a shorter roll, not a scaled one.
+         */
+        strength?: keyof O & string;
     };
     geometry?: {
         minSegments?: number;
@@ -4389,6 +4518,16 @@ interface LightingPreset {
         drift: number;
         angle: number;
     };
+    /**
+     * Distance haze. Depth in a deep space is staged almost entirely by fog —
+     * it is what turns a row of banners into a receding colonnade instead of
+     * a flat row of rectangles.
+     */
+    fog?: {
+        color: string;
+        near: number;
+        far: number;
+    };
 }
 declare const lightingPresets: Record<LightingName, LightingPreset>;
 declare function getLightingPreset(name: LightingName): LightingPreset;
@@ -4406,18 +4545,46 @@ interface PaperLightingProps {
     scale?: number;
     /** Override prefers-reduced-motion (freezes gobo drift). */
     reducedMotion?: boolean;
+    /**
+     * Shadow map resolution, overriding the preset's. 0 turns the shadow pass
+     * off — it re-renders the scene's geometry, so on a weak machine it is
+     * often the single most expensive thing in the frame.
+     */
+    shadowMapSize?: number;
+    /** Draw the soft contact shadow. It is its own render pass. */
+    contactShadow?: boolean;
 }
 /**
  * A scene's lighting rig from one serialized name: key light (spot with a
  * procedural gobo, or directional), ambient fill, tone-mapping exposure,
  * and the contact shadow. Swap presets to restyle the same paper.
  */
-declare function PaperLighting({ preset, floor, scale, reducedMotion, }: PaperLightingProps): react.JSX.Element;
+declare function PaperLighting({ preset, floor, scale, reducedMotion, shadowMapSize, contactShadow, }: PaperLightingProps): react.JSX.Element;
 
 /** Community deformers register here; built-ins are pre-registered. */
-declare function registerDeformer(deformer: Deformer<any>): void;
-declare function getDeformer(id: string): Deformer<any>;
+declare function registerDeformer(deformer: Deformer<AnyOptions>): void;
+declare function getDeformer(id: string): Deformer<AnyOptions>;
 declare function listDeformers(): string[];
+/**
+ * Resolve a raw `deformers` stack — the Advanced fork of a behavior — into
+ * instances safe to render.
+ *
+ * The escape hatch used to pass its options straight through, so a preset
+ * naming an option that doesn't exist (`frequency` where wave wants
+ * `wavelength`) reached the GLSL builder as `undefined` and died there with
+ * a message about `.length`, or reached the CPU path and quietly produced
+ * NaN vertices. Parsing through each deformer's own schema turns that into
+ * the validation error it always was, and fills in defaults for whatever a
+ * hand-written preset left out.
+ *
+ * Disabled entries keep their slot: the GLSL uniform namespace is indexed by
+ * position, so dropping one here would rename every uniform after it.
+ */
+declare function resolveDeformerStack(raw: {
+    type: string;
+    options?: Record<string, unknown>;
+    enabled?: boolean;
+}[]): DeformerInstance[];
 
 /**
  * Run an ordered deformer stack over a sheet geometry: each vertex starts
@@ -4478,6 +4645,11 @@ type BendOptions = z.infer<typeof bendOptionsSchema>;
  * Gentle global arc around a cylinder centered on the sheet — a standing
  * paper's lean. Arc-length preserving, like roll, but symmetric about the
  * center instead of one-sided.
+ *
+ * Written in its cancellation-free form throughout: `r(1 − cos θ)` is
+ * `2r·sin²(θ/2)`, and the in-plane shift goes through `sinMinusX`. Same arc,
+ * same numbers to sixteen places — it is only the float32 half that could
+ * tell the difference, and that is exactly the half the parity gate checks.
  */
 declare const bend: Deformer<BendOptions>;
 
@@ -4540,6 +4712,112 @@ type WaveOptions = z.infer<typeof waveOptionsSchema>;
  */
 declare const wave: Deformer<WaveOptions>;
 
+declare const drapeOptionsSchema: z.ZodObject<{
+    /** Fold depth at the free edge, world units. */
+    amplitude: z.ZodDefault<z.ZodNumber>;
+    /** How many folds run down the drop. */
+    folds: z.ZodDefault<z.ZodNumber>;
+    /**
+     * How fast folds deepen away from the pinned edge. 1 is linear; higher
+     * holds the top flat and gathers all the movement at the free end, which
+     * is what a sheet hung from a rod actually does.
+     */
+    falloff: z.ZodDefault<z.ZodNumber>;
+    /** How much a second, non-harmonic fold breaks the regularity. */
+    irregular: z.ZodDefault<z.ZodNumber>;
+    /** How much the sheet narrows as its folds deepen. */
+    gather: z.ZodDefault<z.ZodNumber>;
+    pinnedEdge: z.ZodDefault<z.ZodEnum<["top", "bottom"]>>;
+}, "strip", z.ZodTypeAny, {
+    amplitude: number;
+    pinnedEdge: "top" | "bottom";
+    folds: number;
+    falloff: number;
+    irregular: number;
+    gather: number;
+}, {
+    amplitude?: number | undefined;
+    pinnedEdge?: "top" | "bottom" | undefined;
+    folds?: number | undefined;
+    falloff?: number | undefined;
+    irregular?: number | undefined;
+    gather?: number | undefined;
+}>;
+type DrapeOptions = z.infer<typeof drapeOptionsSchema>;
+/**
+ * Hung paper: vertical folds running the length of the drop, shallow at the
+ * fixed edge and deepening toward the free one.
+ *
+ * `wave` can put ripples on a sheet, but a traveling sine is a flag, not a
+ * curtain — it kinks the sheet ACROSS its drop and it is uniform end to end.
+ * Cloth hung from an edge does the opposite: the folds run WITH the drop and
+ * they grow as they get further from whatever is holding the sheet up. Two
+ * details do most of the work:
+ *
+ * - the folds are not harmonic. A pure sine reads as corrugated metal, so a
+ *   second wave at an incommensurate frequency breaks the repeat.
+ * - gathered paper is narrower than flat paper. Pulling the surface toward
+ *   its centerline in proportion to fold depth is what stops the drape from
+ *   looking like a texture painted on a rectangle.
+ */
+declare const drape: Deformer<DrapeOptions>;
+
+declare const crumpleOptionsSchema: z.ZodObject<{
+    /** How crushed, 0..1. Peak-to-peak height, and it drives the pull too. */
+    amount: z.ZodDefault<z.ZodNumber>;
+    /** Facets per world unit. Higher is finer, and needs more segments to resolve. */
+    scale: z.ZodDefault<z.ZodNumber>;
+    /**
+     * How much the sheet draws in on itself. Crumpled paper occupies a smaller
+     * footprint than flat paper; without this it reads as an embossed sheet
+     * rather than a crushed one.
+     */
+    pull: z.ZodDefault<z.ZodNumber>;
+    /** A different crush of the same paper. */
+    seed: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    amount: number;
+    seed: number;
+    scale: number;
+    pull: number;
+}, {
+    amount?: number | undefined;
+    seed?: number | undefined;
+    scale?: number | undefined;
+    pull?: number | undefined;
+}>;
+type CrumpleOptions = z.infer<typeof crumpleOptionsSchema>;
+/**
+ * Paper that has been handled.
+ *
+ * Six deformers and not one of them crushed a sheet — `wave` and `fold` were
+ * the nearest and neither reads as crumpled. This is the missing primitive.
+ *
+ * The field is a jittered grid of cells, each pushed up or down, with the
+ * height going to zero exactly on the boundary between them: `F2 − F1`, the
+ * gap between the two nearest cell points, signed per cell. That vanishes on
+ * every boundary, so the sheet stays continuous, and its gradient flips
+ * across one — which is a crease. The result is an irregular polygonal
+ * network of facets alternating toward and away from you, which is what a
+ * sheet crushed in a fist actually is.
+ *
+ * **The normals matter more than the displacement here**, and getting there
+ * took three tries worth recording. Three summed triangle waves: periodic,
+ * an egg-crate. Plain distance-to-nearest (`F1`): irregular but smooth cone
+ * tips, so it read as hammered metal. Only creases with a sign change across
+ * them shade like paper.
+ *
+ * Both normal paths agree with that: the hero path averages vertex normals
+ * over a dense grid, the field path probes two tangents a hundredth of a
+ * sheet apart. Both need facets several segments wide.
+ *
+ * Cost, measured rather than assumed: a field of these runs about 45% longer
+ * per frame than the same field of an undeformed preset, and almost none of
+ * that is geometry — `segments: 'auto'` already gives every sheet 72 a side.
+ * It is the nine cell lookups per probe, three probes deep for the normal.
+ */
+declare const crumple: Deformer<CrumpleOptions>;
+
 /**
  * The shared fake-aerodynamics core (spec M6 §4): velocity-linked lift +
  * curated noise, per v0.2's "reads more real than a true sim" doctrine.
@@ -4584,7 +4862,7 @@ declare function flightPose(t: number, o: FlightParams, phase: number, pose: Aer
 declare function carryDrive(speed: number): number;
 
 /** A draggable 3D grab point; drags write back to behavior params. */
-interface HandleSpec<O = any> {
+interface HandleSpec<O = AnyOptions> {
     id: string;
     /** UV-space (0..1) anchor of the grab point on the flat sheet. */
     anchor(o: O, sheet: SheetDims): [number, number];
@@ -4601,7 +4879,7 @@ interface HandleSpec<O = any> {
  * underneath is an Advanced disclosure. New behaviors are the community
  * on-ramp: ~50 lines over existing deformers.
  */
-interface Behavior<O = any> {
+interface Behavior<O = AnyOptions> {
     id: string;
     label: string;
     defaults: O;
@@ -4626,8 +4904,8 @@ interface Behavior<O = any> {
 }
 
 /** Community behaviors register here; built-ins are pre-registered. */
-declare function registerBehavior(behavior: Behavior<any>): void;
-declare function getBehavior(id: string): Behavior<any>;
+declare function registerBehavior(behavior: Behavior<AnyOptions>): void;
+declare function getBehavior(id: string): Behavior<AnyOptions>;
 declare function listBehaviors(): string[];
 
 declare const peelOptionsSchema: z.ZodObject<{
@@ -4834,6 +5112,37 @@ type FlightOptions = z.infer<typeof flightOptionsSchema>;
  */
 declare const flight: Behavior<FlightOptions>;
 
+declare const crumpleBehaviorOptionsSchema: z.ZodObject<{
+    /** 0 = flat sheet, 1 = crushed. */
+    progress: z.ZodDefault<z.ZodNumber>;
+    /** Few big facets at 0, many small ones at 1. */
+    coarseness: z.ZodDefault<z.ZodNumber>;
+    /** How far the sheet curls in on itself as it crushes. */
+    ball: z.ZodDefault<z.ZodNumber>;
+    /** A different crush of the same paper. */
+    seed: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    progress: number;
+    coarseness: number;
+    ball: number;
+    seed: number;
+}, {
+    progress?: number | undefined;
+    coarseness?: number | undefined;
+    ball?: number | undefined;
+    seed?: number | undefined;
+}>;
+type CrumpleBehaviorOptions = z.infer<typeof crumpleBehaviorOptionsSchema>;
+/**
+ * A sheet being screwed up in a fist.
+ *
+ * Two deformers, in this order for a reason: `crumple` reads the flat sheet
+ * position to place its creases, so it has to run before anything that moves
+ * the sheet around. Crush the paper, then curl the crushed paper — the other
+ * way round would crease a curved sheet as if it were still flat.
+ */
+declare const crumpleBehavior: Behavior<CrumpleBehaviorOptions>;
+
 declare const idleNames: readonly ["float", "tumble", "dangle", "taped", "breeze"];
 type IdleName = (typeof idleNames)[number];
 interface IdlePose {
@@ -4897,18 +5206,34 @@ declare function buildFieldFragmentShader(): string;
  * three.js. `phase` is the motion driver's continuous offset in turns
  * (0..1 = one full cycle); cyclic layouts use it, static ones ignore it.
  * Community layouts are ~30 lines.
+ *
+ * Every built-in names a place paper actually sits — a fanned swatch deck, a
+ * slipped stack, a heap on a desk — because arrangement alone is what makes a
+ * field read as a photo carousel instead of as paper. The other half of that
+ * is `bias`: paper in the world does not all bend alike.
  */
 interface PaperPose {
     position: [number, number, number];
     rotation: [number, number, number];
     scale: number;
+    /**
+     * How strongly this sheet takes the field's deformation: 1 = exactly as the
+     * preset configures it, 0 = flat. Lets one instanced draw call curl the top
+     * of a pile while the sheets pressed underneath stay flat. Omitted = 1.
+     */
+    bias?: number;
 }
 interface Layout<O = Record<string, unknown>> {
     id: string;
     label: string;
     defaults: O;
     optionsSchema: z.ZodType<O, z.ZodTypeDef, unknown>;
-    pose(i: number, n: number, o: O, phase: number): PaperPose;
+    /**
+     * `sheet` is the field's paper size. Layouts that arrange by CONTACT —
+     * edges meeting, sheets resting on each other — cannot work without it,
+     * and a layout that ignores it may simply omit the parameter.
+     */
+    pose(i: number, n: number, o: O, phase: number, sheet: SheetDims): PaperPose;
 }
 declare const ringSchema: z.ZodObject<{
     radius: z.ZodDefault<z.ZodNumber>;
@@ -4920,85 +5245,320 @@ declare const ringSchema: z.ZodObject<{
     radius?: number | undefined;
     tiltDeg?: number | undefined;
 }>;
+/** Prints pegged around a circle — the one carousel worth keeping. */
 declare const ring: Layout<z.infer<typeof ringSchema>>;
-declare const deckSchema: z.ZodObject<{
-    spread: z.ZodDefault<z.ZodNumber>;
+declare const fanSchema: z.ZodObject<{
+    /** Total angular sweep from the first sheet to the last, degrees. */
+    sweep: z.ZodDefault<z.ZodNumber>;
+    /** Where the shared pin sits, in half-sheet-heights below center. 1 = the bottom edge. */
+    hinge: z.ZodDefault<z.ZodNumber>;
+    /** Thickness step so the sheets stack in order instead of z-fighting. */
     lift: z.ZodDefault<z.ZodNumber>;
+    /** How much flatter the middle of the fan sits than its outer sheets. */
+    bow: z.ZodDefault<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
-    spread: number;
+    sweep: number;
+    hinge: number;
     lift: number;
+    bow: number;
 }, {
-    spread?: number | undefined;
+    sweep?: number | undefined;
+    hinge?: number | undefined;
     lift?: number | undefined;
+    bow?: number | undefined;
 }>;
-declare const deck: Layout<z.infer<typeof deckSchema>>;
-declare const cascadeSchema: z.ZodObject<{
-    gap: z.ZodDefault<z.ZodNumber>;
-    drop: z.ZodDefault<z.ZodNumber>;
+/**
+ * A Pantone deck, a paint-chip book, a hand of cards: every sheet pinned at
+ * one shared point and swung open. The sheets nearest the outside of the
+ * sweep carry the most curl, which is what sells the hinge as a hinge.
+ */
+declare const fan: Layout<z.infer<typeof fanSchema>>;
+declare const spreadSchema: z.ZodObject<{
+    /** How far each sheet slides past the one below it. */
+    slip: z.ZodDefault<z.ZodNumber>;
+    /** Direction of the slide, degrees. 0 slides right, 90 slides up. */
+    angle: z.ZodDefault<z.ZodNumber>;
+    lift: z.ZodDefault<z.ZodNumber>;
+    /** How much more the sheets at the far end of the slide bow. */
+    bow: z.ZodDefault<z.ZodNumber>;
+    /** Nothing hand-slid is perfectly square — a touch of per-sheet rotation. */
+    drift: z.ZodDefault<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
-    gap: number;
-    drop: number;
+    drift: number;
+    angle: number;
+    lift: number;
+    bow: number;
+    slip: number;
 }, {
-    gap?: number | undefined;
-    drop?: number | undefined;
+    drift?: number | undefined;
+    angle?: number | undefined;
+    lift?: number | undefined;
+    bow?: number | undefined;
+    slip?: number | undefined;
 }>;
-declare const cascade: Layout<z.infer<typeof cascadeSchema>>;
-declare const helixSchema: z.ZodObject<{
-    radius: z.ZodDefault<z.ZodNumber>;
-    height: z.ZodDefault<z.ZodNumber>;
-    turns: z.ZodDefault<z.ZodNumber>;
+/**
+ * A ream pushed sideways, or a deck dealt across a table: parallel sheets at
+ * a constant offset, each one bowing a little more as it comes free of the
+ * stack's weight.
+ */
+declare const spread: Layout<z.infer<typeof spreadSchema>>;
+declare const pileSchema: z.ZodObject<{
+    /** How far sheets wander from the center of the heap. */
+    scatter: z.ZodDefault<z.ZodNumber>;
+    /** Widest angle a sheet sits off square, degrees. */
+    turn: z.ZodDefault<z.ZodNumber>;
+    lift: z.ZodDefault<z.ZodNumber>;
+    /** How flat the sheets underneath are pressed by the ones on top. */
+    press: z.ZodDefault<z.ZodNumber>;
+    seed: z.ZodDefault<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
-    radius: number;
-    height: number;
-    turns: number;
+    seed: number;
+    lift: number;
+    scatter: number;
+    turn: number;
+    press: number;
 }, {
-    radius?: number | undefined;
-    height?: number | undefined;
-    turns?: number | undefined;
+    seed?: number | undefined;
+    lift?: number | undefined;
+    scatter?: number | undefined;
+    turn?: number | undefined;
+    press?: number | undefined;
 }>;
-declare const helix: Layout<z.infer<typeof helixSchema>>;
+/**
+ * The heap on a desk. The physical tell no parametric curve can fake: sheets
+ * rest ON each other, so only the top of the pile keeps its curl and
+ * everything below is pressed flat by the weight above it.
+ */
+declare const pile: Layout<z.infer<typeof pileSchema>>;
 declare const wallSchema: z.ZodObject<{
     gapX: z.ZodDefault<z.ZodNumber>;
     gapY: z.ZodDefault<z.ZodNumber>;
     jitterAmt: z.ZodDefault<z.ZodNumber>;
+    /** Spread of sag across the wall — no two pinned sheets hang alike. */
+    sag: z.ZodDefault<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
+    sag: number;
     gapX: number;
     gapY: number;
     jitterAmt: number;
 }, {
+    sag?: number | undefined;
     gapX?: number | undefined;
     gapY?: number | undefined;
     jitterAmt?: number | undefined;
 }>;
+/** A studio wall of pinned sheets: a grid, but nothing hangs quite square. */
 declare const wall: Layout<z.infer<typeof wallSchema>>;
-declare const tunnelSchema: z.ZodObject<{
-    radius: z.ZodDefault<z.ZodNumber>;
-    spacing: z.ZodDefault<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    radius: number;
-    spacing: number;
-}, {
-    radius?: number | undefined;
-    spacing?: number | undefined;
-}>;
-declare const tunnel: Layout<z.infer<typeof tunnelSchema>>;
-declare const scatterSchema: z.ZodObject<{
+declare const spillSchema: z.ZodObject<{
     spreadX: z.ZodDefault<z.ZodNumber>;
     spreadY: z.ZodDefault<z.ZodNumber>;
     depth: z.ZodDefault<z.ZodNumber>;
+    /** How far sheets pitch and roll out of the picture plane. */
+    tumble: z.ZodDefault<z.ZodNumber>;
+    /** Spread of bend across the sheets — a spill does not fold them alike. */
+    vary: z.ZodDefault<z.ZodNumber>;
     seed: z.ZodDefault<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
+    tumble: number;
+    seed: number;
     spreadX: number;
     spreadY: number;
     depth: number;
-    seed: number;
+    vary: number;
 }, {
+    tumble?: number | undefined;
+    seed?: number | undefined;
     spreadX?: number | undefined;
     spreadY?: number | undefined;
     depth?: number | undefined;
+    vary?: number | undefined;
+}>;
+/**
+ * A dropped folder's worth of paper, mid-air — what a `pile` looks like the
+ * moment before it settles. Loose in all three axes, and (the part that
+ * separates it from confetti) every sheet caught at its own angle AND its
+ * own amount of bend.
+ */
+declare const spill: Layout<z.infer<typeof spillSchema>>;
+declare const sweepSchema: z.ZodObject<{
+    columns: z.ZodDefault<z.ZodNumber>;
+    /** Breathing room around each specimen. */
+    gap: z.ZodDefault<z.ZodNumber>;
+    /** Deformation at the first specimen and at the last. */
+    from: z.ZodDefault<z.ZodNumber>;
+    to: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    columns: number;
+    gap: number;
+    from: number;
+    to: number;
+}, {
+    columns?: number | undefined;
+    gap?: number | undefined;
+    from?: number | undefined;
+    to?: number | undefined;
+}>;
+/**
+ * A specimen chart: the same sheet mounted in a grid, its deformation ramped
+ * across the series so one image shows a curl at ten stages instead of one.
+ * The layout the rest of this library exists to make possible — and the one
+ * that documents every deformer for free.
+ *
+ * Only as legible as the preset it charts: a sheet with no behavior or
+ * deformers has nothing for the ramp to scale, and every specimen comes out
+ * identical.
+ */
+declare const sweep: Layout<z.infer<typeof sweepSchema>>;
+declare const bookSchema: z.ZodObject<{
+    /** How far the outermost page lifts off the block, degrees. */
+    spread: z.ZodDefault<z.ZodNumber>;
+    /** Fraction of the pages bound to the left. 0 = a one-sided sample book. */
+    split: z.ZodDefault<z.ZodNumber>;
+    /** Page thickness — the gap between pages of one block. */
+    lift: z.ZodDefault<z.ZodNumber>;
+    /** How much more a lifted page arcs than one lying flat in the block. */
+    gutter: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    split: number;
+    gutter: number;
+    lift: number;
+    spread: number;
+}, {
+    split?: number | undefined;
+    gutter?: number | undefined;
+    lift?: number | undefined;
+    spread?: number | undefined;
+}>;
+/**
+ * An open codex: pages hinged on a shared spine, each block splaying away
+ * from the gutter. `split` slides it between the two bound forms paper takes
+ * — 0.5 is a book lying open, 0 is a swatch deck or sample book bound down
+ * one side. Pages lying flat in the block are pressed by the ones above;
+ * only the lifted pages keep their arc.
+ */
+declare const book: Layout<z.infer<typeof bookSchema>>;
+declare const accordionSchema: z.ZodObject<{
+    /** How far each panel tilts off the strip's line, degrees. 0 = flat, 90 = shut. */
+    angle: z.ZodDefault<z.ZodNumber>;
+    /** A concertina holds its creases — how much bow the panels keep. */
+    slack: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    angle: number;
+    slack: number;
+}, {
+    angle?: number | undefined;
+    slack?: number | undefined;
+}>;
+/**
+ * A concertina: panels alternating about creases they genuinely share, so
+ * the sheets read as ONE folded strip rather than as N separate papers —
+ * the only layout here where that is true. Adjacent edges are solved to
+ * meet, which is why it needs the sheet's real width.
+ */
+declare const accordion: Layout<z.infer<typeof accordionSchema>>;
+declare const rackSchema: z.ZodObject<{
+    /** Gap along the row, as a fraction of the paper's width. Under 1 they overlap. */
+    spacing: z.ZodDefault<z.ZodNumber>;
+    /** How far a sheet leans back off vertical, degrees. */
+    lean: z.ZodDefault<z.ZodNumber>;
+    /** How much that lean differs sheet to sheet — nothing propped is uniform. */
+    vary: z.ZodDefault<z.ZodNumber>;
+    /** Small rotations off square. */
+    sway: z.ZodDefault<z.ZodNumber>;
+    seed: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    sway: number;
+    seed: number;
+    spacing: number;
+    vary: number;
+    lean: number;
+}, {
+    sway?: number | undefined;
     seed?: number | undefined;
+    spacing?: number | undefined;
+    vary?: number | undefined;
+    lean?: number | undefined;
 }>;
-declare const scatter: Layout<z.infer<typeof scatterSchema>>;
+/**
+ * Prints stood in a row and leaning back — against a wall, in a rack, propped
+ * along a shelf. The one arrangement here that RESTS on a surface rather than
+ * floating: every sheet pivots on the bottom edge it actually stands on, so
+ * the row shares a floor. The further a sheet has leaned, the more it bows
+ * under its own weight.
+ *
+ * (Stacking these front-to-back the way a letter tray really holds paper is
+ * physically honest and visually useless — the front sheet hides the rest.
+ * A row is the arrangement you can actually see.)
+ */
+declare const rack: Layout<z.infer<typeof rackSchema>>;
+declare const colonnadeSchema: z.ZodObject<{
+    /** The walk the colonnade is built along — see `stage/path`. */
+    path: z.ZodDefault<z.ZodObject<{
+        points: z.ZodDefault<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">>;
+        closed: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        points: [number, number][];
+        closed: boolean;
+    }, {
+        points?: [number, number][] | undefined;
+        closed?: boolean | undefined;
+    }>>;
+    /** Half-width of the clear aisle: how far each banner stands off the walk line. */
+    aisle: z.ZodDefault<z.ZodNumber>;
+    /** How much that gap opens and closes along the walk. Nothing hung by hand is a corridor. */
+    breathe: z.ZodDefault<z.ZodNumber>;
+    /** Widest angle a banner turns off square to the aisle, degrees. */
+    twist: z.ZodDefault<z.ZodNumber>;
+    /** Fraction of the walk left clear at each end, so the figure has somewhere to enter from. */
+    margin: z.ZodDefault<z.ZodNumber>;
+    /** Spread of banner heights, 0..1. */
+    rise: z.ZodDefault<z.ZodNumber>;
+    /** How far the banners lift off the floor, as a fraction of their height. 0 = they pool on it. */
+    hover: z.ZodDefault<z.ZodNumber>;
+    /** Spread of deformation — no two lengths of hung paper drape alike. */
+    drape: z.ZodDefault<z.ZodNumber>;
+    seed: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    path: {
+        points: [number, number][];
+        closed: boolean;
+    };
+    seed: number;
+    hover: number;
+    drape: number;
+    margin: number;
+    twist: number;
+    aisle: number;
+    breathe: number;
+    rise: number;
+}, {
+    path?: {
+        points?: [number, number][] | undefined;
+        closed?: boolean | undefined;
+    } | undefined;
+    seed?: number | undefined;
+    hover?: number | undefined;
+    drape?: number | undefined;
+    margin?: number | undefined;
+    twist?: number | undefined;
+    aisle?: number | undefined;
+    breathe?: number | undefined;
+    rise?: number | undefined;
+}>;
+/**
+ * A nave of hanging banners flanking a walk: paper as ARCHITECTURE rather
+ * than as an object on a desk. The first layout here that arranges along a
+ * path instead of around an origin, which is what lets a figure walk through
+ * it — the aisle is guaranteed clear because the banners are placed off the
+ * walk line, not merely near it.
+ *
+ * Banners alternate ranks (left, right, left…) and the two ranks are
+ * staggered by a quarter step, so you pass them one at a time rather than
+ * through a ladder of matched pairs. Each faces across the aisle: a banner
+ * ahead of you presents its face, which is the whole reason to print
+ * anything on it.
+ */
+declare const colonnade: Layout<z.infer<typeof colonnadeSchema>>;
 /**
  * A block of stamps: flat rows × columns grid in register, floating a hair
  * above the (field-rendered) backing sheet. Standard layout contract — it
@@ -5006,10 +5566,479 @@ declare const scatter: Layout<z.infer<typeof scatterSchema>>;
  * by the field renderer, not by `pose`.
  */
 declare const sheet: Layout<SheetLayoutOptions>;
-declare function registerLayout(layout: Layout<any>): void;
-declare function getLayout(id: string): Layout<any>;
+declare function registerLayout(layout: Layout<AnyOptions>): void;
+declare function getLayout(id: string): Layout<AnyOptions>;
 declare function listLayouts(): string[];
 
+/**
+ * Framing a field is arithmetic, not guesswork: layouts are pure `pose`
+ * functions, so we can just ask one where all its sheets are and put the
+ * camera where they all fit. Community layouts get framed for free.
+ */
+interface FieldBounds {
+    center: [number, number, number];
+    /** Half-extents — the box reaches `center ± half`. */
+    half: [number, number, number];
+}
+/**
+ * The box `n` sheets occupy under a layout. Each sheet is treated as a ball
+ * of its half-diagonal, which covers every rotation the pose can apply
+ * without having to build the pose matrices.
+ */
+declare function fieldBounds(layout: Layout<AnyOptions>, n: number, options: unknown, sheet: SheetDims): FieldBounds;
+/**
+ * Where to put a perspective camera so every sheet a layout poses lands in
+ * frame. Solved per sheet at its own depth rather than against the field's
+ * bounding box: a `ring`'s widest sheets sit at mid-depth, and pretending
+ * that width exists at the near face would shove the camera far enough back
+ * to lose the gallery entirely.
+ */
+declare function fitCamera(layout: Layout<AnyOptions>, n: number, options: unknown, sheet: SheetDims, fovDeg: number, aspect: number, margin?: number): {
+    position: [number, number, number];
+    target: [number, number, number];
+};
+
+declare const stageSchema: z.ZodObject<{
+    path: z.ZodDefault<z.ZodObject<{
+        points: z.ZodDefault<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">>;
+        closed: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        points: [number, number][];
+        closed: boolean;
+    }, {
+        points?: [number, number][] | undefined;
+        closed?: boolean | undefined;
+    }>>;
+    shot: z.ZodDefault<z.ZodObject<{
+        shot: z.ZodDefault<z.ZodEnum<["follow", "lead", "low", "wide"]>>;
+        distance: z.ZodDefault<z.ZodNumber>;
+        height: z.ZodDefault<z.ZodNumber>;
+        lookAhead: z.ZodDefault<z.ZodNumber>;
+        offset: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        height: number;
+        offset: number;
+        distance: number;
+        shot: "follow" | "lead" | "low" | "wide";
+        lookAhead: number;
+    }, {
+        height?: number | undefined;
+        offset?: number | undefined;
+        distance?: number | undefined;
+        shot?: "follow" | "lead" | "low" | "wide" | undefined;
+        lookAhead?: number | undefined;
+    }>>;
+    figure: z.ZodDefault<z.ZodObject<{
+        height: z.ZodDefault<z.ZodNumber>;
+        speed: z.ZodDefault<z.ZodNumber>;
+        stride: z.ZodDefault<z.ZodNumber>;
+        swing: z.ZodDefault<z.ZodNumber>;
+        color: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        height: number;
+        speed: number;
+        color: string;
+        stride: number;
+        swing: number;
+    }, {
+        height?: number | undefined;
+        speed?: number | undefined;
+        color?: string | undefined;
+        stride?: number | undefined;
+        swing?: number | undefined;
+    }>>;
+    /** Stage mode is built for `nave`; the others are all front-lit. */
+    lighting: z.ZodDefault<z.ZodEnum<["studio", "window", "leaves", "goldenhour", "noir", "nave"]>>;
+    showFigure: z.ZodDefault<z.ZodBoolean>;
+    source: z.ZodDefault<z.ZodObject<{
+        /** The bright void the walk resolves toward. Without it the vanishing point is a hole. */
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        color: z.ZodDefault<z.ZodString>;
+        /** How far past the end of the walk it stands, world units. */
+        beyond: z.ZodDefault<z.ZodNumber>;
+        /**
+         * A cyclorama around the whole stage, graded from the source colour at the
+         * horizon to near-dark overhead. The source plane only faces down the walk,
+         * so without this every shot that isn't axial — `wide` especially — looks
+         * out at a black void where the room should be.
+         */
+        surround: z.ZodDefault<z.ZodBoolean>;
+        /** Colour overhead. The horizon takes the source's own colour. */
+        zenith: z.ZodDefault<z.ZodString>;
+        /** Size, as a multiple of the PAPER height — it only has to out-fill the frame. */
+        spread: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        color: string;
+        enabled: boolean;
+        spread: number;
+        zenith: string;
+        beyond: number;
+        surround: boolean;
+    }, {
+        color?: string | undefined;
+        enabled?: boolean | undefined;
+        spread?: number | undefined;
+        zenith?: string | undefined;
+        beyond?: number | undefined;
+        surround?: boolean | undefined;
+    }>>;
+    ground: z.ZodDefault<z.ZodObject<{
+        /** The floor. Without something to catch the shadows there is no ground and no scale. */
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        color: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        color: string;
+        enabled: boolean;
+    }, {
+        color?: string | undefined;
+        enabled?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    path: {
+        points: [number, number][];
+        closed: boolean;
+    };
+    lighting: "studio" | "window" | "leaves" | "goldenhour" | "noir" | "nave";
+    figure: {
+        height: number;
+        speed: number;
+        color: string;
+        stride: number;
+        swing: number;
+    };
+    source: {
+        color: string;
+        enabled: boolean;
+        spread: number;
+        zenith: string;
+        beyond: number;
+        surround: boolean;
+    };
+    shot: {
+        height: number;
+        offset: number;
+        distance: number;
+        shot: "follow" | "lead" | "low" | "wide";
+        lookAhead: number;
+    };
+    showFigure: boolean;
+    ground: {
+        color: string;
+        enabled: boolean;
+    };
+}, {
+    path?: {
+        points?: [number, number][] | undefined;
+        closed?: boolean | undefined;
+    } | undefined;
+    lighting?: "studio" | "window" | "leaves" | "goldenhour" | "noir" | "nave" | undefined;
+    figure?: {
+        height?: number | undefined;
+        speed?: number | undefined;
+        color?: string | undefined;
+        stride?: number | undefined;
+        swing?: number | undefined;
+    } | undefined;
+    source?: {
+        color?: string | undefined;
+        enabled?: boolean | undefined;
+        spread?: number | undefined;
+        zenith?: string | undefined;
+        beyond?: number | undefined;
+        surround?: boolean | undefined;
+    } | undefined;
+    shot?: {
+        height?: number | undefined;
+        offset?: number | undefined;
+        distance?: number | undefined;
+        shot?: "follow" | "lead" | "low" | "wide" | undefined;
+        lookAhead?: number | undefined;
+    } | undefined;
+    showFigure?: boolean | undefined;
+    ground?: {
+        color?: string | undefined;
+        enabled?: boolean | undefined;
+    } | undefined;
+}>;
+type StageConfig = z.infer<typeof stageSchema>;
+type StageConfigInput = z.input<typeof stageSchema>;
+
+/**
+ * Render quality tiers.
+ *
+ * A stage is the heaviest thing this library draws — tens of thousands of
+ * subdivided vertices, a shadow pass, a translucent fragment shader and a
+ * full-screen backdrop — and it has to run on machines nobody developing it
+ * owns. Quality is deliberately NOT part of `stageSchema`: it describes the
+ * device, not the artwork, so it must never travel in a preset or a shared
+ * link. Two people opening the same link should see the same scene at
+ * whatever fidelity their hardware can hold.
+ *
+ * The four knobs, in the order they actually cost:
+ *
+ * - `segments` — subdivisions along a banner's long edge. Quadratic: every
+ *   sheet is a grid, so halving this quarters the vertex work.
+ * - `shadowMapSize` — the shadow pass re-renders the scene's geometry. 0
+ *   turns shadows off, which on a weak machine is the difference between
+ *   moving and not.
+ * - `dpr` — fragment cost scales with the square of it, and this scene is
+ *   fragment-heavy (translucency, fog, a full-screen backdrop).
+ * - `surround` — one more full-screen draw; cheap, but free to drop.
+ */
+declare const qualityNames: readonly ["auto", "low", "medium", "high"];
+type QualityName = (typeof qualityNames)[number];
+type QualityTier = Exclude<QualityName, 'auto'>;
+
+interface PaperStageSceneProps {
+    /** Walk, shot, figure, lighting — see `stageSchema`. */
+    stage?: StageConfigInput;
+    /** Any layout, but `colonnade` is the one built to arrange along a walk. */
+    layout?: string;
+    layoutOptions?: Record<string, unknown>;
+    /** Per-banner slots, exactly as in field mode. */
+    papers?: FieldPaperSlot[];
+    images?: string[];
+    /**
+     * Words on the banners. A string is split across them a line at a time; an
+     * array is used as given. This is the whole point of the mode — a space
+     * built out of something the viewer wrote.
+     */
+    text?: string | string[];
+    /** Shared preset behind every banner. */
+    preset?: string | PaperConfigInput;
+    /** How many banners, when none of `papers` / `images` / `text` says. */
+    count?: number;
+    /**
+     * How far along the walk the figure is, 0..1. Bind it to scroll and the
+     * page scrolls the walk. Omit and it walks on the clock at its own speed.
+     */
+    progress?: number;
+    reducedMotion?: boolean;
+    /**
+     * How much the render is allowed to cost. `auto` (the default) starts in
+     * the middle and adapts to whatever the machine turns out to manage — this
+     * scene runs on hardware nobody developing it owns. Not part of the stage
+     * config: quality describes the DEVICE, not the artwork, so it must never
+     * travel in a preset or a shared link.
+     */
+    quality?: QualityName;
+    /**
+     * Fires when `auto` moves the tier. Useful for showing the viewer what
+     * they are getting, and for measuring what real machines settle on.
+     */
+    onQualityChange?(tier: QualityTier): void;
+}
+interface PaperStageProps extends PaperStageSceneProps {
+    children?: React.ReactNode;
+    className?: string;
+    style?: React.CSSProperties;
+}
+declare function PaperStageScene({ stage: stageInput, quality, onQualityChange, layout, layoutOptions, papers, images, text, preset, count, progress, reducedMotion, }: PaperStageSceneProps): react.JSX.Element;
+/** `<PaperStage />` owns its Canvas; `<PaperStageScene />` drops into an existing one. */
+declare function PaperStage({ children, className, style, ...sceneProps }: PaperStageProps): react.JSX.Element;
+
+/**
+ * Named stages. A mode with no presets asks its visitor to invent a space
+ * out of eleven sliders before it will show them anything — and stage mode
+ * takes about fifteen seconds to understand once you have seen one, which
+ * means the presets ARE the explanation.
+ *
+ * Each names somewhere paper is actually hung at architectural scale, the
+ * same rule the layouts follow.
+ */
+interface StagePreset {
+    id: string;
+    label: string;
+    /** One line, shown under the name. What you are about to look at. */
+    description: string;
+    stage: StageConfigInput;
+    layout: string;
+    layoutOptions?: Record<string, unknown>;
+    /** The paper itself — banners differ per stage more than anything else. */
+    paper?: PaperConfigInput;
+    count: number;
+    text?: string;
+}
+declare const stagePresets: Record<string, StagePreset>;
+declare function getStagePreset(id: string): StagePreset;
+declare function listStagePresets(): string[];
+
+/**
+ * The walk — a path across the ground plane that a figure follows and that
+ * layouts arrange paper along. Pure 2D math (x, z on the floor, y is always
+ * up), no three.js, so it tests in node and is cheap enough to call from
+ * inside a layout's pure `pose`.
+ *
+ * Centripetal Catmull-Rom through the control points — it will not cusp or
+ * overshoot when two points bunch together, which a uniform spline does —
+ * resampled to a uniform arc-length polyline. That resampling is the point:
+ * `pointAt(s)` advances at constant SPEED, so a figure stepping `s` forward
+ * at a steady rate covers ground at a steady rate. A raw spline parameter
+ * would have it sprint through the straights and crawl around the corners.
+ */
+/** A point on the floor. */
+type Ground = [x: number, z: number];
+declare const walkPathSchema: z.ZodObject<{
+    /**
+     * Control points on the ground plane, [x, z]. The default walks away from
+     * the camera down -Z — the shot every reference image is composed on.
+     */
+    points: z.ZodDefault<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">>;
+    /** Join the last point back to the first: an endless walk, and the only form `phase` can slide. */
+    closed: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    points: [number, number][];
+    closed: boolean;
+}, {
+    points?: [number, number][] | undefined;
+    closed?: boolean | undefined;
+}>;
+type WalkPathOptions = z.infer<typeof walkPathSchema>;
+interface WalkPath {
+    /** Total arc length in world units. */
+    readonly length: number;
+    readonly closed: boolean;
+    /** `s` is normalized arc length: 0 = the start, 1 = the end. Closed paths wrap, open paths clamp. */
+    pointAt(s: number): Ground;
+    /** Unit forward direction at `s`. */
+    tangentAt(s: number): Ground;
+    /** Unit LEFT-hand normal at `s` — the side of the aisle a walker's left hand points to. */
+    normalAt(s: number): Ground;
+}
+declare function createWalkPath(options: WalkPathOptions): WalkPath;
+
+/**
+ * Named walks. A path is a list of control points, which is the right thing
+ * to serialize and the wrong thing to put in front of someone — nobody wants
+ * to type coordinates to find out what a curved colonnade looks like. These
+ * are the shapes worth starting from; every one resolves to ordinary points,
+ * so editing on from here stays possible.
+ */
+declare const walkNames: readonly ["straight", "bend", "ess", "ring", "spiral"];
+type WalkName = (typeof walkNames)[number];
+declare const walks: Record<WalkName, WalkPathOptions>;
+declare function getWalk(name: WalkName): WalkPathOptions;
+
+/**
+ * Where to put the camera on a walk.
+ *
+ * `fitCamera` in field/framing.ts solves a different problem — get every
+ * sheet inside the frustum — and solving it here would produce the neutral
+ * three-quarter product shot that stage mode exists to avoid. These are
+ * SHOTS: a camera stationed relative to the walking figure, framing the
+ * space rather than the objects, with the vanishing point doing the work.
+ */
+declare const shotNames: readonly ["follow", "lead", "low", "wide"];
+type ShotName = (typeof shotNames)[number];
+declare const shotSchema: z.ZodObject<{
+    shot: z.ZodDefault<z.ZodEnum<["follow", "lead", "low", "wide"]>>;
+    /**
+     * How far the camera stands off the figure ALONG the walk, world units.
+     * `wide` reads it as how far back it stands; how far it steps aside is
+     * derived from the paper, since that is what it has to clear.
+     */
+    distance: z.ZodDefault<z.ZodNumber>;
+    /** Multiplier on the shot's natural camera height. 1 is as designed. */
+    height: z.ZodDefault<z.ZodNumber>;
+    /** How far up the walk the camera looks past the figure, world units. */
+    lookAhead: z.ZodDefault<z.ZodNumber>;
+    /** Sideways step off the walk line, world units. Positive is the walker's left. */
+    offset: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    height: number;
+    offset: number;
+    distance: number;
+    shot: "follow" | "lead" | "low" | "wide";
+    lookAhead: number;
+}, {
+    height?: number | undefined;
+    offset?: number | undefined;
+    distance?: number | undefined;
+    shot?: "follow" | "lead" | "low" | "wide" | undefined;
+    lookAhead?: number | undefined;
+}>;
+type ShotOptions = z.infer<typeof shotSchema>;
+interface StageShot {
+    position: [x: number, y: number, z: number];
+    target: [x: number, y: number, z: number];
+}
+/**
+ * What each shot is FOR. A stage has two subjects at very different scales —
+ * a body about 1.75 units tall and paper five times that — and a camera that
+ * only knows about the body frames the body, which is how a colonnade of
+ * printed banners ends up showing its bottom third and the tops of some
+ * letterforms. Camera height stays a body measurement (eye level is eye
+ * level); where it AIMS is a blend, and the paper carries most of it.
+ */
+interface StageScale {
+    /** Standing height of the figure. */
+    figure: number;
+    /** Height of the tallest paper on the stage. */
+    paper: number;
+}
+
+/**
+ * Stage-mode export. Same anatomy and version as the paper and field
+ * exports, with one addition that matters more than the rest: the scroll
+ * variant. `progress` is the whole interaction model of a stage, and a
+ * scroll-driven hero is what most people opening this menu actually want —
+ * so the export writes the pinning and the scroll math, which is the part
+ * that is fiddly to get right and boring to write.
+ */
+interface StageExportInput {
+    stage: StageConfigInput;
+    layout: string;
+    layoutOptions?: Record<string, unknown>;
+    /** The banner itself — dims, stock, drape. Omitted uses the built-in banner. */
+    paper?: PaperConfigInput;
+    /** The words the space is built from. Omitted renders blank banners. */
+    text?: string;
+    count?: number;
+    /** Bind the walk to page scroll, pinned, rather than to the clock. */
+    scroll?: boolean;
+    /** Exported component name. */
+    componentName?: string;
+}
+/** Which named walk these points are, if any — the export reads better for it. */
+declare function walkNameFor(path: StageConfig['path']): WalkName | undefined;
+/** The stage config with defaults removed — what actually needs writing down. */
+declare function diffStage(stage: StageConfigInput): Record<string, unknown>;
+/**
+ * JSON.stringify, except an array of plain numbers stays on one line. A walk
+ * is a list of coordinate pairs, and the default pretty-printer spreads each
+ * `[6, 17]` over four lines — twenty lines of punctuation for one gentle
+ * curve. Exported code is a product surface; it should read like something a
+ * person wrote.
+ */
+declare function stringifyStage(value: unknown, indent?: number): string;
+/** The one-line visual an agent verifies after `npm run dev`. */
+declare function describeStage(input: StageExportInput): string;
+/** Component source shared by the JSX snippet and the agent payload. */
+declare function buildStageComponentSource(input: StageExportInput): string;
+/** The self-contained stage integration brief — one paste into a coding agent. */
+declare function buildStageAgentPayload(input: StageExportInput): string;
+
+/** How much of the incident key light a fully translucent sheet passes on. */
+declare const TRANSMISSION_GAIN = 0.5;
+interface TranslucencyValues {
+    translucency: number;
+    /** Unit world direction from the scene toward the key light. */
+    direction: THREE.Vector3;
+    color: THREE.Color;
+    /** Light the room passes through the sheet from every direction at once. */
+    ambient: number;
+}
+/**
+ * Resolve the transmission uniforms from the paper and the scene's lighting
+ * preset — the key light's own position and color, so translucency can never
+ * disagree with the lamp casting the shadows.
+ */
+declare function translucencyValues(translucency: number, lighting: LightingName): TranslucencyValues;
+/** Ready-to-bind uniform objects for a shader program. */
+declare function translucencyUniforms(translucency: number, lighting: LightingName): Record<string, {
+    value: unknown;
+}>;
+
 /**
  * A stock is a named bundle of material + geometry defaults — choosing paper
  * at a print shop. Individual controls always override; schema-wise these are
@@ -5023,6 +6052,12 @@ interface Stock {
     roughness: number;
     /** 0 = opaque. Vellum is translucent. */
     opacity: number;
+    /**
+     * How much light passes THROUGH the sheet when something is behind it,
+     * 0..1. Distinct from `opacity`: newsprint is fully opaque to look at and
+     * still glows on a lightbox. This is what makes a backlit banner read.
+     */
+    translucency: number;
     /** Ink multiply tint for content drawn on this stock (thermal prints grey-black). */
     inkColor: string;
     /** Thermal-printer banding intensity baked into the grain effect. */
@@ -5040,7 +6075,16 @@ interface Stock {
 declare const stocks: Record<StockName, Stock>;
 declare function getStock(name: StockName): Stock;
 
-declare function atlasGrid(count: number): {
+/**
+ * Grid shape for `count` tiles of a given aspect (height / width).
+ *
+ * Square tiles want a square grid, but a stage banner is 5.7 times taller
+ * than it is wide, and packing those into a square GRID makes an atlas five
+ * times taller than it is wide — which then has to be squashed to fit the
+ * texture budget, and the content with it. Choosing cols/rows ≈ aspect keeps
+ * the atlas itself roughly square whatever shape the paper is.
+ */
+declare function atlasGrid(count: number, aspect?: number): {
     cols: number;
     rows: number;
 };
@@ -5147,7 +6191,9 @@ declare function composeSurface(surface: SurfaceConfig, stock: Stock, thickness:
 sheet?: {
     width: number;
     height: number;
-}): ComposedSurface;
+}, 
+/** Whose key light transmission is measured against. */
+lighting?: LightingName): ComposedSurface;
 
 interface PaperMaterialProps {
     stock: Stock;
@@ -5161,6 +6207,8 @@ interface PaperMaterialProps {
         width: number;
         height: number;
     };
+    /** Scene lighting — transmission is measured against its key light. */
+    lighting?: LightingName;
 }
 /**
  * The paper's skin: MeshStandardMaterial (real lighting preserved) extended
@@ -5169,7 +6217,7 @@ interface PaperMaterialProps {
  * paper doesn't mirror its front through the sheet. Programs rebuild only
  * on structure change; value edits mutate uniforms in place.
  */
-declare function PaperMaterial({ stock, texture, backTexture, surface, thickness, sheet, }: PaperMaterialProps): react.JSX.Element;
+declare function PaperMaterial({ stock, texture, backTexture, surface, thickness, sheet, lighting, }: PaperMaterialProps): react.JSX.Element;
 
 type ReceiptContent = Extract<ContentConfig, {
     type: 'receipt';
@@ -5355,4 +6403,4 @@ interface ModeContext {
  */
 declare function resolveMode(requested: PaperModeRequest, ctx: ModeContext): PaperMode;
 
-export { AGENT_PAYLOAD_VERSION, type AeroPose, type BackContentConfig, type BackingDrawSpec, type Behavior, type BehaviorConfig, type BendOptions, type CarryOptions, type ClothConfig, type ClothParams, ClothSim, type ComposedDisplacement, type ComposedSurface, type ContentAtlas, type ContentConfig, type CoreStateName, type CurlOptions, type DampedValue, type Deformer, type DeformerContext, type DeformerInstance, type DeformerInstanceConfig, DropZone, type DropZoneConfig, type DropZoneProps, DropZoneRegistry, type FallOptions, type FieldA11yController, type FieldExportInput, type FieldExportPaper, type FieldExportZone, type FieldGroupData, type FieldPaperSlot, type FlightOptions, type FlightParams, type FlipOptions, type FlyOptions, type FoldOptions, type HandleSpec, type HangOptions, type IdleName, type IdlePreset, type KeyboardCarry, type KeyboardStepResult, type Layout, type LetterFoldOptions, type LightingName, type LightingPreset, ON_TWOS_FPS, PARITY_EPSILON, Paper, type PaperConfig, type PaperConfigInput, type PaperEdge, PaperFallback, PaperField, PaperFieldMesh, type PaperFieldMeshProps, type PaperFieldProps, type PaperHandle, PaperLighting, type PaperLightingProps, PaperMaterial, type PaperMaterialProps, PaperMesh, type PaperMeshProps, PaperMirror, type PaperMode, type PaperModeRequest, type PaperPose, type PaperProps, PaperStateMachine, type PaperStateMachineOptions, type PaperStates, type PaperStatesInput, type ParityCase, type ParityResult, type PeelOptions, type PhysicsConfig, type PinMode, type PlacedPaper, type ReceiptContent, type RollOptions, SHEET_LIFT, type SceneConfig, type SheetConfig, type SheetDims, type SheetLayoutOptions, type StateDef, type StateEvent, type StateName, type StateTransitionConfig, type Stock, type StockName, type SurfaceConfig, type SurfaceMaps, type UnrollOptions, type UsePaperStatesResult, type WaveOptions, applyDeformerStack, atlasGrid, backContentSchema, barcodeBars, behaviorConfigSchema, bend, bendOptionsSchema, buildAgentPayload, buildDisplacementGLSL, buildFieldAgentPayload, buildFieldComponentSource, buildFieldFragmentShader, buildFieldVertexShader, buildJsxSnippet, carry, carryDrive, carryOptionsSchema, cascade, clothConfigSchema, composeSurface, contentSchema, contentText, coreStateNames, cornerNames, createSheetGeometry, curl, curlOptionsSchema, dampTo, deck, deformerInstanceSchema, describeConfig, describeFieldConfig, diffConfig, diffFieldProps, displacePoint, distinctFieldPresets, drawBacking, fall, fallOptionsSchema, fieldKeyboardStep, flattenNumeric, flight, flightOptionsSchema, flightPose, flip, flipOptionsSchema, fly, flyOptionsSchema, fold, foldOptionsSchema, getBehavior, getDeformer, getIdlePreset, getLayout, getLightingPreset, getPreset, getStock, groupFieldPapers, gust, hang, hangOptionsSchema, helix, idleNames, idlePresets, isBuiltinPreset, letterFold, letterFoldOptionsSchema, lightenHex, lightingNames, lightingPresets, listBehaviors, listDeformers, listLayouts, listPresets, makeGoboTexture, mergeConfig, mergeWithDeletes, outwardCorner, paperConfigSchema, paperEdges, paperStatesSchema, parityCases, parsePreset, peel, peelOptionsSchema, physicsNames, physicsSchema, quantizeProgress, quantizeTime, receiptContentSchema, receiptTotals, recordStateOverride, registerBehavior, registerDeformer, registerLayout, registerPreset, resolveConfig, resolveFieldSlotConfig, resolveMode, resolveSegments, resolveStateConfig, ring, roll, rollOptionsSchema, runParityHarness, scatter, sceneSchema, serializePreset, sheet, sheetBackingSize, sheetLayoutSchema, sheetSchema, sheetSlotXY, silhouetteRects, stackMinSegments, stackUniformValues, stateDefSchema, stateEventTransitions, stateTransitionSchema, stockNames, stockSchema, stocks, stripStates, supportsWebGL, surfaceSchema, tornEdgesOnDetach, tunnel, uniquePresetName, unregisterPreset, unroll, unrollOptionsSchema, useContentAtlas, usePaperStates, usePrefersReducedMotion, wall, wave, waveOptionsSchema, withSheetCellFromPaper, zoneAccepts };
+export { AGENT_PAYLOAD_VERSION, type AeroPose, type BackContentConfig, type BackingDrawSpec, type Behavior, type BehaviorConfig, type BehaviorConfigInput, type BendOptions, type CarryOptions, type ClothConfig, type ClothParams, ClothSim, type ComposedDisplacement, type ComposedSurface, type ContentAtlas, type ContentConfig, type ContentConfigInput, type CoreStateName, type CrumpleBehaviorOptions, type CrumpleOptions, type CurlOptions, type DampedValue, type Deformer, type DeformerContext, type DeformerInstance, type DeformerInstanceConfig, type DeformerInstanceConfigInput, type DrapeOptions, DropZone, type DropZoneConfig, type DropZoneProps, DropZoneRegistry, type FallOptions, type FieldA11yController, type FieldBounds, type FieldExportInput, type FieldExportPaper, type FieldExportZone, type FieldGroupData, type FieldPaperSlot, type FlightOptions, type FlightParams, type FlipOptions, type FlyOptions, type FoldOptions, type Ground, type HandleSpec, type HangOptions, type IdleName, type IdlePreset, type KeyboardCarry, type KeyboardStepResult, type Layout, type LetterFoldOptions, type LightingName, type LightingPreset, ON_TWOS_FPS, PARITY_EPSILON, Paper, type PaperConfig, type PaperConfigInput, type PaperEdge, PaperFallback, PaperField, PaperFieldMesh, type PaperFieldMeshProps, type PaperFieldProps, type PaperHandle, PaperLighting, type PaperLightingProps, PaperMaterial, type PaperMaterialProps, PaperMesh, type PaperMeshProps, PaperMirror, type PaperMode, type PaperModeRequest, type PaperPose, type PaperProps, PaperStage, type PaperStageProps, PaperStageScene, type PaperStageSceneProps, PaperStateMachine, type PaperStateMachineOptions, type PaperStates, type PaperStatesInput, type ParityCase, type ParityResult, type PeelOptions, type PhysicsConfig, type PhysicsConfigInput, type PinMode, type PlacedPaper, type QualityName, type QualityTier, type ReceiptContent, type RollOptions, SHEET_LIFT, type SceneConfig, type SceneConfigInput, type SheetConfig, type SheetDims, type SheetLayoutOptions, type ShotName, type ShotOptions, type StageConfig, type StageConfigInput, type StageExportInput, type StagePreset, type StageScale, type StageShot, type StateDef, type StateEvent, type StateName, type StateTransitionConfig, type Stock, type StockName, type SurfaceConfig, type SurfaceConfigInput, type SurfaceMaps, TRANSMISSION_GAIN, type TranslucencyValues, type UnrollOptions, type UsePaperStatesResult, type WalkName, type WalkPath, type WalkPathOptions, type WaveOptions, accordion, applyDeformerStack, atlasGrid, backContentSchema, barcodeBars, behaviorConfigSchema, bend, bendOptionsSchema, book, buildAgentPayload, buildDisplacementGLSL, buildFieldAgentPayload, buildFieldComponentSource, buildFieldFragmentShader, buildFieldVertexShader, buildJsxSnippet, buildStageAgentPayload, buildStageComponentSource, carry, carryDrive, carryOptionsSchema, clothConfigSchema, colonnade, composeSurface, contentSchema, contentText, coreStateNames, cornerNames, createSheetGeometry, createWalkPath, crumple, crumpleBehavior, crumpleBehaviorOptionsSchema, crumpleOptionsSchema, curl, curlOptionsSchema, dampTo, deformerInstanceSchema, describeConfig, describeFieldConfig, describeStage, diffConfig, diffFieldProps, diffStage, displacePoint, distinctFieldPresets, drape, drapeOptionsSchema, drawBacking, fall, fallOptionsSchema, fan, fieldBounds, fieldKeyboardStep, fitCamera, flattenNumeric, flight, flightOptionsSchema, flightPose, flip, flipOptionsSchema, fly, flyOptionsSchema, fold, foldOptionsSchema, getBehavior, getDeformer, getIdlePreset, getLayout, getLightingPreset, getPreset, getStagePreset, getStock, getWalk, groupFieldPapers, gust, hang, hangOptionsSchema, idleNames, idlePresets, isBuiltinPreset, letterFold, letterFoldOptionsSchema, lightenHex, lightingNames, lightingPresets, listBehaviors, listDeformers, listLayouts, listPresets, listStagePresets, makeGoboTexture, mergeConfig, mergeWithDeletes, outwardCorner, paperConfigSchema, paperEdges, paperStatesSchema, parityCases, parsePreset, peel, peelOptionsSchema, physicsNames, physicsSchema, pile, qualityNames, quantizeProgress, quantizeTime, rack, receiptContentSchema, receiptTotals, recordStateOverride, registerBehavior, registerDeformer, registerLayout, registerPreset, resolveConfig, resolveDeformerStack, resolveFieldSlotConfig, resolveMode, resolveSegments, resolveStateConfig, ring, roll, rollOptionsSchema, runParityHarness, sceneSchema, serializePreset, sheet, sheetBackingSize, sheetLayoutSchema, sheetSchema, sheetSlotXY, shotNames, silhouetteRects, spill, spread, stackMinSegments, stackUniformValues, stagePresets, stageSchema, stateDefSchema, stateEventTransitions, stateTransitionSchema, stockNames, stockSchema, stocks, stringifyStage, stripStates, supportsWebGL, surfaceSchema, sweep, tornEdgesOnDetach, translucencyUniforms, translucencyValues, uniquePresetName, unregisterPreset, unroll, unrollOptionsSchema, useContentAtlas, usePaperStates, usePrefersReducedMotion, walkNameFor, walkNames, walks, wall, wave, waveOptionsSchema, withSheetCellFromPaper, zoneAccepts };