Production-ready animations, transitions, backgrounds, and scenes for Remotion
TypeScript ai-agentsclaude-codedemo-videomcpmcp-servermodel-context-protocolmotion-designproduct-demoreactremotionshadcnvideo
feat: pixalate region
kapishdimab38829f6ef1d
diff --git a/components/docs/examples/canvas-scenes.tsx b/components/docs/examples/canvas-scenes.tsxindex 8f6b5a0d..047d9b62 100644--- a/components/docs/examples/canvas-scenes.tsx+++ b/components/docs/examples/canvas-scenes.tsx@@ -70,6 +70,84 @@ export function CanvasSceneA() {);}+export const SECRET_ROW_X = 504;+export const SECRET_ROW_WIDTH = 600;+export const SECRET_ROW_HEIGHT = 72;++const SECRET_ROWS = [+ { label: "Account", value: "[email protected]", y: 220 },+ { label: "API key", value: "sk_live_4f8a2c9e1b7d", y: 332 },+ { label: "Webhook secret", value: "whsec_71c0d4e8ab35", y: 444 },+];++export function CanvasSceneSecrets() {+ return (+ <AbsoluteFill style={{ background: "#0d0f14", fontFamily: SANS }}>+ <span+ style={{+ position: "absolute",+ left: 96,+ top: 104,+ fontSize: 44,+ fontWeight: 600,+ letterSpacing: "-0.02em",+ color: INK,+ }}+ >+ Project credentials+ </span>+ {SECRET_ROWS.map((row) => (+ <div key={row.label}>+ <div+ style={{+ position: "absolute",+ left: 96,+ top: row.y,+ height: SECRET_ROW_HEIGHT,+ display: "flex",+ alignItems: "center",+ fontSize: 34,+ color: MUTED,+ }}+ >+ {row.label}+ </div>+ <div+ style={{+ position: "absolute",+ left: SECRET_ROW_X,+ top: row.y,+ width: SECRET_ROW_WIDTH,+ height: SECRET_ROW_HEIGHT,+ display: "flex",+ alignItems: "center",+ fontFamily: MONO,+ fontSize: 34,+ color: INK,+ }}+ >+ {row.value}+ </div>+ </div>+ ))}+ <div+ style={{+ position: "absolute",+ left: 96,+ right: 96,+ top: 568,+ paddingTop: 28,+ borderTop: "1px solid #1e222c",+ fontSize: 28,+ color: MUTED,+ }}+ >+ Rotate keys from the dashboard — old ones stay valid for 24 hours.+ </div>+ </AbsoluteFill>+ );+}+export function CanvasSceneB() {return (<AbsoluteFilldiff --git a/components/docs/examples/pixelate-region-example.tsx b/components/docs/examples/pixelate-region-example.tsxnew file mode 100644index 00000000..d5660d03--- /dev/null+++ b/components/docs/examples/pixelate-region-example.tsx@@ -0,0 +1,57 @@+"use client";++import {+ CanvasSceneSecrets,+ SECRET_ROW_HEIGHT,+ SECRET_ROW_WIDTH,+ SECRET_ROW_X,+} from "@/components/docs/examples/canvas-scenes";+import { PixelateRegion } from "@/registry/remocn/pixelate-region";++const REDACTED = [+ {+ x: SECRET_ROW_X,+ y: 332,+ width: SECRET_ROW_WIDTH,+ height: SECRET_ROW_HEIGHT,+ },+ {+ x: SECRET_ROW_X,+ y: 444,+ width: SECRET_ROW_WIDTH,+ height: SECRET_ROW_HEIGHT,+ },+];++interface PixelateRegionExampleProps {+ cellSize?: number;+}++export function PixelateRegionExampleScene({+ cellSize,+}: PixelateRegionExampleProps) {+ return (+ <PixelateRegion regions={REDACTED} cellSize={cellSize}>+ <CanvasSceneSecrets />+ </PixelateRegion>+ );+}++export const pixelateRegionExampleCode = (+ values: Record<string, unknown>,+): string => {+ const cellSize = (values.cellSize as number) ?? 24;+ return `import { PixelateRegion } from "@/components/remocn/pixelate-region";++export const MyScene = () => (+ <PixelateRegion+ regions={[+ { x: 504, y: 332, width: 600, height: 72 },+ { x: 504, y: 444, width: 600, height: 72 },+ ]}+ cellSize={${cellSize}}+ >+ <Scene />+ </PixelateRegion>+);`;+};diff --git a/content/changelog/2026-08-02-filters.mdx b/content/changelog/2026-08-02-filters.mdxindex 49245db1..bf812f1d 100644--- a/content/changelog/2026-08-02-filters.mdx+++ b/content/changelog/2026-08-02-filters.mdx@@ -10,6 +10,7 @@ Canvas transitions gave the catalog effects that live at a cut. Filters are the### New components- [VHS Filter](/docs/filters/components/vhs-filter) — a scene held under analog tape. Colour bleeds sideways off every edge while brightness stays sharp, which is what separates tape from a blur; rows wander out of line on a slow drift with per-line jitter on top; the bottom of the frame tears where a real deck switches heads; luma noise and scanlines settle over all of it. Every knob is a plain number, so `intensity` can be interpolated to let a scene surface out of the wear.+- [Pixelate Region](/docs/filters/components/pixelate-region) — the practical one. Hand it rectangles in composition coordinates and everything inside them becomes an opaque mosaic, each cell the average of the picture under it, while the rest of the frame stays perfectly sharp. It is built so that failing open is impossible: the mosaic is composited over black at full alpha every frame, the CSS fallback degrades to a plain opaque block rather than an approximation, and passing more regions than can be covered throws instead of quietly dropping one. Record the real dashboard, cover the real key.- [Sustained Glitch](/docs/filters/components/sustained-glitch) — broadcast corruption held over a scene as scheduled bursts rather than a constant texture. Slices tear sideways on their own beats, channels pull apart, and blocks fill with picture dragged in from elsewhere in the frame; a few frames later it has decayed and the scene is untouched again until the next hit. `intensity` is read every frame, so the damage can be interpolated onto a beat. It is the sustained sibling of `glitch-cut` — the same look, living between the cuts instead of at one.- [CRT Screen](/docs/filters/components/crt-screen) — the scene put behind curved glass. The picture bulges outward so straight lines bow, an RGB phosphor mask breaks the colour into stripes, scanlines follow the curve instead of lying flat, bright areas flood the mask around them, and past the edge of the tube the corners fall away into real darkness rather than a hole. The pair splits cleanly: `vhs-filter` degrades the signal, `crt-screen` is the display it arrives on, and they stack.diff --git a/content/docs/filters/components/meta.json b/content/docs/filters/components/meta.jsonindex c3cc4bfc..e60d5fa2 100644--- a/content/docs/filters/components/meta.json+++ b/content/docs/filters/components/meta.json@@ -1,5 +1,5 @@{"title": "Filters","collapsible": false,- "pages": ["vhs-filter", "crt-screen", "sustained-glitch"]+ "pages": ["vhs-filter", "crt-screen", "sustained-glitch", "pixelate-region"]}diff --git a/content/docs/filters/components/pixelate-region.mdx b/content/docs/filters/components/pixelate-region.mdxnew file mode 100644index 00000000..9066f542--- /dev/null+++ b/content/docs/filters/components/pixelate-region.mdx@@ -0,0 +1,110 @@+---+title: Pixelate Region+description: Cover rectangles of a scene with an opaque mosaic and leave the rest untouched+component: pixelate-region+vibe: clean+length: sustained+useWhen:+ - "A product demo shows real data — API keys, tokens, email addresses, account numbers — that must not leave the building."+ - "You are recording a real dashboard or inbox and only part of the frame is sensitive, so the rest should stay perfectly sharp."+ - "The reveal is the point — something is deliberately hidden and the viewer should see that it was hidden."+avoidWhen:+ - "The whole frame wants a treatment rather than a covered rectangle — `vhs-filter` and `crt-screen` work edge to edge."+ - "What you are covering moves around the frame, since a region is a fixed rectangle and will slide off whatever it was over."+ - "You only want to de-emphasise something — a mosaic dense enough to redact is not a soft focus, and a soft focus is not a redaction."+---++<ComponentPreview name="pixelate-region" />++<CanvasFilterNote />++## Installation++<InstallBlock name="pixelate-region" />++## Usage++`PixelateRegion` is a wrapper. Give it rectangles in composition coordinates and+everything inside them is resampled into an opaque mosaic — each cell takes the+average of the picture under it — while the rest of the scene passes through+untouched.++```tsx+import { PixelateRegion } from "@/components/remocn/pixelate-region";++export const MyScene = () => (+ <PixelateRegion+ regions={[+ { x: 504, y: 332, width: 600, height: 72 },+ { x: 504, y: 444, width: 600, height: 72 },+ ]}+ >+ <Scene />+ </PixelateRegion>+);+```++Coordinates are in the same units as your composition — the `width` and `height`+you gave `<Composition>` — with the origin at the top left. Read them straight+off the frame you are covering.++## The redaction guarantee++This component is a utility, not an effect, and it is built so that failing open+is impossible.++Inside a region the output is always opaque. The untouched scene sits on a layer+directly beneath the filter's output, so anything less than full coverage would+show the original through — which for a mosaic over an API key is not a visual+glitch, it is a leak. The mosaic is therefore composited over black and written at+full alpha, every frame, on every path.++That includes the browsers that have no html-in-canvas at all. Where every other+filter in the pack degrades to an approximation of its look, this one degrades to+a plain opaque block over each region: less interesting, exactly as covering.++Passing more regions than can be covered at once throws rather than dropping the+extras, for the same reason — a silently ignored region is a visible secret.+Nest a second `PixelateRegion` if you need more than eight.++## Choosing a cell size++`cellSize` is the width of one mosaic square in composition units. Text stops+being readable well before it stops being recognisable, so err coarse: a cell+around a third of the cap height of the text you are covering leaves nothing to+reconstruct.++## Props++<PropsTable+ rows={[+ {+ name: "regions",+ type: "PixelateRect[]",+ description:+ "Rectangles to cover, as { x, y, width, height } in composition coordinates from the top-left origin. Up to eight; more throws rather than silently dropping any.",+ },+ {+ name: "cellSize",+ type: "number",+ default: "24",+ description:+ "Width of one mosaic square in composition units. Cells are square, and each one is the average of the picture under it rather than a single sample.",+ },+ {+ name: "children",+ type: "React.ReactNode",+ description: "The scene the filter wraps and re-reads every frame.",+ },+ ]}+/>++## Notes++Nothing here animates. The mosaic changes only when the scene under it does, so a+region over static content is pixel-identical from frame to frame and a region+over a moving dashboard tracks it.++The cell grid is anchored to each region's own top-left corner, so the mosaic+starts cleanly at the edge of what you are covering instead of inheriting a grid+from the frame.diff --git a/registry-artifacts/pixelate-region.json b/registry-artifacts/pixelate-region.jsonnew file mode 100644index 00000000..ff1cc7bb--- /dev/null+++ b/registry-artifacts/pixelate-region.json@@ -0,0 +1,17 @@+{+ "$schema": "https://ui.shadcn.com/schema/registry-item.json",+ "name": "pixelate-region",+ "title": "Pixelate Region",+ "description": "Cover rectangles of a scene with an opaque mosaic while the rest passes through untouched — redact keys, addresses and personal data before a demo goes out.",+ "dependencies": ["remotion"],+ "registryDependencies": ["@remocn/canvas-presentation"],+ "files": [+ {+ "path": "registry/remocn/pixelate-region/index.tsx",+ "content": "\"use client\";\n\nimport type React from \"react\";\nimport { AbsoluteFill, useVideoConfig } from \"remotion\";\nimport {\n type CanvasFilterProps,\n makeCanvasFilter,\n makeFilterShader,\n} from \"@/lib/remocn/canvas-presentation\";\n\nexport type PixelateRect = {\n x: number;\n y: number;\n width: number;\n height: number;\n};\n\nexport type PixelateRegionProps = {\n regions: PixelateRect[];\n cellSize?: number;\n};\n\nconst MAX_REGIONS = 8;\n\nconst DEFAULTS = {\n cellSize: 24,\n};\n\ntype NormalizedProps = {\n rects: PixelateRect[];\n cellX: number;\n cellY: number;\n};\n\nconst FRAGMENT_SHADER = `#version 300 es\nprecision highp float;\n\nuniform sampler2D u_scene;\nuniform vec4 u_regions[${MAX_REGIONS}];\nuniform int u_region_count;\nuniform vec2 u_cell;\n\nin vec2 v_uv;\nout vec4 outColor;\n\nconst int TAPS = 3;\n\nvec4 cellAverage(vec2 center, vec2 cell) {\n vec4 sum = vec4(0.0);\n for (int y = 0; y < TAPS; y++) {\n for (int x = 0; x < TAPS; x++) {\n vec2 offset =\n (vec2(float(x), float(y)) + 0.5) / float(TAPS) - 0.5;\n sum += texture(u_scene, center + offset * cell);\n }\n }\n return sum / float(TAPS * TAPS);\n}\n\nvoid main() {\n vec4 result = texture(u_scene, v_uv);\n vec2 cell = max(u_cell, vec2(0.0005));\n\n for (int i = 0; i < ${MAX_REGIONS}; i++) {\n if (i >= u_region_count) {\n continue;\n }\n vec4 region = u_regions[i];\n vec2 lo = region.xy;\n vec2 hi = region.xy + region.zw;\n vec2 hit = step(lo, v_uv) * step(v_uv, hi);\n if (hit.x * hit.y < 0.5) {\n continue;\n }\n vec2 center = lo + (floor((v_uv - lo) / cell) + 0.5) * cell;\n result = vec4(cellAverage(center, cell).rgb, 1.0);\n }\n\n outColor = result;\n}`;\n\nconst shader = makeFilterShader<NormalizedProps>(\n FRAGMENT_SHADER,\n ({ gl, uniform, passedProps }) => {\n const { rects, cellX, cellY } = passedProps;\n const packed = new Float32Array(MAX_REGIONS * 4);\n const count = Math.min(rects.length, MAX_REGIONS);\n for (let i = 0; i < count; i++) {\n const rect = rects[i];\n packed[i * 4] = rect.x;\n packed[i * 4 + 1] = rect.y;\n packed[i * 4 + 2] = rect.width;\n packed[i * 4 + 3] = rect.height;\n }\n gl.uniform4fv(uniform(\"u_regions[0]\"), packed);\n gl.uniform1i(uniform(\"u_region_count\"), count);\n gl.uniform2f(uniform(\"u_cell\"), cellX, cellY);\n },\n);\n\nconst PixelateRegionFallback: React.FC<NormalizedProps & CanvasFilterProps> = ({\n children,\n rects,\n}) => (\n <AbsoluteFill>\n {children}\n {rects.map((rect) => (\n <div\n key={`${rect.x}-${rect.y}-${rect.width}-${rect.height}`}\n style={{\n position: \"absolute\",\n left: `${rect.x * 100}%`,\n top: `${rect.y * 100}%`,\n width: `${rect.width * 100}%`,\n height: `${rect.height * 100}%`,\n background: \"#14161c\",\n }}\n />\n ))}\n </AbsoluteFill>\n);\n\nconst PixelateRegionCanvas = makeCanvasFilter<NormalizedProps>({\n shader,\n fallback: PixelateRegionFallback,\n});\n\nexport const PixelateRegion: React.FC<\n PixelateRegionProps & CanvasFilterProps\n> = ({ regions, cellSize = DEFAULTS.cellSize, children }) => {\n const { width, height } = useVideoConfig();\n\n if (regions.length > MAX_REGIONS) {\n throw new Error(\n `pixelate-region: at most ${MAX_REGIONS} regions can be covered at once, received ${regions.length}. Dropping any of them would leave what it covered visible, so nest a second PixelateRegion instead.`,\n );\n }\n\n const rects = regions.map((region) => ({\n x: region.x / width,\n y: region.y / height,\n width: region.width / width,\n height: region.height / height,\n }));\n\n return (\n <PixelateRegionCanvas\n rects={rects}\n cellX={cellSize / width}\n cellY={cellSize / height}\n >\n {children}\n </PixelateRegionCanvas>\n );\n};\n",+ "type": "registry:component",+ "target": "components/remocn/pixelate-region.tsx"+ }+ ],+ "type": "registry:component"+}diff --git a/registry-artifacts/registry.json b/registry-artifacts/registry.jsonindex 27053347..5909957d 100644--- a/registry-artifacts/registry.json+++ b/registry-artifacts/registry.json@@ -1674,6 +1674,21 @@],"type": "registry:component"},+ {+ "name": "pixelate-region",+ "title": "Pixelate Region",+ "description": "Cover rectangles of a scene with an opaque mosaic while the rest passes through untouched — redact keys, addresses and personal data before a demo goes out.",+ "dependencies": ["remotion"],+ "registryDependencies": ["@remocn/canvas-presentation"],+ "files": [+ {+ "path": "registry/remocn/pixelate-region/index.tsx",+ "type": "registry:component",+ "target": "components/remocn/pixelate-region.tsx"+ }+ ],+ "type": "registry:component"+ },{"name": "sustained-glitch","title": "Sustained Glitch",diff --git a/registry/__index__.tsx b/registry/__index__.tsxindex b233fcfd..b293afb0 100644--- a/registry/__index__.tsx+++ b/registry/__index__.tsx@@ -58,6 +58,7 @@ import { perCharacterRiseConfig } from "@/registry/remocn/per-character-rise/conimport { perWordCrossfadeConfig } from "@/registry/remocn/per-word-crossfade/config";import { perlinDissolveConfig } from "@/registry/remocn/perlin-dissolve/config";import { perspectiveMarqueeConfig } from "@/registry/remocn/perspective-marquee/config";+import { pixelateRegionConfig } from "@/registry/remocn/pixelate-region/config";import { polaroidConfig } from "@/registry/remocn/polaroid/config";import { progressStepsConfig } from "@/registry/remocn/progress-steps/config";import { pushThroughConfig } from "@/registry/remocn/push-through/config";@@ -1481,6 +1482,13 @@ const registry: Record<string, RegistryEntry> = {),config: sustainedGlitchConfig,},+ "pixelate-region": {+ load: () =>+ import("@/components/docs/examples/pixelate-region-example").then(+ (m) => ({ default: m.PixelateRegionExampleScene }),+ ),+ config: pixelateRegionConfig,+ },"slide-swap": {load: () =>import("@/components/docs/examples/slide-swap-example").then((m) => ({diff --git a/registry/remocn/pixelate-region/config.ts b/registry/remocn/pixelate-region/config.tsnew file mode 100644index 00000000..bdcd54bf--- /dev/null+++ b/registry/remocn/pixelate-region/config.ts@@ -0,0 +1,23 @@+import { pixelateRegionExampleCode } from "@/components/docs/examples/pixelate-region-example";+import { type ComponentConfig, FPS, H, W } from "@/lib/customizer-config";++export const pixelateRegionConfig: ComponentConfig = {+ componentName: "PixelateRegion",+ importPath: "@/components/remocn/pixelate-region",+ controls: {+ cellSize: {+ type: "number",+ default: 24,+ min: 6,+ max: 72,+ step: 2,+ label: "Cell size",+ },+ },+ durationInFrames: 90,+ fps: FPS,+ compositionWidth: W,+ compositionHeight: H,+ previewBackdrop: { type: "color", value: "#0a0a0a" },+ snippet: pixelateRegionExampleCode,+};diff --git a/registry/remocn/pixelate-region/index.tsx b/registry/remocn/pixelate-region/index.tsxnew file mode 100644index 00000000..aadc87ad--- /dev/null+++ b/registry/remocn/pixelate-region/index.tsx@@ -0,0 +1,155 @@+"use client";++import type React from "react";+import { AbsoluteFill, useVideoConfig } from "remotion";+import {+ type CanvasFilterProps,+ makeCanvasFilter,+ makeFilterShader,+} from "@/lib/remocn/canvas-presentation";++export type PixelateRect = {+ x: number;+ y: number;+ width: number;+ height: number;+};++export type PixelateRegionProps = {+ regions: PixelateRect[];+ cellSize?: number;+};++const MAX_REGIONS = 8;++const DEFAULTS = {+ cellSize: 24,+};++type NormalizedProps = {+ rects: PixelateRect[];+ cellX: number;+ cellY: number;+};++const FRAGMENT_SHADER = `#version 300 es+precision highp float;++uniform sampler2D u_scene;+uniform vec4 u_regions[${MAX_REGIONS}];+uniform int u_region_count;+uniform vec2 u_cell;++in vec2 v_uv;+out vec4 outColor;++const int TAPS = 3;++vec4 cellAverage(vec2 center, vec2 cell) {+ vec4 sum = vec4(0.0);+ for (int y = 0; y < TAPS; y++) {+ for (int x = 0; x < TAPS; x++) {+ vec2 offset =+ (vec2(float(x), float(y)) + 0.5) / float(TAPS) - 0.5;+ sum += texture(u_scene, center + offset * cell);+ }+ }+ return sum / float(TAPS * TAPS);+}++void main() {+ vec4 result = texture(u_scene, v_uv);+ vec2 cell = max(u_cell, vec2(0.0005));++ for (int i = 0; i < ${MAX_REGIONS}; i++) {+ if (i >= u_region_count) {+ continue;+ }+ vec4 region = u_regions[i];+ vec2 lo = region.xy;+ vec2 hi = region.xy + region.zw;+ vec2 hit = step(lo, v_uv) * step(v_uv, hi);+ if (hit.x * hit.y < 0.5) {+ continue;+ }+ vec2 center = lo + (floor((v_uv - lo) / cell) + 0.5) * cell;+ result = vec4(cellAverage(center, cell).rgb, 1.0);+ }++ outColor = result;+}`;++const shader = makeFilterShader<NormalizedProps>(+ FRAGMENT_SHADER,+ ({ gl, uniform, passedProps }) => {+ const { rects, cellX, cellY } = passedProps;+ const packed = new Float32Array(MAX_REGIONS * 4);+ const count = Math.min(rects.length, MAX_REGIONS);+ for (let i = 0; i < count; i++) {+ const rect = rects[i];+ packed[i * 4] = rect.x;+ packed[i * 4 + 1] = rect.y;+ packed[i * 4 + 2] = rect.width;+ packed[i * 4 + 3] = rect.height;+ }+ gl.uniform4fv(uniform("u_regions[0]"), packed);+ gl.uniform1i(uniform("u_region_count"), count);+ gl.uniform2f(uniform("u_cell"), cellX, cellY);+ },+);++const PixelateRegionFallback: React.FC<NormalizedProps & CanvasFilterProps> = ({+ children,+ rects,+}) => (+ <AbsoluteFill>+ {children}+ {rects.map((rect) => (+ <div+ key={`${rect.x}-${rect.y}-${rect.width}-${rect.height}`}+ style={{+ position: "absolute",+ left: `${rect.x * 100}%`,+ top: `${rect.y * 100}%`,+ width: `${rect.width * 100}%`,+ height: `${rect.height * 100}%`,+ background: "#14161c",+ }}+ />+ ))}+ </AbsoluteFill>+);++const PixelateRegionCanvas = makeCanvasFilter<NormalizedProps>({+ shader,+ fallback: PixelateRegionFallback,+});++export const PixelateRegion: React.FC<+ PixelateRegionProps & CanvasFilterProps+> = ({ regions, cellSize = DEFAULTS.cellSize, children }) => {+ const { width, height } = useVideoConfig();++ if (regions.length > MAX_REGIONS) {+ throw new Error(+ `pixelate-region: at most ${MAX_REGIONS} regions can be covered at once, received ${regions.length}. Dropping any of them would leave what it covered visible, so nest a second PixelateRegion instead.`,+ );+ }++ const rects = regions.map((region) => ({+ x: region.x / width,+ y: region.y / height,+ width: region.width / width,+ height: region.height / height,+ }));++ return (+ <PixelateRegionCanvas+ rects={rects}+ cellX={cellSize / width}+ cellY={cellSize / height}+ >+ {children}+ </PixelateRegionCanvas>+ );+};diff --git a/registry/remocn/registry.json b/registry/remocn/registry.jsonindex 21a6dd27..4032af37 100644--- a/registry/remocn/registry.json+++ b/registry/remocn/registry.json@@ -1674,6 +1674,21 @@}]},+ {+ "name": "pixelate-region",+ "type": "registry:component",+ "title": "Pixelate Region",+ "description": "Cover rectangles of a scene with an opaque mosaic while the rest passes through untouched — redact keys, addresses and personal data before a demo goes out.",+ "dependencies": ["remotion"],+ "registryDependencies": ["@remocn/canvas-presentation"],+ "files": [+ {+ "path": "pixelate-region/index.tsx",+ "type": "registry:component",+ "target": "components/remocn/pixelate-region.tsx"+ }+ ]+ },{"name": "sustained-glitch","type": "registry:component",diff --git a/src/remotion/canvas-spike-root.tsx b/src/remotion/canvas-spike-root.tsxindex 06ff1049..b48e0fdc 100644--- a/src/remotion/canvas-spike-root.tsx+++ b/src/remotion/canvas-spike-root.tsx@@ -12,6 +12,7 @@ import { EmberBurnExampleScene } from "@/components/docs/examples/ember-burn-exaimport { GlitchCutExampleScene } from "@/components/docs/examples/glitch-cut-example";import { GridWaveExampleScene } from "@/components/docs/examples/grid-wave-example";import { ParticleDissolveExampleScene } from "@/components/docs/examples/particle-dissolve-example";+import { PixelateRegionExampleScene } from "@/components/docs/examples/pixelate-region-example";import { SustainedGlitchExampleScene } from "@/components/docs/examples/sustained-glitch-example";import { VhsFilterExampleScene } from "@/components/docs/examples/vhs-filter-example";import type { ComponentConfig } from "@/lib/customizer-config";@@ -21,6 +22,7 @@ import { emberBurnConfig } from "@/registry/remocn/ember-burn/config";import { glitchCutConfig } from "@/registry/remocn/glitch-cut/config";import { gridWaveConfig } from "@/registry/remocn/grid-wave/config";import { particleDissolveConfig } from "@/registry/remocn/particle-dissolve/config";+import { pixelateRegionConfig } from "@/registry/remocn/pixelate-region/config";import { sustainedGlitchConfig } from "@/registry/remocn/sustained-glitch/config";import { vhsFilterConfig } from "@/registry/remocn/vhs-filter/config";@@ -54,6 +56,10 @@ const SCENES: Record<Scene: SustainedGlitchExampleScene,config: sustainedGlitchConfig,},+ "pixelate-region": {+ Scene: PixelateRegionExampleScene,+ config: pixelateRegionConfig,+ },};function makeStage(Scene: ComponentType) {