paperlab 0.5.2 → 0.6.0

package/dist/stage.d.cts

@@ -1,5 +1,5 @@
 import * as react from 'react';
-import { F as FieldPaperSlot, a as PaperConfigInput } from './slots-CIo7FnlY.cjs';
+import { F as FieldPaperSlot, a as PaperConfigInput } from './slots-C5PqY0Q5.cjs';
 import { z } from 'zod';
 
 /**
@@ -15,136 +15,63 @@ import { z } from 'zod';
  * you say you want it raw.
  */
 declare const stageGradeSchema: z.ZodObject<{
-    /**
-     * How far light bleeds past what is emitting it.
-     *
-     * This is the one that matters most in a backlit hall, because the source
-     * plane is drawn with `toneMapped: false` — it is light, not an object, so
-     * no tone curve ever rolls it off. Bloom is the only thing that gives it
-     * an edge that behaves like light instead of like a lit rectangle.
-     */
     bloom: z.ZodDefault<z.ZodNumber>;
-    /**
-     * How bright a pixel has to be before it blooms at all, in LINEAR light.
-     *
-     * Above 1.0 is not only legal, it is the useful range — and that is the
-     * whole reason the bound is 4 rather than 1. Bloom reads the scene before
-     * the tone curve, while values are still unbounded, so "1.0" means "as
-     * bright as white" rather than "as bright as the brightest pixel on
-     * screen". Lit near-white paper sits close to 1.0 all by itself; the
-     * source burns at `SOURCE_INTENSITY`, several times that. A threshold
-     * under 1 therefore blooms the PAPER, which fogs the hall and costs the
-     * sheets their edges — the exact failure this default is set to avoid.
-     */
     threshold: z.ZodDefault<z.ZodNumber>;
-    /**
-     * Depth falloff — how much the near and far ends of the walk go soft.
-     *
-     * **Defaults to 0, and that is a considered default rather than a stub.**
-     * Depth in this scene is already staged by haze, which is how a real hall
-     * does it and which costs one fragment instruction; optical blur is a
-     * second full-screen pass with a circle-of-confusion buffer behind it, and
-     * it is the effect most likely to read as a video game rather than as a
-     * photograph. Every paper installation worth copying is shot deep — an
-     * f/11 room where the sheets at the far end are as sharp as the ones you
-     * can touch.
-     *
-     * It is here because a shallow frame is a legitimate look and the schema
-     * is the only place a look is allowed to live. Turn it up for a close shot
-     * on one banner; leave it alone for a hall.
-     */
     depth: z.ZodDefault<z.ZodNumber>;
-    /** How far the corners fall off. A frame with no edge reads as a viewport rather than a photograph. */
     vignette: z.ZodDefault<z.ZodNumber>;
-    /**
-     * Film grain.
-     *
-     * Worth more here than in most scenes: grain is the one texture shared
-     * between the render and the thing being rendered. Keep it under ~0.05 —
-     * past that it stops reading as stock and starts reading as noise.
-     */
     grain: z.ZodDefault<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    grain: number;
-    depth: number;
-    bloom: number;
-    threshold: number;
-    vignette: number;
-}, {
-    grain?: number | undefined;
-    depth?: number | undefined;
-    bloom?: number | undefined;
-    threshold?: number | undefined;
-    vignette?: number | undefined;
-}>;
+}, z.core.$strip>;
 declare const stageSchema: z.ZodObject<{
-    path: z.ZodDefault<z.ZodObject<{
-        points: z.ZodDefault<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">>;
+    path: z.ZodPrefault<z.ZodObject<{
+        points: z.ZodDefault<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
         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"]>>;
+    }, z.core.$strip>>;
+    shot: z.ZodPrefault<z.ZodObject<{
+        shot: z.ZodDefault<z.ZodEnum<{
+            low: "low";
+            follow: "follow";
+            lead: "lead";
+            wide: "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: "low" | "follow" | "lead" | "wide";
-        lookAhead: number;
-    }, {
-        height?: number | undefined;
-        offset?: number | undefined;
-        distance?: number | undefined;
-        shot?: "low" | "follow" | "lead" | "wide" | undefined;
-        lookAhead?: number | undefined;
-    }>>;
-    figure: z.ZodDefault<z.ZodObject<{
+    }, z.core.$strip>>;
+    figure: z.ZodPrefault<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>;
-        finish: z.ZodDefault<z.ZodEnum<["silhouette", "shaded"]>>;
-        gait: z.ZodDefault<z.ZodEnum<["auto", "walk", "run"]>>;
+        finish: z.ZodDefault<z.ZodEnum<{
+            silhouette: "silhouette";
+            shaded: "shaded";
+        }>>;
+        gait: z.ZodDefault<z.ZodEnum<{
+            auto: "auto";
+            walk: "walk";
+            run: "run";
+        }>>;
         model: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        height: number;
-        speed: number;
-        color: string;
-        stride: number;
-        swing: number;
-        finish: "silhouette" | "shaded";
-        gait: "auto" | "walk" | "run";
-        model?: string | undefined;
-    }, {
-        height?: number | undefined;
-        speed?: number | undefined;
-        color?: string | undefined;
-        stride?: number | undefined;
-        swing?: number | undefined;
-        finish?: "silhouette" | "shaded" | undefined;
-        gait?: "auto" | "walk" | "run" | undefined;
-        model?: string | undefined;
+    }, z.core.$strip>>;
+    lighting: z.ZodDefault<z.ZodEnum<{
+        studio: "studio";
+        window: "window";
+        leaves: "leaves";
+        goldenhour: "goldenhour";
+        noir: "noir";
+        nave: "nave";
+        raking: "raking";
+        lightbox: "lightbox";
     }>>;
-    /** Stage mode is built for `nave`; the others are all front-lit. */
-    lighting: z.ZodDefault<z.ZodEnum<["studio", "window", "leaves", "goldenhour", "noir", "nave", "raking", "lightbox"]>>;
-    /**
-     * The light, by hand: exposure, key, direction, height, ambient, studio,
-     * haze. Overrides on `lighting` rather than a replacement for it, so a
-     * shared stage carries the sliders that were moved and nothing else.
-     */
     light: z.ZodDefault<z.ZodObject<{
         exposure: z.ZodOptional<z.ZodNumber>;
-        film: z.ZodOptional<z.ZodEnum<["agx", "neutral", "filmic"]>>;
+        film: z.ZodOptional<z.ZodEnum<{
+            agx: "agx";
+            neutral: "neutral";
+            filmic: "filmic";
+        }>>;
         key: z.ZodOptional<z.ZodNumber>;
         color: z.ZodOptional<z.ZodString>;
         direction: z.ZodOptional<z.ZodNumber>;
@@ -152,481 +79,59 @@ declare const stageSchema: z.ZodObject<{
         ambient: z.ZodOptional<z.ZodNumber>;
         studio: z.ZodOptional<z.ZodNumber>;
         haze: z.ZodOptional<z.ZodNumber>;
-    }, "strip", z.ZodTypeAny, {
-        key?: number | undefined;
-        height?: number | undefined;
-        color?: string | undefined;
-        studio?: number | undefined;
-        exposure?: number | undefined;
-        film?: "agx" | "neutral" | "filmic" | undefined;
-        direction?: number | undefined;
-        ambient?: number | undefined;
-        haze?: number | undefined;
-    }, {
-        key?: number | undefined;
-        height?: number | undefined;
-        color?: string | undefined;
-        studio?: number | undefined;
-        exposure?: number | undefined;
-        film?: "agx" | "neutral" | "filmic" | undefined;
-        direction?: number | undefined;
-        ambient?: number | undefined;
-        haze?: number | undefined;
-    }>>;
-    /**
-     * OFF by default now.
-     *
-     * The figure existed to say "this is a room at gallery scale", which is a
-     * real job and the right instinct. A rendered human is simply the most
-     * expensive and least reliable way to do it: it is the one thing in frame
-     * every viewer appraises, and a low-polygon one reads as an asset-store
-     * placeholder no matter how good the hall around it is.
-     *
-     * `stageRoomSchema` does the job instead, with objects whose size the
-     * viewer already knows. And the deciding argument is that the stage is
-     * NAVIGABLE — drag, wheel, arrow-step, click-to-approach — so there is
-     * already a person in the hall and it is the viewer. A second one walking
-     * the same aisle on its own clock competes for that role.
-     *
-     * Still one flag away for anyone who wants it.
-     */
+    }, z.core.$strip>>;
     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. */
+    source: z.ZodPrefault<z.ZodObject<{
         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 is an OPENING, not a wall. At 5 the plane was 100 units across and
-         * filled the entire frame behind the colonnade, so the hall had no dark
-         * end to resolve toward and the whole picture sat at one value. Sized to
-         * roughly the height of the paper it stands behind, it reads as the way
-         * out — which is what the figure is walking toward.
-         */
         spread: z.ZodDefault<z.ZodNumber>;
-    }, "strip", z.ZodTypeAny, {
-        color: string;
-        spread: number;
-        enabled: boolean;
-        zenith: string;
-        beyond: number;
-        surround: boolean;
-    }, {
-        color?: string | undefined;
-        spread?: number | undefined;
-        enabled?: boolean | 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. */
+    }, z.core.$strip>>;
+    ground: z.ZodPrefault<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
-        /**
-         * Lifted off near-black (`#0e0b09`). A floor dark enough to disappear
-         * cannot show its own seams, and the seams are the scale cue — the hall
-         * kept its contrast against the source and gained a surface you can read
-         * the size of the room from.
-         */
         color: z.ZodDefault<z.ZodString>;
-        /**
-         * Width of one poured slab, in world units. 0 leaves the floor unseamed.
-         *
-         * The cheapest scale cue there is, and the one this scene most lacked. A
-         * concrete floor is poured in bays of roughly two and a half metres, and a
-         * viewer knows that without being told — so a floor with seams in it
-         * states the size of the room, while a floor without them is a gradient
-         * that happens to be horizontal.
-         */
         slab: z.ZodDefault<z.ZodNumber>;
-    }, "strip", z.ZodTypeAny, {
-        color: string;
-        enabled: boolean;
-        slab: number;
-    }, {
-        color?: string | undefined;
-        enabled?: boolean | undefined;
-        slab?: number | undefined;
-    }>>;
-    /** Ceiling and the architecture around the walk — see `stageRoomSchema`. */
-    room: z.ZodDefault<z.ZodObject<{
+    }, z.core.$strip>>;
+    room: z.ZodPrefault<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
-        /**
-         * Ceiling height, as a multiple of the paper's own height.
-         *
-         * Relative rather than absolute because the banners ARE the architecture
-         * here: a hall whose ceiling sits just above its hangings reads as built
-         * for them, and one at a fixed world height reads as whatever the paper
-         * happened to be scaled to that day.
-         */
         height: z.ZodDefault<z.ZodNumber>;
         color: z.ZodDefault<z.ZodString>;
-        /** Columns flanking the walk — see `stageColumnsSchema`. */
-        columns: z.ZodDefault<z.ZodObject<{
+        columns: z.ZodPrefault<z.ZodObject<{
             enabled: z.ZodDefault<z.ZodBoolean>;
-            /** Centres this far apart along the walk. Roughly a bay. */
             spacing: z.ZodDefault<z.ZodNumber>;
-            /** Shaft width. The number doing the work — a column is a known size. */
             width: z.ZodDefault<z.ZodNumber>;
-            /**
-             * How far off the walk's centreline each rank stands.
-             *
-             * Outside the banners, always. Columns are the room; the paper is the
-             * subject, and a column standing between the viewer and a banner has
-             * swapped the two over. Default clears a `colonnade`'s widest sensible
-             * aisle with room to spare.
-             */
             offset: z.ZodDefault<z.ZodNumber>;
-            /**
-             * Stone, and darker than paper on purpose.
-             *
-             * The brightest thing in any of these frames has to be the light, and the
-             * second brightest has to be the paper. A column the same value as a
-             * banner does not read as architecture behind the subject; it reads as
-             * more banners, and the eye stops being able to tell what the room is made
-             * of from what is hanging in it.
-             */
             color: z.ZodDefault<z.ZodString>;
-        }, "strip", z.ZodTypeAny, {
-            width: number;
-            offset: number;
-            color: string;
-            spacing: number;
-            enabled: boolean;
-        }, {
-            width?: number | undefined;
-            offset?: number | undefined;
-            color?: string | undefined;
-            spacing?: number | undefined;
-            enabled?: boolean | undefined;
-        }>>;
-        /** A wall at the end of the walk with the source in it. */
-        doorway: z.ZodDefault<z.ZodObject<{
+        }, z.core.$strip>>;
+        doorway: z.ZodPrefault<z.ZodObject<{
             enabled: z.ZodDefault<z.ZodBoolean>;
-            /** Opening size, as a multiple of the source's own. 1 frames it exactly. */
             opening: z.ZodDefault<z.ZodNumber>;
             color: z.ZodDefault<z.ZodString>;
-        }, "strip", z.ZodTypeAny, {
-            color: string;
-            enabled: boolean;
-            opening: number;
-        }, {
-            color?: string | undefined;
-            enabled?: boolean | undefined;
-            opening?: number | undefined;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    suspension: z.ZodPrefault<z.ZodObject<{
+        type: z.ZodDefault<z.ZodEnum<{
+            none: "none";
+            thread: "thread";
+            rod: "rod";
         }>>;
-    }, "strip", z.ZodTypeAny, {
-        height: number;
-        color: string;
-        enabled: boolean;
-        columns: {
-            width: number;
-            offset: number;
-            color: string;
-            spacing: number;
-            enabled: boolean;
-        };
-        doorway: {
-            color: string;
-            enabled: boolean;
-            opening: number;
-        };
-    }, {
-        height?: number | undefined;
-        color?: string | undefined;
-        enabled?: boolean | undefined;
-        columns?: {
-            width?: number | undefined;
-            offset?: number | undefined;
-            color?: string | undefined;
-            spacing?: number | undefined;
-            enabled?: boolean | undefined;
-        } | undefined;
-        doorway?: {
-            color?: string | undefined;
-            enabled?: boolean | undefined;
-            opening?: number | undefined;
-        } | undefined;
-    }>>;
-    /** Thread and clips — see `stageSuspensionSchema`. */
-    suspension: z.ZodDefault<z.ZodObject<{
-        /**
-         * What carries the load.
-         *
-         * `thread` is monofilament to the ceiling — one straight line per sheet.
-         * `rod` is a dowel across each sheet's top edge, hung from the ceiling at
-         * both ends, which is a different image entirely: a rank on threads reads
-         * as sheets floating in a row, and a rank on rods reads as sheets that
-         * were HUNG, by someone, on something. `none` is for a stage where the
-         * paper is meant to be impossible.
-         */
-        type: z.ZodDefault<z.ZodEnum<["none", "thread", "rod"]>>;
         color: z.ZodDefault<z.ZodString>;
-        /**
-         * What grips the sheet.
-         *
-         * A clip is wide and shallow — the bulldog clip of a gallery. A peg is
-         * narrow and deep, and grips DOWN the face of the sheet rather than
-         * across its edge: the domestic one, a line of paper on a washing line.
-         * They are told apart by silhouette at any distance, which is the only
-         * thing that survives being one instanced box at the top of an
-         * eight-metre banner.
-         *
-         * This replaced a `clips: boolean`. Two of the four pieces of hardware the
-         * plan named — pegs, and a rod — had no way to be asked for, and a boolean
-         * cannot grow a third answer.
-         */
-        hardware: z.ZodDefault<z.ZodEnum<["none", "clip", "peg"]>>;
-    }, "strip", z.ZodTypeAny, {
-        type: "none" | "thread" | "rod";
-        color: string;
-        hardware: "none" | "clip" | "peg";
-    }, {
-        type?: "none" | "thread" | "rod" | undefined;
-        color?: string | undefined;
-        hardware?: "none" | "clip" | "peg" | undefined;
-    }>>;
-    /**
-     * The print — bloom, vignette, grain.
-     *
-     * Needs `@react-three/postprocessing` and `postprocessing`. They are
-     * declared OPTIONAL peers, which means `<Paper>` never pulls them in and a
-     * bundle that only imports `<Paper>` never contains them — not that a
-     * stage renders without them. A bundler asked to resolve `<PaperStage>`
-     * without them installed fails at build time, and that is the intended
-     * behaviour: a stage silently losing its grade would be worse than a
-     * missing-module error that names the package.
-     */
-    grade: z.ZodDefault<z.ZodObject<{
-        /**
-         * How far light bleeds past what is emitting it.
-         *
-         * This is the one that matters most in a backlit hall, because the source
-         * plane is drawn with `toneMapped: false` — it is light, not an object, so
-         * no tone curve ever rolls it off. Bloom is the only thing that gives it
-         * an edge that behaves like light instead of like a lit rectangle.
-         */
+        hardware: z.ZodDefault<z.ZodEnum<{
+            none: "none";
+            clip: "clip";
+            peg: "peg";
+        }>>;
+    }, z.core.$strip>>;
+    grade: z.ZodPrefault<z.ZodObject<{
         bloom: z.ZodDefault<z.ZodNumber>;
-        /**
-         * How bright a pixel has to be before it blooms at all, in LINEAR light.
-         *
-         * Above 1.0 is not only legal, it is the useful range — and that is the
-         * whole reason the bound is 4 rather than 1. Bloom reads the scene before
-         * the tone curve, while values are still unbounded, so "1.0" means "as
-         * bright as white" rather than "as bright as the brightest pixel on
-         * screen". Lit near-white paper sits close to 1.0 all by itself; the
-         * source burns at `SOURCE_INTENSITY`, several times that. A threshold
-         * under 1 therefore blooms the PAPER, which fogs the hall and costs the
-         * sheets their edges — the exact failure this default is set to avoid.
-         */
         threshold: z.ZodDefault<z.ZodNumber>;
-        /**
-         * Depth falloff — how much the near and far ends of the walk go soft.
-         *
-         * **Defaults to 0, and that is a considered default rather than a stub.**
-         * Depth in this scene is already staged by haze, which is how a real hall
-         * does it and which costs one fragment instruction; optical blur is a
-         * second full-screen pass with a circle-of-confusion buffer behind it, and
-         * it is the effect most likely to read as a video game rather than as a
-         * photograph. Every paper installation worth copying is shot deep — an
-         * f/11 room where the sheets at the far end are as sharp as the ones you
-         * can touch.
-         *
-         * It is here because a shallow frame is a legitimate look and the schema
-         * is the only place a look is allowed to live. Turn it up for a close shot
-         * on one banner; leave it alone for a hall.
-         */
         depth: z.ZodDefault<z.ZodNumber>;
-        /** How far the corners fall off. A frame with no edge reads as a viewport rather than a photograph. */
         vignette: z.ZodDefault<z.ZodNumber>;
-        /**
-         * Film grain.
-         *
-         * Worth more here than in most scenes: grain is the one texture shared
-         * between the render and the thing being rendered. Keep it under ~0.05 —
-         * past that it stops reading as stock and starts reading as noise.
-         */
         grain: z.ZodDefault<z.ZodNumber>;
-    }, "strip", z.ZodTypeAny, {
-        grain: number;
-        depth: number;
-        bloom: number;
-        threshold: number;
-        vignette: number;
-    }, {
-        grain?: number | undefined;
-        depth?: number | undefined;
-        bloom?: number | undefined;
-        threshold?: number | undefined;
-        vignette?: number | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    path: {
-        points: [number, number][];
-        closed: boolean;
-    };
-    lighting: "studio" | "window" | "leaves" | "goldenhour" | "noir" | "nave" | "raking" | "lightbox";
-    light: {
-        key?: number | undefined;
-        height?: number | undefined;
-        color?: string | undefined;
-        studio?: number | undefined;
-        exposure?: number | undefined;
-        film?: "agx" | "neutral" | "filmic" | undefined;
-        direction?: number | undefined;
-        ambient?: number | undefined;
-        haze?: number | undefined;
-    };
-    figure: {
-        height: number;
-        speed: number;
-        color: string;
-        stride: number;
-        swing: number;
-        finish: "silhouette" | "shaded";
-        gait: "auto" | "walk" | "run";
-        model?: string | undefined;
-    };
-    source: {
-        color: string;
-        spread: number;
-        enabled: boolean;
-        zenith: string;
-        beyond: number;
-        surround: boolean;
-    };
-    shot: {
-        height: number;
-        offset: number;
-        distance: number;
-        shot: "low" | "follow" | "lead" | "wide";
-        lookAhead: number;
-    };
-    ground: {
-        color: string;
-        enabled: boolean;
-        slab: number;
-    };
-    showFigure: boolean;
-    room: {
-        height: number;
-        color: string;
-        enabled: boolean;
-        columns: {
-            width: number;
-            offset: number;
-            color: string;
-            spacing: number;
-            enabled: boolean;
-        };
-        doorway: {
-            color: string;
-            enabled: boolean;
-            opening: number;
-        };
-    };
-    suspension: {
-        type: "none" | "thread" | "rod";
-        color: string;
-        hardware: "none" | "clip" | "peg";
-    };
-    grade: {
-        grain: number;
-        depth: number;
-        bloom: number;
-        threshold: number;
-        vignette: number;
-    };
-}, {
-    path?: {
-        points?: [number, number][] | undefined;
-        closed?: boolean | undefined;
-    } | undefined;
-    lighting?: "studio" | "window" | "leaves" | "goldenhour" | "noir" | "nave" | "raking" | "lightbox" | undefined;
-    light?: {
-        key?: number | undefined;
-        height?: number | undefined;
-        color?: string | undefined;
-        studio?: number | undefined;
-        exposure?: number | undefined;
-        film?: "agx" | "neutral" | "filmic" | undefined;
-        direction?: number | undefined;
-        ambient?: number | undefined;
-        haze?: number | undefined;
-    } | undefined;
-    figure?: {
-        height?: number | undefined;
-        speed?: number | undefined;
-        color?: string | undefined;
-        stride?: number | undefined;
-        swing?: number | undefined;
-        finish?: "silhouette" | "shaded" | undefined;
-        gait?: "auto" | "walk" | "run" | undefined;
-        model?: string | undefined;
-    } | undefined;
-    source?: {
-        color?: string | undefined;
-        spread?: number | undefined;
-        enabled?: boolean | undefined;
-        zenith?: string | undefined;
-        beyond?: number | undefined;
-        surround?: boolean | undefined;
-    } | undefined;
-    shot?: {
-        height?: number | undefined;
-        offset?: number | undefined;
-        distance?: number | undefined;
-        shot?: "low" | "follow" | "lead" | "wide" | undefined;
-        lookAhead?: number | undefined;
-    } | undefined;
-    ground?: {
-        color?: string | undefined;
-        enabled?: boolean | undefined;
-        slab?: number | undefined;
-    } | undefined;
-    showFigure?: boolean | undefined;
-    room?: {
-        height?: number | undefined;
-        color?: string | undefined;
-        enabled?: boolean | undefined;
-        columns?: {
-            width?: number | undefined;
-            offset?: number | undefined;
-            color?: string | undefined;
-            spacing?: number | undefined;
-            enabled?: boolean | undefined;
-        } | undefined;
-        doorway?: {
-            color?: string | undefined;
-            enabled?: boolean | undefined;
-            opening?: number | undefined;
-        } | undefined;
-    } | undefined;
-    suspension?: {
-        type?: "none" | "thread" | "rod" | undefined;
-        color?: string | undefined;
-        hardware?: "none" | "clip" | "peg" | undefined;
-    } | undefined;
-    grade?: {
-        grain?: number | undefined;
-        depth?: number | undefined;
-        bloom?: number | undefined;
-        threshold?: number | undefined;
-        vignette?: number | undefined;
-    } | undefined;
-}>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 type StageConfig = z.infer<typeof stageSchema>;
 type StageConfigInput = z.input<typeof stageSchema>;
 type StageGradeConfig = z.infer<typeof stageGradeSchema>;
@@ -650,51 +155,14 @@ type StageGradeConfig = z.infer<typeof stageGradeSchema>;
  * Pure math lives here so it tests in node; the listeners are in `useWalk`.
  */
 declare const stageMotionSchema: z.ZodObject<{
-    /**
-     * Who drives the walk. Same three names as a field's, and they mean the
-     * same things — a stage and a field are the same contract seen from two
-     * distances.
-     *
-     * - `drag` — the viewer. Pointer, wheel, arrow keys, or a click on a paper.
-     *   It DRIFTS on the clock until the first time they touch it, and then it
-     *   is theirs for good. That is one behaviour rather than two drivers, and
-     *   it is the default because the alternatives are each half wrong: a stage
-     *   that only autoplays cannot be touched, and one that only waits opens as
-     *   a still photograph of itself.
-     * - `autoplay` — the clock, and only the clock. It never hands over.
-     * - `none` — nothing. The walk stands wherever it was left.
-     *
-     * An explicit `progress` prop outranks all three: a stage bound to page
-     * scroll is a controlled component, and a driver fighting the page for the
-     * same number is the bug you would spend an afternoon on.
-     */
-    driver: z.ZodDefault<z.ZodEnum<["autoplay", "drag", "none"]>>;
-    /** Multiplier on the pace: the figure's walking speed for `autoplay`, the hand for `drag`. */
+    driver: z.ZodDefault<z.ZodEnum<{
+        none: "none";
+        drag: "drag";
+        autoplay: "autoplay";
+    }>>;
     speed: z.ZodDefault<z.ZodNumber>;
-    /**
-     * Whether the walk takes the WHEEL and the TOUCH away from the page.
-     *
-     * True for a stage that fills the screen — it is the page, so there is
-     * nothing to take it from. False for one sitting in a column of prose,
-     * where capturing them means a reader who scrolls past it has their scroll
-     * eaten and a reader on a phone has their finger trapped. Dragging with a
-     * mouse and stepping with the arrow keys work either way, because neither
-     * is a gesture the page also wants.
-     *
-     * Even when captured, the wheel is handed BACK at the ends of an open
-     * walk: scrolling past the last banner should carry on down the page
-     * rather than press silently into a wall.
-     */
     capture: z.ZodDefault<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    speed: number;
-    driver: "none" | "autoplay" | "drag";
-    capture: boolean;
-}, {
-    speed?: number | undefined;
-    driver?: "none" | "autoplay" | "drag" | undefined;
-    capture?: boolean | undefined;
-}>;
+}, z.core.$strip>;
 type StageMotion = z.infer<typeof stageMotionSchema>;
 type StageMotionInput = z.input<typeof stageMotionSchema>;
 
@@ -870,20 +338,9 @@ declare function listStagePresets(): string[];
 /** 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. */
+    points: z.ZodDefault<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
     closed: z.ZodDefault<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    points: [number, number][];
-    closed: boolean;
-}, {
-    points?: [number, number][] | undefined;
-    closed?: boolean | undefined;
-}>;
+}, z.core.$strip>;
 type WalkPathOptions = z.infer<typeof walkPathSchema>;
 interface WalkPath {
     /** Total arc length in world units. */
@@ -922,32 +379,17 @@ declare function getWalk(name: WalkName): WalkPathOptions;
 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.
-     */
+    shot: z.ZodDefault<z.ZodEnum<{
+        low: "low";
+        follow: "follow";
+        lead: "lead";
+        wide: "wide";
+    }>>;
     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: "low" | "follow" | "lead" | "wide";
-    lookAhead: number;
-}, {
-    height?: number | undefined;
-    offset?: number | undefined;
-    distance?: number | undefined;
-    shot?: "low" | "follow" | "lead" | "wide" | undefined;
-    lookAhead?: number | undefined;
-}>;
+}, z.core.$strip>;
 type ShotOptions = z.infer<typeof shotSchema>;
 interface StageShot {
     position: [x: number, y: number, z: number];