Skip to content

Production-ready animations, transitions, backgrounds, and scenes for Remotion

feat: bump remotion version. generate RSP artifacts (#262)

KapishDimae5dbeba7e57f
diff --git a/components/docs/examples/stage-example.test.ts b/components/docs/examples/stage-example.test.ts
new file mode 100644
index 00000000..b106e492
--- /dev/null
+++ b/components/docs/examples/stage-example.test.ts
@@ -0,0 +1,62 @@
+import { describe, expect, it } from "bun:test";
+import {
+ STAGE_PRESETS,
+ stageExampleCode,
+} from "@/components/docs/examples/stage-example";
+import { resolveStagePose } from "@/registry/remocn/stage";
+import { stageConfig } from "@/registry/remocn/stage/config";
+
+const moves = STAGE_PRESETS["smooth-descent"];
+const yAt = (frame: number) => resolveStagePose(frame, moves).y;
+
+describe("smooth-descent Stage preset", () => {
+ it("moves strictly downward for the full preview without holds", () => {
+ for (let frame = 0; frame < 299; frame++) {
+ expect(yAt(frame + 1)).toBeGreaterThan(yAt(frame));
+ }
+ });
+
+ it("keeps velocity continuous around both ramp boundaries", () => {
+ const beforeAccelerationEnd = yAt(30) - yAt(29);
+ const afterAccelerationEnd = yAt(31) - yAt(30);
+ const beforeDecelerationStart = yAt(269) - yAt(268);
+ const afterDecelerationStart = yAt(270) - yAt(269);
+
+ expect(beforeAccelerationEnd).toBeCloseTo(afterAccelerationEnd, 3);
+ expect(beforeDecelerationStart).toBeCloseTo(afterDecelerationStart, 3);
+ });
+
+ it("prints editable easing expressions in the generated snippet", () => {
+ const snippet = stageExampleCode({ preset: "smooth-descent" });
+ expect(snippet).toContain("Easing.in(Easing.cubic)");
+ expect(snippet).toContain("Easing.linear");
+ expect(snippet).toContain("Easing.out(Easing.cubic)");
+ expect(snippet).not.toContain("function");
+ });
+});
+
+describe("Stage extreme depth controls", () => {
+ const expectNumberRange = (
+ name: "rotateX" | "rotateY" | "perspective" | "scale",
+ min: number,
+ max: number,
+ step: number,
+ defaultValue: number,
+ ) => {
+ const control = stageConfig.controls[name];
+ if (control.type !== "number") {
+ throw new Error(`${name} must be a number control`);
+ }
+ expect(control.min).toBe(min);
+ expect(control.max).toBe(max);
+ expect(control.step).toBe(step);
+ expect(control.default).toBe(defaultValue);
+ };
+
+ it("exposes experimental rotation, perspective, and scale ranges", () => {
+ expectNumberRange("rotateX", -180, 180, 1, 14);
+ expectNumberRange("rotateY", -180, 180, 1, -20);
+ expectNumberRange("perspective", 50, 5000, 25, 900);
+ expectNumberRange("scale", 0.1, 3, 0.01, 0.86);
+ });
+});
diff --git a/components/docs/examples/stage-example.tsx b/components/docs/examples/stage-example.tsx
new file mode 100644
index 00000000..7ed11aa0
--- /dev/null
+++ b/components/docs/examples/stage-example.tsx
@@ -0,0 +1,144 @@
+"use client";
+
+import { Easing, type EasingFunction, Img, staticFile } from "remotion";
+import { Stage, type StageKey, type StageProps } from "@/registry/remocn/stage";
+
+export type StagePreset =
+ | "smooth-descent"
+ | "site-tour"
+ | "hero-push"
+ | "section-hop";
+
+const SMOOTH_RAMP_IN = Easing.in(Easing.cubic);
+const SMOOTH_RAMP_OUT = Easing.out(Easing.cubic);
+
+export const STAGE_PRESETS: Record<StagePreset, StageKey[]> = {
+ "smooth-descent": [
+ { at: 0, x: 0.5, y: 0.035, zoom: 1.04 },
+ {
+ at: 30,
+ x: 0.5,
+ y: 0.07052,
+ zoom: 1.04,
+ easing: SMOOTH_RAMP_IN,
+ },
+ { at: 269, x: 0.5, y: 0.91948, zoom: 1.04, easing: Easing.linear },
+ {
+ at: 299,
+ x: 0.5,
+ y: 0.955,
+ zoom: 1.04,
+ easing: SMOOTH_RAMP_OUT,
+ },
+ ],
+ "site-tour": [
+ { at: 0, x: 0.48, y: 0.035, zoom: 1.04, rotate: -0.35 },
+ { at: 38, x: 0.48, y: 0.035, zoom: 1.04, rotate: -0.35 },
+ { at: 88, x: 0.53, y: 0.28, zoom: 1.12, rotate: 0.15 },
+ { at: 116, x: 0.53, y: 0.28, zoom: 1.12, rotate: 0.15 },
+ { at: 174, x: 0.47, y: 0.58, zoom: 1.08, rotate: -0.2 },
+ { at: 204, x: 0.47, y: 0.58, zoom: 1.08, rotate: -0.2 },
+ { at: 268, x: 0.52, y: 0.955, zoom: 1.02, rotate: 0.1 },
+ { at: 299, x: 0.52, y: 0.955, zoom: 1.02, rotate: 0.1 },
+ ],
+ "hero-push": [
+ { at: 0, x: 0.5, y: 0.045, zoom: 0.94 },
+ { at: 90, x: 0.5, y: 0.045, zoom: 1.2 },
+ { at: 160, x: 0.5, y: 0.045, zoom: 1.2 },
+ { at: 299, x: 0.5, y: 0.2, zoom: 1.08 },
+ ],
+ "section-hop": [
+ { at: 0, x: 0.5, y: 0.04, zoom: 1.1 },
+ { at: 52, x: 0.5, y: 0.04, zoom: 1.1 },
+ { at: 92, x: 0.46, y: 0.38, zoom: 1.18, rotate: -0.3 },
+ { at: 142, x: 0.46, y: 0.38, zoom: 1.18, rotate: -0.3 },
+ { at: 184, x: 0.54, y: 0.72, zoom: 1.14, rotate: 0.25 },
+ { at: 234, x: 0.54, y: 0.72, zoom: 1.14, rotate: 0.25 },
+ { at: 278, x: 0.5, y: 0.96, zoom: 1.06 },
+ { at: 299, x: 0.5, y: 0.96, zoom: 1.06 },
+ ],
+};
+
+export interface StageExampleProps
+ extends Omit<StageProps, "children" | "contentSize" | "moves"> {
+ preset?: StagePreset;
+}
+
+export function StageExampleScene({
+ preset = "smooth-descent",
+ shake = 0,
+ seed = "remocn-smooth-descent",
+ ...stageProps
+}: StageExampleProps) {
+ return (
+ <Stage
+ {...stageProps}
+ contentSize={{ width: 1265, height: 10022 }}
+ moves={STAGE_PRESETS[preset] ?? STAGE_PRESETS["smooth-descent"]}
+ shake={shake}
+ seed={seed}
+ >
+ <Img
+ src={staticFile("stage-remocn-components.webp")}
+ style={{ display: "block", width: "100%", height: "100%" }}
+ />
+ </Stage>
+ );
+}
+
+const EASING_SOURCES = new Map<EasingFunction, string>([
+ [SMOOTH_RAMP_IN, "Easing.in(Easing.cubic)"],
+ [Easing.linear, "Easing.linear"],
+ [SMOOTH_RAMP_OUT, "Easing.out(Easing.cubic)"],
+]);
+
+const keyToSource = (key: StageKey) => {
+ const fields = Object.entries(key).map(([name, value]) => {
+ if (name === "easing" && typeof value === "function") {
+ return `${name}: ${EASING_SOURCES.get(value) ?? "Easing.linear"}`;
+ }
+ return `${name}: ${value}`;
+ });
+ return `{ ${fields.join(", ")} }`;
+};
+
+export const stageExampleCode = (values: Record<string, unknown>): string => {
+ const preset = (values.preset as StagePreset) ?? "smooth-descent";
+ const selectedMoves =
+ STAGE_PRESETS[preset] ?? STAGE_PRESETS["smooth-descent"];
+ const moves = selectedMoves
+ .map((key) => ` ${keyToSource(key)},`)
+ .join("\n");
+ const remotionImports = selectedMoves.some((key) => key.easing)
+ ? "Easing, Img, staticFile"
+ : "Img, staticFile";
+ const backdrop =
+ (values.backdrop as string) ??
+ "linear-gradient(145deg, #17181d 0%, #09090b 72%)";
+
+ return `import { ${remotionImports} } from "remotion";
+import { Stage } from "@/components/remocn/stage";
+
+<Stage
+ contentSize={{ width: 1265, height: 10022 }}
+ moves={[
+${moves}
+ ]}
+ shake={${(values.shake as number) ?? 0}}
+ seed={${JSON.stringify((values.seed as string) ?? "remocn-smooth-descent")}}
+ backdrop={${JSON.stringify(backdrop)}}
+ rotateX={${(values.rotateX as number) ?? 14}}
+ rotateY={${(values.rotateY as number) ?? -20}}
+ perspective={${(values.perspective as number) ?? 900}}
+ scale={${(values.scale as number) ?? 0.86}}
+ radius={${(values.radius as number) ?? 1.4}}
+ reflection={${(values.reflection as number) ?? 0.24}}
+ shadow={${(values.shadow as number) ?? 0.7}}
+ light={${(values.light as number) ?? 0.55}}
+>
+ <Img
+ src={staticFile("your-long-page.png")}
+ style={{ width: "100%", height: "100%" }}
+ />
+</Stage>`;
+};
diff --git a/content/changelog/2026-08-21-stage.mdx b/content/changelog/2026-08-21-stage.mdx
new file mode 100644
index 00000000..33b77490
--- /dev/null
+++ b/content/changelog/2026-08-21-stage.mdx
@@ -0,0 +1,12 @@
+---
+title: Studio staging and operator camera moves
+date: 2026-08-21
+---
+
+Product demos can now stage and direct one continuous surface with a single component. Stage gives screenshots, recordings, long pages, and live React scenes a perspective studio treatment, then moves an integrated operator camera across them with normalized timeline targets.
+
+<ChangelogPreview name="stage" />
+
+### New component
+
+- [Stage](/docs/layout/stage) — places any surface on a stronger perspective plane and directs the camera with normalized `x`/`y` targets, per-arrival easing, holds, endpoint clamps, zoom, roll, and deterministic handheld shake. Explicit `contentSize` lets the camera travel from top to bottom of a page much taller than the video frame.
diff --git a/content/docs/layout/index.mdx b/content/docs/layout/index.mdx
index a37c60c6..0fe5ea4e 100644
--- a/content/docs/layout/index.mdx
+++ b/content/docs/layout/index.mdx
@@ -13,5 +13,23 @@ Layout primitives that handle full-frame fills, content framing, and padding —
status: "stable",
href: "/docs/layout/backdrop",
},
+ {
+ name: "Drift",
+ description: "A restrained linear camera creep that keeps a static scene alive without becoming the subject",
+ status: "stable",
+ href: "/docs/layout/drift",
+ },
+ {
+ name: "Chat to Preview Layout",
+ description: "A two-column handoff where an agent conversation yields the frame to the product it created",
+ status: "stable",
+ href: "/docs/layout/chat-to-preview-layout",
+ },
+ {
+ name: "Stage",
+ description: "A perspective studio plane with an integrated operator camera that can travel across long screenshots and live scenes",
+ status: "stable",
+ href: "/docs/layout/stage",
+ },
]}
/>
diff --git a/content/docs/layout/meta.json b/content/docs/layout/meta.json
index bddbbc1f..810410fb 100644
--- a/content/docs/layout/meta.json
+++ b/content/docs/layout/meta.json
@@ -1,5 +1,5 @@
{
"title": "Layout",
"defaultOpen": false,
- "pages": ["index", "backdrop", "drift", "chat-to-preview-layout"]
+ "pages": ["index", "backdrop", "drift", "chat-to-preview-layout", "stage"]
}
diff --git a/content/docs/layout/stage.mdx b/content/docs/layout/stage.mdx
new file mode 100644
index 00000000..aed4a5e0
--- /dev/null
+++ b/content/docs/layout/stage.mdx
@@ -0,0 +1,175 @@
+---
+title: Stage
+description: Put a screenshot, recording, or long page on a perspective studio plane and direct the camera across it with timeline keyframes
+component: stage
+vibe: premium
+length: sustained
+useWhen:
+ - "A product screen, website, image, or live React scene should read as a photographed object rather than a flat full-frame capture."
+ - "The camera needs to travel across one continuous surface, including a page much taller than the composition."
+ - "You want studio perspective, lighting, camera keyframes, holds, easing, and deterministic handheld motion in one wrapper."
+avoidWhen:
+ - "You only need a full-frame fill or rounded inset with no 3D presentation — use `backdrop`."
+ - "You are moving between two scenes — use a transition such as `whip-pan` or `focus-pull`."
+ - "Elements inside the subject need independent depth or parallax — Stage treats all children as one flat plane."
+---
+
+<ComponentPreview name="stage" />
+
+## Installation
+
+<InstallBlock name="stage" />
+
+## Usage
+
+`Stage` is both the set and the operator camera. It places one child surface in a perspective studio, then keeps a normalized point on that surface at the center of the shot as `moves` change over time.
+
+```tsx
+import { Img, staticFile } from "remotion";
+import { Stage } from "@/components/remocn/stage";
+
+export const WebsiteTour = () => (
+ <Stage
+ contentSize={{ width: 1440, height: 9800 }}
+ moves={[
+ { at: 0, x: 0.5, y: 0.04, zoom: 1.02 },
+ { at: 45, x: 0.5, y: 0.04, zoom: 1.02 }, // hold
+ { at: 130, x: 0.48, y: 0.5, zoom: 1.12 },
+ { at: 220, x: 0.52, y: 0.96, zoom: 1.04 },
+ ]}
+ shake={0.12}
+ >
+ <Img
+ src={staticFile("long-page.png")}
+ style={{ width: "100%", height: "100%" }}
+ />
+ </Stage>
+);
+```
+
+The child can be an image, video, live React component, or whole Remotion scene. Descendants keep animating, but they share one 3D plane. The plane settles into the studio over the first 24 frames; the camera path can continue for as long as the Sequence does.
+
+## Long surfaces and camera targets
+
+`contentSize` declares the surface's intrinsic aspect ratio. Stage fits its width to the composition and allows the resulting height to extend far beyond the frame. It does not fake webpage scrolling: the long surface stays intact while the camera flies above it.
+
+`x` and `y` are normalized target points on that surface:
+
+- `x: 0`, `y: 0` targets the top-left corner.
+- `x: 0.5`, `y: 0.5` targets the center.
+- `x: 1`, `y: 1` targets the bottom-right corner.
+
+Stage clamps `x` and `y` to `0–1`. Because the current target is held at composition center, the coordinates stay stable when zoom and perspective change. An empty `moves` array leaves the surface centered and static.
+
+<Note title="Give the surface real dimensions">
+ Stage cannot infer the intended height of an absolutely positioned child. Pass `contentSize` for screenshots and long layouts, and make the child fill the resulting plane.
+</Note>
+
+## Segment easing and holds
+
+Each destination key can choose the easing used to arrive at it. The default is the project `EXPO` easing. Repeat an identical pose at a later frame to create a hold.
+
+```tsx
+import { Easing } from "remotion";
+
+<Stage
+ contentSize={{ width: 1440, height: 9800 }}
+ moves={[
+ { at: 0, x: 0.5, y: 0.05, zoom: 1 },
+ {
+ at: 60,
+ x: 0.54,
+ y: 0.34,
+ zoom: 1.16,
+ easing: Easing.out(Easing.cubic),
+ },
+ { at: 100, x: 0.54, y: 0.34, zoom: 1.16 },
+ { at: 170, x: 0.48, y: 0.72, zoom: 1.08 },
+ ]}
+>
+ <YourLongSurface />
+</Stage>
+```
+
+Before the first key, Stage holds the first pose; after the last key, it holds the final pose. Keys are sorted by `at`, and when keys share a frame, the last supplied key wins. Missing pose fields use neutral values (`x: 0.5`, `y: 0.5`, `zoom: 1`, `rotate: 0`) instead of inheriting from the previous key.
+
+## Direct the studio
+
+The studio props remain independent from the camera path:
+
+```tsx
+<Stage
+ contentSize={{ width: 1440, height: 9800 }}
+ moves={moves}
+ backdrop="radial-gradient(circle at 35% 10%, #403a72, #111117 58%, #08080b)"
+ rotateX={14}
+ rotateY={-20}
+ perspective={900}
+ scale={0.86}
+ radius={1.8}
+ reflection={0.2}
+ shadow={0.8}
+ light={0.65}
+>
+ <YourProductScene />
+</Stage>
+```
+
+Lower `perspective` values exaggerate depth. `reflection`, `shadow`, and `light` clamp to `0–1`. `radius` is a percentage of the composition width, so the corner treatment scales across render sizes.
+
+The customizer deliberately exposes experimental ranges: both rotations reach `-180–180°`, perspective reaches down to `50px`, and scale reaches `0.1–3`. Rotations beyond 90 degrees reveal the browser's naturally mirrored back face instead of making the surface disappear. Very low perspective and high scale can clip most of the surface; that is intentional for extreme close-ups and abstract depth treatments.
+
+## Deterministic handheld movement
+
+`shake` adds low-frequency operator movement and smoothly interpolated seeded noise. The same `seed`, frame, and strength always produce the same render.
+
+```tsx
+<Stage moves={moves} shake={0.18} seed="homepage-take-03">
+ <YourScene />
+</Stage>
+```
+
+Use `0.08–0.2` for a restrained human operator. `shake` clamps to `0–1`.
+
+## Text and source bleed
+
+Fractional zoom continuously resamples glyphs. If small live text trembles, put `willChange: "transform"` on each text container, not every word. Keep 1px borders outside those promoted layers so borders stay sharp.
+
+The outer frame clips the surface. Targets near an edge, zoom below `1`, and strong perspective can reveal the backdrop around it. Leave breathing room in the source or keep edge targets slightly inset, such as `y: 0.04` and `y: 0.96`.
+
+For an optical finish, wrap Stage in [`CameraLens`](/docs/filters/components/camera-lens). Stage supplies the physical set and operator path; CameraLens supplies bloom, softness, chromatic aberration, and vignette.
+
+## Props
+
+<PropsTable
+ rows={[
+ { name: "children", type: "ReactNode", description: "The image, video, component, or scene rendered as one studio plane." },
+ { name: "contentSize", type: "{ width: number; height: number }", default: "composition size", description: "Intrinsic surface dimensions used to preserve its aspect ratio, including long pages." },
+ { name: "moves", type: "StageKey[]", default: "[]", description: "Normalized camera targets keyed by Sequence-local frame." },
+ { name: "shake", type: "number", default: "0", description: "Deterministic handheld strength, clamped from 0 to 1." },
+ { name: "seed", type: "string", default: '"remocn-stage"', description: "Seed used by the handheld noise field." },
+ { name: "backdrop", type: "string", default: '"linear-gradient(145deg, #17181d 0%, #09090b 72%)"', description: "CSS background used for the full-frame studio." },
+ { name: "rotateX", type: "number", default: "14", description: "X-axis tilt of the surface in degrees." },
+ { name: "rotateY", type: "number", default: "-20", description: "Y-axis tilt of the surface in degrees." },
+ { name: "perspective", type: "number", default: "900", description: "CSS perspective distance in pixels. Lower values exaggerate depth." },
+ { name: "scale", type: "number", default: "0.86", description: "Base scale of the studio plane before keyframe zoom." },
+ { name: "radius", type: "number", default: "1.4", description: "Surface corner radius as a percentage of composition width." },
+ { name: "reflection", type: "number", default: "0.24", description: "Floor reflection strength from 0 to 1." },
+ { name: "shadow", type: "number", default: "0.7", description: "Contact-shadow strength from 0 to 1." },
+ { name: "light", type: "number", default: "0.55", description: "Directional studio-light strength from 0 to 1." },
+ { name: "className", type: "string", default: "undefined", description: "Additional class names applied to the full-frame wrapper." },
+ ]}
+/>
+
+### StageKey
+
+<PropsTable
+ rows={[
+ { name: "at", type: "number", description: "Required frame from the start of the current Sequence." },
+ { name: "x", type: "number", default: "0.5", description: "Horizontal target on the surface from left (0) to right (1)." },
+ { name: "y", type: "number", default: "0.5", description: "Vertical target on the surface from top (0) to bottom (1)." },
+ { name: "zoom", type: "number", default: "1", description: "Zoom multiplier around the current target." },
+ { name: "rotate", type: "number", default: "0", description: "Camera roll in degrees; the surface rotates in the opposite direction." },
+ { name: "easing", type: "EasingFunction", default: "EXPO", description: "Easing used by the segment arriving at this key." },
+ ]}
+/>
diff --git a/docs/plans/2026-08-21-stage-camera-move-design.md b/docs/plans/2026-08-21-stage-camera-move-design.md
new file mode 100644
index 00000000..02259acc
--- /dev/null
+++ b/docs/plans/2026-08-21-stage-camera-move-design.md
@@ -0,0 +1,98 @@
+# Stage with an integrated camera
+
+## Goal
+
+Build one installable `Stage` component that turns a screenshot, recording, or live React scene into a studio-shot video. The studio presentation and operator movement are one experience: a static stage without a usable camera path is not the product promised by the ui.camera reference.
+
+`camera-move` is not a registry item. Its keyframe math, deterministic handheld motion, demos, documentation, and tests belong to `stage`.
+
+## Chosen approach
+
+`Stage` renders one explicit content plane and moves a camera target across it. The plane may be much taller than the composition. Camera keys address normalized points on that plane: `y: 0` is its top and `y: 1` is its bottom. This keeps a storyboard independent of the screenshot's pixel dimensions and makes long-site tours readable.
+
+Alternatives considered:
+
+- `scrollFrom` and `scrollTo` would be simpler but could not express holds, returns, or differently eased sections.
+- A nested `Stage.Camera` API would preserve separate concepts but would recreate the split the unified component is meant to remove.
+- Scrolling content inside a fixed tilted viewport would be easier to implement, but it reads as webpage scrolling rather than a camera flying over a stationary product surface.
+
+## Public API
+
+```ts
+interface StageKey {
+ at: number;
+ x?: number;
+ y?: number;
+ zoom?: number;
+ rotate?: number;
+ easing?: EasingFunction;
+}
+
+interface StageProps {
+ children: ReactNode;
+ contentSize?: { width: number; height: number };
+ moves?: StageKey[];
+ shake?: number;
+ seed?: string;
+
+ backdrop?: string;
+ rotateX?: number;
+ rotateY?: number;
+ perspective?: number;
+ scale?: number;
+ radius?: number;
+ reflection?: number;
+ shadow?: number;
+ light?: number;
+ className?: string;
+}
+```
+
+`contentSize` is the plane's logical aspect ratio. The plane is fitted to the stage width and its full height is derived from that ratio. When omitted, it defaults to the current composition dimensions.
+
+`x` and `y` select the point on the plane held at the composition centre. Both default to `0.5` and clamp to `0..1`. `zoom` defaults to `1`; `rotate` is camera roll and defaults to `0`. The destination key's `easing` controls arrival into that key and defaults to `EXPO` from `scene-motion`.
+
+`moves={[]}` produces a static centred shot. Keys are sorted by `at`, duplicate frames use the last supplied key, endpoints clamp, and identical adjacent poses create a hold. `shake` clamps to `0..1` and combines seeded smooth noise with low-frequency sine motion. It never calls `Math.random()`.
+
+## Geometry and layers
+
+The outer stage is the camera viewport and clips overflow. A content plane is centred in composition coordinates, scaled to a useful studio width, and given an explicit pixel height from `contentSize`. For every frame, Stage calculates the target point on that plane, moves it to the composition centre, and makes it the transform origin. Zoom, camera roll, and the stronger studio perspective therefore happen around the current target rather than around the centre of a several-thousand-pixel element.
+
+The default pose is deliberately stronger than the first implementation: approximately `rotateX: 14`, `rotateY: -20`, `perspective: 900`. A 24-frame `SETTLE_SOFT` entrance blends into the sustained camera path. The component's documented length is `sustained`, because camera movement may span the entire Sequence.
+
+Layers remain backdrop, floor reflection, contact shadow, content plane, and light. Reflection and shadow describe the visible studio area and do not require mounting `children` twice. This keeps live React scenes and media safe.
+
+## Demo asset and customizer
+
+The preview uses an optimized full-page WebP capture of the live `remocn.dev` homepage. At design time the page is approximately `1265 x 9164`. The screenshot is stored as a local public asset so Remotion renders are deterministic and do not depend on the live site or network.
+
+The demo lasts about 300 frames and follows several beats from hero to lower sections. Its key list contains holds so the tour reads as an operator choosing details rather than an automated scroll.
+
+The customizer exposes one storyboard preset selector plus the stage pose and handheld controls. Its generated snippet prints the real `contentSize` and `moves` array. There is no `camera-move` preview or configuration.
+
+## Registry and documentation migration
+
+Remove `camera-move` from:
+
+- `registry/remocn/registry.json`
+- `registry/__index__.tsx` and the generated preview manifest
+- registry artifacts
+- layout navigation, cards, and component documentation
+- changelog wording that presents it as a separate component
+
+The Stage page becomes the single source of truth for camera coordinates, long content, holds, easing, deterministic shake, text resampling, content bleed, and composition with `CameraLens`.
+
+## Verification
+
+Move camera tests under `stage` and cover:
+
+- key sorting and duplicate frames;
+- empty moves and endpoint clamps;
+- per-segment easing and holds;
+- normalized top, centre, and bottom targets on a tall plane;
+- transform origin and translation for long content;
+- camera pan before zoom;
+- deterministic seeded shake;
+- safe fallbacks for invalid `contentSize`.
+
+Then run registry build, preview-manifest build, docs metadata tests, focused Stage tests, typecheck, lint, production build, and visual inspection of the long-site tour.
diff --git a/docs/plans/2026-08-21-stage-extreme-depth-controls-design.md b/docs/plans/2026-08-21-stage-extreme-depth-controls-design.md
new file mode 100644
index 00000000..351c4042
--- /dev/null
+++ b/docs/plans/2026-08-21-stage-extreme-depth-controls-design.md
@@ -0,0 +1,34 @@
+# Stage extreme depth controls design
+
+## Goal
+
+Allow the Stage customizer to create much stronger and experimental depth treatments without changing the current readable defaults.
+
+## Control ranges
+
+- `rotateX`: `-180..180`, step `1`, default `14`.
+- `rotateY`: `-180..180`, step `1`, default `-20`.
+- `perspective`: `50..5000`, step `25`, default `900`.
+- `scale`: `0.1..3`, step `0.01`, default `0.86`.
+
+Lower perspective values exaggerate foreshortening. The wider scale range supports both extreme pull-backs and oversized close-ups.
+
+## Back face
+
+Stage currently hides the plane's back face, which makes rotations beyond 90 degrees disappear. Change `backfaceVisibility` to `visible` so the experimental rotation range remains observable. The browser's natural mirrored rendering of the back face is acceptable and should be documented.
+
+Do not duplicate the child surface to manufacture a separate back face. Long screenshots can already be thousands of pixels tall, so mounting a second copy would add unnecessary rendering and memory cost.
+
+## Defaults and compatibility
+
+Keep the existing Stage defaults unchanged. The component already accepts arbitrary numeric props; this change expands customizer reach and makes the back face visible. Existing compositions using normal rotations are unaffected.
+
+## Documentation and verification
+
+- Document that values near or beyond 90 degrees can reveal a mirrored back face.
+- Document that very low perspective or high scale can deliberately clip most of the surface.
+- Test the exact customizer ranges and defaults.
+- Test that the generated transform preserves extreme numeric values.
+- Rebuild the preview manifest.
+- Run targeted tests, typecheck, lint, and production build.
+- Visually inspect a strong-depth pose and a rotation beyond 90 degrees.
diff --git a/docs/plans/2026-08-21-stage-smooth-descent-design.md b/docs/plans/2026-08-21-stage-smooth-descent-design.md
new file mode 100644
index 00000000..a9b1bde3
--- /dev/null
+++ b/docs/plans/2026-08-21-stage-smooth-descent-design.md
@@ -0,0 +1,38 @@
+# Stage smooth descent design
+
+## Goal
+
+Make a continuous top-to-bottom camera move the default Stage example. The camera should never hold or change direction. Acceleration and deceleration should be limited to short regions at the beginning and end, with a constant-speed middle.
+
+## Preset
+
+Add `smooth-descent` to the existing Stage presets and make it the default. Keep `site-tour`, `hero-push`, and `section-hop` as selectable alternatives.
+
+The default 300-frame path uses four keys:
+
+- Frame 0: top target, zero starting velocity.
+- Frame 30: end of the cubic acceleration ramp.
+- Frame 269: start of the cubic deceleration ramp.
+- Frame 299: bottom target, zero ending velocity.
+
+The target stays horizontally centered with constant zoom and roll. The vertical targets are approximately `0.035`, `0.071`, `0.919`, and `0.955`.
+
+## Velocity continuity
+
+The first segment uses `Easing.in(Easing.cubic)`, the middle segment uses `Easing.linear`, and the final segment uses `Easing.out(Easing.cubic)`.
+
+For a 30-frame cubic ramp, the ramp displacement is one third of the distance that the constant middle velocity would travel in the same time. This matches the velocity at both segment boundaries and avoids a visible speed jump.
+
+## Defaults and snippet
+
+The Stage customizer defaults to `smooth-descent`. Default handheld shake becomes `0` so the intended path reads as a clean continuous move. Users can still add shake manually.
+
+The generated snippet imports `Easing` from Remotion and prints named easing expressions instead of serializing easing functions.
+
+## Verification
+
+- Test that the preset has no adjacent identical targets and progresses strictly downward.
+- Test continuity around frames 30 and 269 within a small tolerance.
+- Rebuild the preview manifest.
+- Run targeted tests, typecheck, lint, and production build.
+- Visually inspect the beginning, constant-speed middle, and ending ramp.
diff --git a/lib/customizer-config.ts b/lib/customizer-config.ts
index 52a1b923..7dc36fb3 100644
--- a/lib/customizer-config.ts
+++ b/lib/customizer-config.ts
@@ -109,7 +109,7 @@ export const SHARED_CONTROLS: InteractivitySchema = {
};
/** Components that opt out of the shared `speed` control entirely. */
-const NO_SHARED_SPEED = new Set(["backdrop"]);
+const NO_SHARED_SPEED = new Set(["backdrop", "stage"]);
/**
* Components whose animation rides a shared progress driver that must reach its
diff --git a/public/stage-remocn-components.webp b/public/stage-remocn-components.webp
new file mode 100644
index 00000000..28ffdbac
Binary files /dev/null and b/public/stage-remocn-components.webp differ
diff --git a/registry-artifacts/registry.json b/registry-artifacts/registry.json
index cacc89da..1f11f77e 100644
--- a/registry-artifacts/registry.json
+++ b/registry-artifacts/registry.json
@@ -1339,6 +1339,21 @@
],
"type": "registry:component"
},
+ {
+ "name": "stage",
+ "title": "Stage",
+ "description": "Place a screenshot, recording, or long page on a perspective studio plane and direct an integrated camera across it with timeline keyframes.",
+ "dependencies": ["remotion"],
+ "registryDependencies": ["@remocn/scene-motion"],
+ "files": [
+ {
+ "path": "registry/remocn/stage/index.tsx",
+ "type": "registry:component",
+ "target": "components/remocn/stage.tsx"
+ }
+ ],
+ "type": "registry:component"
+ },
{
"name": "logo-enter",
"title": "Logo Enter",
diff --git a/registry-artifacts/stage.json b/registry-artifacts/stage.json
new file mode 100644
index 00000000..305b826c
--- /dev/null
+++ b/registry-artifacts/stage.json
@@ -0,0 +1,17 @@
+{
+ "$schema": "https://ui.shadcn.com/schema/registry-item.json",
+ "name": "stage",
+ "title": "Stage",
+ "description": "Place a screenshot, recording, or long page on a perspective studio plane and direct an integrated camera across it with timeline keyframes.",
+ "dependencies": ["remotion"],
+ "registryDependencies": ["@remocn/scene-motion"],
+ "files": [
+ {
+ "path": "registry/remocn/stage/index.tsx",
+ "content": "\"use client\";\n\nimport type { CSSProperties, ReactNode } from \"react\";\nimport {\n AbsoluteFill,\n type EasingFunction,\n interpolate,\n random,\n useCurrentFrame,\n useVideoConfig,\n} from \"remotion\";\nimport { CLAMP, EXPO, SETTLE_SOFT } from \"@/lib/remocn/scene-motion\";\n\nexport interface StageKey {\n at: number;\n x?: number;\n y?: number;\n zoom?: number;\n rotate?: number;\n easing?: EasingFunction;\n}\n\nexport interface StageContentSize {\n width: number;\n height: number;\n}\n\nexport interface StageProps {\n children: ReactNode;\n contentSize?: StageContentSize;\n moves?: StageKey[];\n shake?: number;\n seed?: string;\n backdrop?: string;\n rotateX?: number;\n rotateY?: number;\n perspective?: number;\n scale?: number;\n radius?: number;\n reflection?: number;\n shadow?: number;\n light?: number;\n className?: string;\n}\n\nexport interface StagePose {\n x: number;\n y: number;\n zoom: number;\n rotate: number;\n}\n\nexport interface StageShake {\n x: number;\n y: number;\n rotate: number;\n}\n\nexport interface StagePlaneGeometry {\n width: number;\n height: number;\n left: number;\n top: number;\n targetX: number;\n targetY: number;\n translateX: number;\n translateY: number;\n}\n\nconst NEUTRAL_POSE: StagePose = { x: 0.5, y: 0.5, zoom: 1, rotate: 0 };\n\nconst clamp01 = (value: number) => Math.min(1, Math.max(0, value));\n\nconst poseFromKey = (key: StageKey): StagePose => ({\n x: clamp01(key.x ?? NEUTRAL_POSE.x),\n y: clamp01(key.y ?? NEUTRAL_POSE.y),\n zoom: key.zoom ?? NEUTRAL_POSE.zoom,\n rotate: key.rotate ?? NEUTRAL_POSE.rotate,\n});\n\nexport function normalizeStageKeys(moves: StageKey[]): StageKey[] {\n const byFrame = new Map<number, StageKey>();\n for (const move of moves) byFrame.set(move.at, move);\n return [...byFrame.values()].sort((a, b) => a.at - b.at);\n}\n\nexport function resolveStagePose(frame: number, moves: StageKey[]): StagePose {\n const keys = normalizeStageKeys(moves);\n if (keys.length === 0) return NEUTRAL_POSE;\n if (frame <= keys[0].at) return poseFromKey(keys[0]);\n if (frame >= keys[keys.length - 1].at) {\n return poseFromKey(keys[keys.length - 1]);\n }\n\n const rightIndex = keys.findIndex((key) => frame <= key.at);\n const left = keys[rightIndex - 1];\n const right = keys[rightIndex];\n const progress = interpolate(frame, [left.at, right.at], [0, 1], {\n ...CLAMP,\n easing: right.easing ?? EXPO,\n });\n const from = poseFromKey(left);\n const to = poseFromKey(right);\n const lerp = (a: number, b: number) => a + (b - a) * progress;\n\n return {\n x: lerp(from.x, to.x),\n y: lerp(from.y, to.y),\n zoom: lerp(from.zoom, to.zoom),\n rotate: lerp(from.rotate, to.rotate),\n };\n}\n\nconst smoothstep = (value: number) => value * value * (3 - 2 * value);\n\nfunction smoothNoise(frame: number, seed: string, axis: string): number {\n const sample = frame / 6;\n const index = Math.floor(sample);\n const mix = smoothstep(sample - index);\n const a = random(`${seed}-${axis}-${index}`) * 2 - 1;\n const b = random(`${seed}-${axis}-${index + 1}`) * 2 - 1;\n return a + (b - a) * mix;\n}\n\nexport function getStageShake(\n frame: number,\n shake: number,\n seed = \"remocn-stage\",\n): StageShake {\n const amount = clamp01(shake);\n if (amount === 0) return { x: 0, y: 0, rotate: 0 };\n\n const phase = random(`${seed}-phase`) * Math.PI * 2;\n const xWave = Math.sin(frame * 0.19 + phase) * 0.58;\n const yWave = Math.sin(frame * 0.13 + phase * 1.37) * 0.5;\n const xFine = Math.sin(frame * 0.047 + phase * 0.71) * 0.22;\n const yFine = Math.sin(frame * 0.071 + phase * 1.91) * 0.2;\n\n return {\n x: (xWave + xFine + smoothNoise(frame, seed, \"x\") * 0.32) * 7 * amount,\n y: (yWave + yFine + smoothNoise(frame, seed, \"y\") * 0.3) * 5 * amount,\n rotate:\n (Math.sin(frame * 0.083 + phase * 0.43) * 0.65 +\n smoothNoise(frame, seed, \"roll\") * 0.35) *\n 0.28 *\n amount,\n };\n}\n\nexport function getStagePlaneGeometry(\n compositionWidth: number,\n compositionHeight: number,\n contentSize: StageContentSize | undefined,\n pose: StagePose,\n widthRatio = 0.84,\n): StagePlaneGeometry {\n const safeContentWidth =\n contentSize && contentSize.width > 0 ? contentSize.width : compositionWidth;\n const safeContentHeight =\n contentSize && contentSize.height > 0\n ? contentSize.height\n : compositionHeight;\n const width = compositionWidth * widthRatio;\n const height = width * (safeContentHeight / safeContentWidth);\n const left = (compositionWidth - width) / 2;\n const top = (compositionHeight - height) / 2;\n const targetX = clamp01(pose.x) * width;\n const targetY = clamp01(pose.y) * height;\n\n return {\n width,\n height,\n left,\n top,\n targetX,\n targetY,\n translateX: compositionWidth / 2 - (left + targetX),\n translateY: compositionHeight / 2 - (top + targetY),\n };\n}\n\nexport function getStageTransform(\n geometry: StagePlaneGeometry,\n pose: StagePose,\n options: {\n scale: number;\n rotateX: number;\n rotateY: number;\n entryY?: number;\n shake?: StageShake;\n },\n): string {\n const handheld = options.shake ?? { x: 0, y: 0, rotate: 0 };\n const translateX = geometry.translateX - handheld.x;\n const translateY = geometry.translateY + (options.entryY ?? 0) - handheld.y;\n const rotateZ = -pose.rotate - handheld.rotate;\n\n return `translate3d(${translateX}px, ${translateY}px, 0) scale(${options.scale * pose.zoom}) rotateZ(${rotateZ}deg) rotateX(${options.rotateX}deg) rotateY(${options.rotateY}deg)`;\n}\n\nexport function Stage({\n children,\n contentSize,\n moves = [],\n shake = 0,\n seed = \"remocn-stage\",\n backdrop = \"linear-gradient(145deg, #17181d 0%, #09090b 72%)\",\n rotateX = 14,\n rotateY = -20,\n perspective = 900,\n scale = 0.86,\n radius = 1.4,\n reflection = 0.24,\n shadow = 0.7,\n light = 0.55,\n className,\n}: StageProps) {\n const frame = useCurrentFrame();\n const { width, height } = useVideoConfig();\n const settle = interpolate(frame, [0, 24], [0, 1], {\n ...CLAMP,\n easing: SETTLE_SOFT,\n });\n const opacity = interpolate(frame, [0, 9], [0, 1], CLAMP);\n const pose = resolveStagePose(frame, moves);\n const handheld = getStageShake(frame, shake, seed);\n const geometry = getStagePlaneGeometry(width, height, contentSize, pose);\n const radiusPx = (radius / 100) * width;\n const reflectionStrength = clamp01(reflection);\n const shadowStrength = clamp01(shadow);\n const lightStrength = clamp01(light);\n const currentScale = interpolate(settle, [0, 1], [scale * 0.94, scale]);\n const currentRotateX = interpolate(settle, [0, 1], [rotateX + 8, rotateX]);\n const currentRotateY = interpolate(settle, [0, 1], [rotateY - 5, rotateY]);\n const entryY = interpolate(settle, [0, 1], [64, 0]);\n const transform = getStageTransform(geometry, pose, {\n scale: currentScale,\n rotateX: currentRotateX,\n rotateY: currentRotateY,\n entryY,\n shake: handheld,\n });\n\n const planeStyle: CSSProperties = {\n position: \"absolute\",\n left: geometry.left,\n top: geometry.top,\n width: geometry.width,\n height: geometry.height,\n overflow: \"hidden\",\n borderRadius: radiusPx,\n transform,\n transformOrigin: `${geometry.targetX}px ${geometry.targetY}px`,\n transformStyle: \"preserve-3d\",\n backfaceVisibility: \"visible\",\n willChange: \"transform\",\n };\n\n return (\n <AbsoluteFill\n className={className}\n style={{ overflow: \"hidden\", background: backdrop }}\n >\n <div\n aria-hidden\n style={{\n position: \"absolute\",\n left: \"13%\",\n top: \"72%\",\n width: \"74%\",\n height: \"30%\",\n opacity: reflectionStrength * opacity,\n background:\n \"linear-gradient(to bottom, rgba(188,181,255,0.32), rgba(91,81,145,0.1) 35%, transparent 76%)\",\n clipPath: \"polygon(7% 0, 93% 0, 78% 100%, 22% 100%)\",\n filter: \"blur(18px)\",\n transform: `perspective(650px) rotateX(58deg) translateY(${entryY * 0.28}px)`,\n transformOrigin: \"center top\",\n pointerEvents: \"none\",\n }}\n />\n\n <div\n aria-hidden\n style={{\n position: \"absolute\",\n left: \"16%\",\n top: \"70%\",\n width: \"68%\",\n height: \"11%\",\n borderRadius: \"50%\",\n background: `rgba(0, 0, 0, ${0.52 * shadowStrength * opacity})`,\n filter: `blur(${20 + 30 * shadowStrength}px)`,\n transform: `translateY(${entryY * 0.35}px)`,\n pointerEvents: \"none\",\n }}\n />\n\n <AbsoluteFill\n style={{\n perspective,\n perspectiveOrigin: \"50% 42%\",\n opacity,\n pointerEvents: \"none\",\n }}\n >\n <div style={planeStyle}>{children}</div>\n </AbsoluteFill>\n\n <AbsoluteFill\n aria-hidden\n style={{\n pointerEvents: \"none\",\n opacity: lightStrength,\n background:\n \"radial-gradient(ellipse at 38% 7%, rgba(255,255,255,0.2), transparent 36%), linear-gradient(115deg, rgba(255,255,255,0.08), transparent 38%, rgba(255,255,255,0.02) 68%, rgba(0,0,0,0.24))\",\n mixBlendMode: \"screen\",\n }}\n />\n </AbsoluteFill>\n );\n}\n",
+ "type": "registry:component",
+ "target": "components/remocn/stage.tsx"
+ }
+ ],
+ "type": "registry:component"
+}
diff --git a/registry/__index__.tsx b/registry/__index__.tsx
index 09005663..1a24777e 100644
--- a/registry/__index__.tsx
+++ b/registry/__index__.tsx
@@ -2192,6 +2192,14 @@ const registry: Record<string, RegistryEntry> = {
loadConfig: () =>
import("@/registry/remocn/drift/config").then((m) => m.driftConfig),
},
+ stage: {
+ load: () =>
+ import("@/components/docs/examples/stage-example").then((m) => ({
+ default: m.StageExampleScene,
+ })),
+ loadConfig: () =>
+ import("@/registry/remocn/stage/config").then((m) => m.stageConfig),
+ },
"claude-chat": {
load: () =>
import("@/registry/remocn/claude-chat").then((m) => ({
diff --git a/registry/__manifest__.ts b/registry/__manifest__.ts
index f5b36f3c..d08e490c 100644
--- a/registry/__manifest__.ts
+++ b/registry/__manifest__.ts
@@ -3710,6 +3710,26 @@ export const previewManifest: Record<string, PreviewManifestEntry> = {
speed: 1,
},
},
+ stage: {
+ durationInFrames: 300,
+ fps: 30,
+ compositionWidth: 1280,
+ compositionHeight: 720,
+ defaults: {
+ preset: "smooth-descent",
+ shake: 0,
+ seed: "remocn-smooth-descent",
+ backdrop: "linear-gradient(145deg, #17181d 0%, #09090b 72%)",
+ rotateX: 14,
+ rotateY: -20,
+ perspective: 900,
+ scale: 0.86,
+ radius: 1.4,
+ reflection: 0.24,
+ shadow: 0.7,
+ light: 0.55,
+ },
+ },
"staggered-fade-up": {
durationInFrames: 90,
fps: 30,
diff --git a/registry/remocn/registry.json b/registry/remocn/registry.json
index 33db9168..d0d46666 100644
--- a/registry/remocn/registry.json
+++ b/registry/remocn/registry.json
@@ -1339,6 +1339,21 @@
}
]
},
+ {
+ "name": "stage",
+ "type": "registry:component",
+ "title": "Stage",
+ "description": "Place a screenshot, recording, or long page on a perspective studio plane and direct an integrated camera across it with timeline keyframes.",
+ "dependencies": ["remotion"],
+ "registryDependencies": ["@remocn/scene-motion"],
+ "files": [
+ {
+ "path": "stage/index.tsx",
+ "type": "registry:component",
+ "target": "components/remocn/stage.tsx"
+ }
+ ]
+ },
{
"name": "logo-enter",
"type": "registry:component",
diff --git a/registry/remocn/stage/__tests__/stage.test.ts b/registry/remocn/stage/__tests__/stage.test.ts
new file mode 100644
index 00000000..9a7f77c7
--- /dev/null
+++ b/registry/remocn/stage/__tests__/stage.test.ts
@@ -0,0 +1,145 @@
+import { describe, expect, it } from "bun:test";
+import { Easing } from "remotion";
+import {
+ getStagePlaneGeometry,
+ getStageShake,
+ getStageTransform,
+ normalizeStageKeys,
+ resolveStagePose,
+} from "../index";
+
+describe("normalizeStageKeys", () => {
+ it("sorts keys without mutating the input", () => {
+ const moves = [
+ { at: 30, y: 0.8 },
+ { at: 0, y: 0.1 },
+ ];
+ expect(normalizeStageKeys(moves).map((key) => key.at)).toEqual([0, 30]);
+ expect(moves.map((key) => key.at)).toEqual([30, 0]);
+ });
+
+ it("uses the last supplied key when frames collide", () => {
+ expect(
+ normalizeStageKeys([
+ { at: 10, y: 0.2 },
+ { at: 10, y: 0.6 },
+ ]),
+ ).toEqual([{ at: 10, y: 0.6 }]);
+ });
+});
+
+describe("resolveStagePose", () => {
+ it("centers an empty stage", () => {
+ expect(resolveStagePose(42, [])).toEqual({
+ x: 0.5,
+ y: 0.5,
+ zoom: 1,
+ rotate: 0,
+ });
+ });
+
+ it("clamps normalized targets and timeline endpoints", () => {
+ const moves = [
+ { at: 10, x: -1, y: 0.2, zoom: 1.1 },
+ { at: 20, x: 2, y: 0.8, zoom: 1.4 },
+ ];
+ expect(resolveStagePose(-100, moves)).toEqual({
+ x: 0,
+ y: 0.2,
+ zoom: 1.1,
+ rotate: 0,
+ });
+ expect(resolveStagePose(100, moves)).toEqual({
+ x: 1,
+ y: 0.8,
+ zoom: 1.4,
+ rotate: 0,
+ });
+ });
+
+ it("applies destination easing and expresses holds", () => {
+ const eased = resolveStagePose(5, [
+ { at: 0, x: 0 },
+ { at: 10, x: 1, easing: Easing.in(Easing.quad) },
+ ]);
+ expect(eased.x).toBeCloseTo(0.25, 6);
+
+ const hold = [
+ { at: 0, y: 0.1 },
+ { at: 10, y: 0.4, easing: Easing.linear },
+ { at: 20, y: 0.4, easing: Easing.linear },
+ { at: 30, y: 0.8, easing: Easing.linear },
+ ];
+ expect(resolveStagePose(15, hold).y).toBe(0.4);
+ });
+});
+
+describe("stage plane geometry", () => {
+ it("preserves a tall source ratio and pins its target to frame center", () => {
+ const pose = { x: 0.52, y: 0.955, zoom: 1, rotate: 0 };
+ const geometry = getStagePlaneGeometry(
+ 1280,
+ 720,
+ { width: 1265, height: 10022 },
+ pose,
+ );
+
+ expect(geometry.width).toBeCloseTo(1075.2, 6);
+ expect(geometry.height).toBeCloseTo(8518.304, 3);
+ expect(geometry.left + geometry.targetX + geometry.translateX).toBe(640);
+ expect(geometry.top + geometry.targetY + geometry.translateY).toBe(360);
+ });
+
+ it("falls back safely when content dimensions are invalid", () => {
+ const geometry = getStagePlaneGeometry(
+ 1280,
+ 720,
+ { width: 0, height: -1 },
+ { x: 0.5, y: 0.5, zoom: 1, rotate: 0 },
+ );
+ expect(geometry.height).toBeCloseTo(604.8, 6);
+ });
+});
+
+describe("stage transform", () => {
+ it("combines target translation, camera roll, perspective pose, and shake", () => {
+ const pose = { x: 0.5, y: 0.5, zoom: 1.2, rotate: 2 };
+ const geometry = getStagePlaneGeometry(1280, 720, undefined, pose);
+ expect(
+ getStageTransform(geometry, pose, {
+ scale: 0.8,
+ rotateX: 14,
+ rotateY: -20,
+ entryY: 10,
+ shake: { x: 2, y: -3, rotate: 0.5 },
+ }),
+ ).toBe(
+ "translate3d(-2px, 13px, 0) scale(0.96) rotateZ(-2.5deg) rotateX(14deg) rotateY(-20deg)",
+ );
+ });
+
+ it("preserves experimental rotation and scale values", () => {
+ const pose = { x: 0.5, y: 0.5, zoom: 1, rotate: 0 };
+ const geometry = getStagePlaneGeometry(1280, 720, undefined, pose);
+ expect(
+ getStageTransform(geometry, pose, {
+ scale: 3,
+ rotateX: 180,
+ rotateY: -180,
+ }),
+ ).toBe(
+ "translate3d(0px, 0px, 0) scale(3) rotateZ(0deg) rotateX(180deg) rotateY(-180deg)",
+ );
+ });
+});
+
+describe("getStageShake", () => {
+ it("is deterministic, seed-sensitive, and strength-clamped", () => {
+ expect(getStageShake(18, 0.8, "a")).toEqual(getStageShake(18, 0.8, "a"));
+ expect(getStageShake(18, 0.8, "a")).not.toEqual(
+ getStageShake(18, 0.8, "b"),
+ );
+ expect(getStageShake(18, 0, "a")).toEqual({ x: 0, y: 0, rotate: 0 });
+ expect(getStageShake(18, 2, "a")).toEqual(getStageShake(18, 1, "a"));
+ });
+});
diff --git a/registry/remocn/stage/config.ts b/registry/remocn/stage/config.ts
new file mode 100644
index 00000000..fe0d55f1
--- /dev/null
+++ b/registry/remocn/stage/config.ts
@@ -0,0 +1,122 @@
+import { stageExampleCode } from "@/components/docs/examples/stage-example";
+import {
+ type ComponentConfig,
+ enumVariants,
+ FPS,
+ H,
+ W,
+} from "@/lib/customizer-config";
+
+export const stageConfig: ComponentConfig = {
+ componentName: "Stage",
+ importPath: "@/components/remocn/stage",
+ controls: {
+ preset: {
+ type: "enum",
+ default: "smooth-descent",
+ variants: enumVariants([
+ "smooth-descent",
+ "site-tour",
+ "hero-push",
+ "section-hop",
+ ]),
+ description: "Camera path",
+ },
+ shake: {
+ type: "number",
+ min: 0,
+ max: 1,
+ step: 0.05,
+ default: 0,
+ description: "Handheld shake",
+ hiddenFromList: false,
+ },
+ seed: {
+ type: "text-content",
+ default: "remocn-smooth-descent",
+ description: "Shake seed",
+ },
+ backdrop: {
+ type: "text-content",
+ default: "linear-gradient(145deg, #17181d 0%, #09090b 72%)",
+ description: "Backdrop (CSS)",
+ },
+ rotateX: {
+ type: "number",
+ min: -180,
+ max: 180,
+ step: 1,
+ default: 14,
+ description: "Rotate X",
+ hiddenFromList: false,
+ },
+ rotateY: {
+ type: "number",
+ min: -180,
+ max: 180,
+ step: 1,
+ default: -20,
+ description: "Rotate Y",
+ hiddenFromList: false,
+ },
+ perspective: {
+ type: "number",
+ min: 50,
+ max: 5000,
+ step: 25,
+ default: 900,
+ description: "Perspective",
+ hiddenFromList: false,
+ },
+ scale: {
+ type: "number",
+ min: 0.1,
+ max: 3,
+ step: 0.01,
+ default: 0.86,
+ description: "Scale",
+ hiddenFromList: false,
+ },
+ radius: {
+ type: "number",
+ min: 0,
+ max: 4,
+ step: 0.1,
+ default: 1.4,
+ description: "Radius",
+ hiddenFromList: false,
+ },
+ reflection: {
+ type: "number",
+ min: 0,
+ max: 1,
+ step: 0.05,
+ default: 0.24,
+ description: "Reflection",
+ hiddenFromList: false,
+ },
+ shadow: {
+ type: "number",
+ min: 0,
+ max: 1,
+ step: 0.05,
+ default: 0.7,
+ description: "Contact shadow",
+ hiddenFromList: false,
+ },
+ light: {
+ type: "number",
+ min: 0,
+ max: 1,
+ step: 0.05,
+ default: 0.55,
+ description: "Studio light",
+ hiddenFromList: false,
+ },
+ },
+ durationInFrames: 300,
+ fps: FPS,
+ compositionWidth: W,
+ compositionHeight: H,
+ snippet: stageExampleCode,
+};
diff --git a/registry/remocn/stage/index.tsx b/registry/remocn/stage/index.tsx
new file mode 100644
index 00000000..00aea76c
--- /dev/null
+++ b/registry/remocn/stage/index.tsx
@@ -0,0 +1,322 @@
+"use client";
+
+import type { CSSProperties, ReactNode } from "react";
+import {
+ AbsoluteFill,
+ type EasingFunction,
+ interpolate,
+ random,
+ useCurrentFrame,
+ useVideoConfig,
+} from "remotion";
+import { CLAMP, EXPO, SETTLE_SOFT } from "@/lib/remocn/scene-motion";
+
+export interface StageKey {
+ at: number;
+ x?: number;
+ y?: number;
+ zoom?: number;
+ rotate?: number;
+ easing?: EasingFunction;
+}
+
+export interface StageContentSize {
+ width: number;
+ height: number;
+}
+
+export interface StageProps {
+ children: ReactNode;
+ contentSize?: StageContentSize;
+ moves?: StageKey[];
+ shake?: number;
+ seed?: string;
+ backdrop?: string;
+ rotateX?: number;
+ rotateY?: number;
+ perspective?: number;
+ scale?: number;
+ radius?: number;
+ reflection?: number;
+ shadow?: number;
+ light?: number;
+ className?: string;
+}
+
+export interface StagePose {
+ x: number;
+ y: number;
+ zoom: number;
+ rotate: number;
+}
+
+export interface StageShake {
+ x: number;
+ y: number;
+ rotate: number;
+}
+
+export interface StagePlaneGeometry {
+ width: number;
+ height: number;
+ left: number;
+ top: number;
+ targetX: number;
+ targetY: number;
+ translateX: number;
+ translateY: number;
+}
+
+const NEUTRAL_POSE: StagePose = { x: 0.5, y: 0.5, zoom: 1, rotate: 0 };
+
+const clamp01 = (value: number) => Math.min(1, Math.max(0, value));
+
+const poseFromKey = (key: StageKey): StagePose => ({
+ x: clamp01(key.x ?? NEUTRAL_POSE.x),
+ y: clamp01(key.y ?? NEUTRAL_POSE.y),
+ zoom: key.zoom ?? NEUTRAL_POSE.zoom,
+ rotate: key.rotate ?? NEUTRAL_POSE.rotate,
+});
+
+export function normalizeStageKeys(moves: StageKey[]): StageKey[] {
+ const byFrame = new Map<number, StageKey>();
+ for (const move of moves) byFrame.set(move.at, move);
+ return [...byFrame.values()].sort((a, b) => a.at - b.at);
+}
+
+export function resolveStagePose(frame: number, moves: StageKey[]): StagePose {
+ const keys = normalizeStageKeys(moves);
+ if (keys.length === 0) return NEUTRAL_POSE;
+ if (frame <= keys[0].at) return poseFromKey(keys[0]);
+ if (frame >= keys[keys.length - 1].at) {
+ return poseFromKey(keys[keys.length - 1]);
+ }
+
+ const rightIndex = keys.findIndex((key) => frame <= key.at);
+ const left = keys[rightIndex - 1];
+ const right = keys[rightIndex];
+ const progress = interpolate(frame, [left.at, right.at], [0, 1], {
+ ...CLAMP,
+ easing: right.easing ?? EXPO,
+ });
+ const from = poseFromKey(left);
+ const to = poseFromKey(right);
+ const lerp = (a: number, b: number) => a + (b - a) * progress;
+
+ return {
+ x: lerp(from.x, to.x),
+ y: lerp(from.y, to.y),
+ zoom: lerp(from.zoom, to.zoom),
+ rotate: lerp(from.rotate, to.rotate),
+ };
+}
+
+const smoothstep = (value: number) => value * value * (3 - 2 * value);
+
+function smoothNoise(frame: number, seed: string, axis: string): number {
+ const sample = frame / 6;
+ const index = Math.floor(sample);
+ const mix = smoothstep(sample - index);
+ const a = random(`${seed}-${axis}-${index}`) * 2 - 1;
+ const b = random(`${seed}-${axis}-${index + 1}`) * 2 - 1;
+ return a + (b - a) * mix;
+}
+
+export function getStageShake(
+ frame: number,
+ shake: number,
+ seed = "remocn-stage",
+): StageShake {
+ const amount = clamp01(shake);
+ if (amount === 0) return { x: 0, y: 0, rotate: 0 };
+
+ const phase = random(`${seed}-phase`) * Math.PI * 2;
+ const xWave = Math.sin(frame * 0.19 + phase) * 0.58;
+ const yWave = Math.sin(frame * 0.13 + phase * 1.37) * 0.5;
+ const xFine = Math.sin(frame * 0.047 + phase * 0.71) * 0.22;
+ const yFine = Math.sin(frame * 0.071 + phase * 1.91) * 0.2;
+
+ return {
+ x: (xWave + xFine + smoothNoise(frame, seed, "x") * 0.32) * 7 * amount,
+ y: (yWave + yFine + smoothNoise(frame, seed, "y") * 0.3) * 5 * amount,
+ rotate:
+ (Math.sin(frame * 0.083 + phase * 0.43) * 0.65 +
+ smoothNoise(frame, seed, "roll") * 0.35) *
+ 0.28 *
+ amount,
+ };
+}
+
+export function getStagePlaneGeometry(
+ compositionWidth: number,
+ compositionHeight: number,
+ contentSize: StageContentSize | undefined,
+ pose: StagePose,
+ widthRatio = 0.84,
+): StagePlaneGeometry {
+ const safeContentWidth =
+ contentSize && contentSize.width > 0 ? contentSize.width : compositionWidth;
+ const safeContentHeight =
+ contentSize && contentSize.height > 0
+ ? contentSize.height
+ : compositionHeight;
+ const width = compositionWidth * widthRatio;
+ const height = width * (safeContentHeight / safeContentWidth);
+ const left = (compositionWidth - width) / 2;
+ const top = (compositionHeight - height) / 2;
+ const targetX = clamp01(pose.x) * width;
+ const targetY = clamp01(pose.y) * height;
+
+ return {
+ width,
+ height,
+ left,
+ top,
+ targetX,
+ targetY,
+ translateX: compositionWidth / 2 - (left + targetX),
+ translateY: compositionHeight / 2 - (top + targetY),
+ };
+}
+
+export function getStageTransform(
+ geometry: StagePlaneGeometry,
+ pose: StagePose,
+ options: {
+ scale: number;
+ rotateX: number;
+ rotateY: number;
+ entryY?: number;
+ shake?: StageShake;
+ },
+): string {
+ const handheld = options.shake ?? { x: 0, y: 0, rotate: 0 };
+ const translateX = geometry.translateX - handheld.x;
+ const translateY = geometry.translateY + (options.entryY ?? 0) - handheld.y;
+ const rotateZ = -pose.rotate - handheld.rotate;
+
+ return `translate3d(${translateX}px, ${translateY}px, 0) scale(${options.scale * pose.zoom}) rotateZ(${rotateZ}deg) rotateX(${options.rotateX}deg) rotateY(${options.rotateY}deg)`;
+}
+
+export function Stage({
+ children,
+ contentSize,
+ moves = [],
+ shake = 0,
+ seed = "remocn-stage",
+ backdrop = "linear-gradient(145deg, #17181d 0%, #09090b 72%)",
+ rotateX = 14,
+ rotateY = -20,
+ perspective = 900,
+ scale = 0.86,
+ radius = 1.4,
+ reflection = 0.24,
+ shadow = 0.7,
+ light = 0.55,
+ className,
+}: StageProps) {
+ const frame = useCurrentFrame();
+ const { width, height } = useVideoConfig();
+ const settle = interpolate(frame, [0, 24], [0, 1], {
+ ...CLAMP,
+ easing: SETTLE_SOFT,
+ });
+ const opacity = interpolate(frame, [0, 9], [0, 1], CLAMP);
+ const pose = resolveStagePose(frame, moves);
+ const handheld = getStageShake(frame, shake, seed);
+ const geometry = getStagePlaneGeometry(width, height, contentSize, pose);
+ const radiusPx = (radius / 100) * width;
+ const reflectionStrength = clamp01(reflection);
+ const shadowStrength = clamp01(shadow);
+ const lightStrength = clamp01(light);
+ const currentScale = interpolate(settle, [0, 1], [scale * 0.94, scale]);
+ const currentRotateX = interpolate(settle, [0, 1], [rotateX + 8, rotateX]);
+ const currentRotateY = interpolate(settle, [0, 1], [rotateY - 5, rotateY]);
+ const entryY = interpolate(settle, [0, 1], [64, 0]);
+ const transform = getStageTransform(geometry, pose, {
+ scale: currentScale,
+ rotateX: currentRotateX,
+ rotateY: currentRotateY,
+ entryY,
+ shake: handheld,
+ });
+
+ const planeStyle: CSSProperties = {
+ position: "absolute",
+ left: geometry.left,
+ top: geometry.top,
+ width: geometry.width,
+ height: geometry.height,
+ overflow: "hidden",
+ borderRadius: radiusPx,
+ transform,
+ transformOrigin: `${geometry.targetX}px ${geometry.targetY}px`,
+ transformStyle: "preserve-3d",
+ backfaceVisibility: "visible",
+ willChange: "transform",
+ };
+
+ return (
+ <AbsoluteFill
+ className={className}
+ style={{ overflow: "hidden", background: backdrop }}
+ >
+ <div
+ aria-hidden
+ style={{
+ position: "absolute",
+ left: "13%",
+ top: "72%",
+ width: "74%",
+ height: "30%",
+ opacity: reflectionStrength * opacity,
+ background:
+ "linear-gradient(to bottom, rgba(188,181,255,0.32), rgba(91,81,145,0.1) 35%, transparent 76%)",
+ clipPath: "polygon(7% 0, 93% 0, 78% 100%, 22% 100%)",
+ filter: "blur(18px)",
+ transform: `perspective(650px) rotateX(58deg) translateY(${entryY * 0.28}px)`,
+ transformOrigin: "center top",
+ pointerEvents: "none",
+ }}
+ />
+
+ <div
+ aria-hidden
+ style={{
+ position: "absolute",
+ left: "16%",
+ top: "70%",
+ width: "68%",
+ height: "11%",
+ borderRadius: "50%",
+ background: `rgba(0, 0, 0, ${0.52 * shadowStrength * opacity})`,
+ filter: `blur(${20 + 30 * shadowStrength}px)`,
+ transform: `translateY(${entryY * 0.35}px)`,
+ pointerEvents: "none",
+ }}
+ />
+
+ <AbsoluteFill
+ style={{
+ perspective,
+ perspectiveOrigin: "50% 42%",
+ opacity,
+ pointerEvents: "none",
+ }}
+ >
+ <div style={planeStyle}>{children}</div>
+ </AbsoluteFill>
+
+ <AbsoluteFill
+ aria-hidden
+ style={{
+ pointerEvents: "none",
+ opacity: lightStrength,
+ background:
+ "radial-gradient(ellipse at 38% 7%, rgba(255,255,255,0.2), transparent 36%), linear-gradient(115deg, rgba(255,255,255,0.08), transparent 38%, rgba(255,255,255,0.02) 68%, rgba(0,0,0,0.24))",
+ mixBlendMode: "screen",
+ }}
+ />
+ </AbsoluteFill>
+ );
+}