agentcut 0.2.26 → 0.2.27

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (94) hide show
  1. package/README.md +177 -177
  2. package/dist/studio/agents/claude.js +3 -2
  3. package/dist/studio/agents/claude.js.map +1 -1
  4. package/dist/studio/chat.js +1 -1
  5. package/dist/studio/chat.js.map +1 -1
  6. package/dist/studio/cli.js +24 -24
  7. package/dist/studio/download.d.ts +24 -0
  8. package/dist/studio/download.js +234 -0
  9. package/dist/studio/download.js.map +1 -0
  10. package/dist/studio/host.js +8 -0
  11. package/dist/studio/host.js.map +1 -1
  12. package/dist/studio/housekeeping.d.ts +2 -2
  13. package/dist/studio/housekeeping.js +18 -17
  14. package/dist/studio/housekeeping.js.map +1 -1
  15. package/dist/studio/release-cursor.js +21 -21
  16. package/dist/studio/release-video.js +10 -10
  17. package/dist/studio/tools.js +7 -0
  18. package/dist/studio/tools.js.map +1 -1
  19. package/package.json +56 -56
  20. package/template/AGENTS.md +14 -14
  21. package/template/components/README.md +70 -70
  22. package/template/components/before-after/BeforeAfter.tsx +89 -89
  23. package/template/components/catalog.ts +107 -107
  24. package/template/components/cinematic/Device3D.tsx +324 -324
  25. package/template/components/cinematic/devices3d/display-model.ts +184 -184
  26. package/template/components/cinematic/devices3d/iphone-model.ts +643 -643
  27. package/template/components/cinematic/devices3d/macbook-model.ts +608 -608
  28. package/template/components/cinematic/devices3d/models.ts +657 -657
  29. package/template/components/cinematic/devices3d/runtime.ts +267 -267
  30. package/template/components/cinematic/math.ts +100 -100
  31. package/template/components/color/grade-effect.ts +650 -650
  32. package/template/components/color/grade.ts +512 -512
  33. package/template/components/color/looks.ts +154 -154
  34. package/template/components/countdown/Countdown.tsx +166 -166
  35. package/template/components/dot-trace-title/DotTraceTitle.tsx +181 -181
  36. package/template/components/dot-trace-title/meta.json +51 -51
  37. package/template/components/generate/GenerateReveal.tsx +381 -381
  38. package/template/components/hook-card/HookCard.tsx +554 -554
  39. package/template/components/index.ts +199 -199
  40. package/template/components/lib.ts +191 -191
  41. package/template/components/line-diagram/LineDiagram.tsx +205 -205
  42. package/template/components/line-diagram/meta.json +215 -215
  43. package/template/components/list-card/ListCard.tsx +104 -104
  44. package/template/components/live-clip.ts +75 -75
  45. package/template/components/looks.tsx +1447 -1447
  46. package/template/components/loops/LoopCanvas.tsx +132 -132
  47. package/template/components/loops/engine.ts +184 -184
  48. package/template/components/loops/library.ts +667 -667
  49. package/template/components/loops/library2.ts +777 -777
  50. package/template/components/motion-loop/MotionLoop.tsx +37 -37
  51. package/template/components/motion-loop/meta.json +311 -311
  52. package/template/components/props.ts +73 -73
  53. package/template/components/quote-card/QuoteCard.tsx +71 -71
  54. package/template/components/style-layer.tsx +233 -233
  55. package/template/components/styles.ts +113 -113
  56. package/template/components/types.ts +66 -66
  57. package/template/components/word-pop/WordPop.tsx +59 -59
  58. package/template/components/word-stack/WordStack.tsx +122 -122
  59. package/template/presets/charcoal-sketch/PROMPT.md +48 -48
  60. package/template/presets/charcoal-sketch/scripts/duck_music.py +34 -34
  61. package/template/presets/punk-cut-paper/scenes/Motif.tsx +376 -376
  62. package/template/presets/punk-cut-paper/scenes/Photo.tsx +73 -73
  63. package/template/presets/punk-cut-paper/scenes/Ransom.tsx +119 -119
  64. package/template/runtime/composition.tsx +1189 -1189
  65. package/template/runtime/helpers.tsx +230 -230
  66. package/template/runtime/index.tsx +22 -22
  67. package/template/runtime/types.ts +315 -315
  68. package/template/skill/SKILL.md +186 -187
  69. package/template/skill/references/broll.md +44 -44
  70. package/template/skill/references/browser-export.md +61 -61
  71. package/template/skill/references/cinematic.md +206 -206
  72. package/template/skill/references/color.md +79 -79
  73. package/template/skill/references/craft.md +97 -97
  74. package/template/skill/references/editing-styles.md +57 -57
  75. package/template/skill/references/feature-launch.md +34 -34
  76. package/template/skill/references/footage.md +72 -72
  77. package/template/skill/references/format.md +142 -142
  78. package/template/skill/references/how-to.md +146 -146
  79. package/template/skill/references/launch-direction.md +89 -89
  80. package/template/skill/references/loops.md +151 -151
  81. package/template/skill/references/mcp-external.md +19 -19
  82. package/template/skill/references/performance.md +93 -93
  83. package/template/skill/references/person-cutout.md +19 -19
  84. package/template/skill/references/presets.md +60 -60
  85. package/template/skill/references/product-launch.md +134 -134
  86. package/template/skill/references/release-capture.md +53 -53
  87. package/template/skill/references/sound.md +167 -166
  88. package/template/skill/references/style-spy.md +160 -160
  89. package/template/skill/references/website-howto.md +45 -45
  90. package/template/starter/.studio/chat.json +1 -1
  91. package/template/starter/layers.json +46 -46
  92. package/template/starter/notes.md +4 -4
  93. package/template/starter/project.json +13 -13
  94. package/template/starter/scenes/Title.tsx +38 -38
@@ -1,132 +1,132 @@
1
- // Draws a seamless loop (or your own draw function) on a canvas for the current frame.
2
- import { useLayoutEffect, useRef, type CSSProperties } from "react";
3
- import { useCurrentFrame, useRemotionEnvironment, useVideoConfig } from "remotion";
4
- import { LOOP, loopPalette, M, type LoopDraw, type LoopPalette, type LoopTone } from "./engine";
5
- import { getLoop } from "./library";
6
-
7
- export interface LoopCanvasProps {
8
- /** A library loop id (see LOOPS) or your own draw function with the same contract. */
9
- loop: string | LoopDraw;
10
- /** Brand colours; the palette's three tones derive from them. */
11
- accent?: string;
12
- accent2?: string;
13
- tone?: LoopTone;
14
- /** Or a full palette (overrides accent, accent2 and tone). */
15
- palette?: LoopPalette;
16
- /** Playback speed (1 = the loop's 12 s cycle). Seamless at any speed; to repeat a clip, make duration × speed a multiple of 12 s. */
17
- speed?: number;
18
- /** Shifts where in the cycle it starts (seconds). */
19
- offset?: number;
20
- /** Varies the layout of the loop's elements. */
21
- seed?: number;
22
- /** Don't fill the background (shapes over footage or a Stage). */
23
- transparent?: boolean;
24
- /** Motion blur sub-frames in captures and exports (1 = none, 4 default, 8 for fast loops); the live preview draws 1. */
25
- blur?: number;
26
- /**
27
- * Size in world px. Without them the loop is frame-sized and stretches to fill its parent (a
28
- * full-frame parent, or one with the frame's aspect). With them it is drawn at exactly that size
29
- * (CSS too), so it never distorts: pass the size of the box it sits in (a card, a Plane).
30
- */
31
- width?: number;
32
- height?: number;
33
- style?: CSSProperties;
34
- }
35
-
36
- /** A seamless motion loop drawn from the brand palette, frame-accurate in preview and export. */
37
- export function LoopCanvas({
38
- loop,
39
- accent = "#7c5cff",
40
- accent2 = "#ff5ca8",
41
- tone = "dark",
42
- palette,
43
- speed = 1,
44
- offset = 0,
45
- seed = 0,
46
- transparent = false,
47
- blur = 4,
48
- width,
49
- height,
50
- style,
51
- }: LoopCanvasProps) {
52
- const frame = useCurrentFrame();
53
- const config = useVideoConfig();
54
- const env = useRemotionEnvironment();
55
- const ref = useRef<HTMLCanvasElement>(null);
56
- const scratch = useRef<HTMLCanvasElement | null>(null);
57
- const acc = useRef<Float32Array | null>(null);
58
- const w = Math.round(width ?? config.width);
59
- const h = Math.round(height ?? config.height);
60
- const draw = typeof loop === "function" ? loop : getLoop(loop).draw;
61
- const P = palette ?? loopPalette(accent, accent2, tone);
62
- // The live preview skips motion blur; captures and exports draw every sub-frame.
63
- const samples = env.isPlayer && !env.isRendering ? 1 : Math.max(1, Math.min(12, Math.round(blur)));
64
-
65
- useLayoutEffect(() => {
66
- const canvas = ref.current;
67
- const ctx = canvas?.getContext("2d");
68
- if (!canvas || !ctx) return;
69
- const paint = (target: CanvasRenderingContext2D, t: number) => {
70
- target.save();
71
- target.clearRect(0, 0, w, h);
72
- if (!transparent) {
73
- target.fillStyle = P.bg;
74
- target.fillRect(0, 0, w, h);
75
- }
76
- draw(target, w, h, ((t % LOOP) + LOOP) % LOOP, P, M, seed);
77
- target.restore();
78
- };
79
- const t0 = (frame / config.fps) * speed + offset;
80
- if (samples === 1) {
81
- paint(ctx, t0);
82
- return;
83
- }
84
- // Average sub-frames across a 180° shutter (half a frame), in premultiplied float so transparent
85
- // pixels average correctly and 8-bit rounding happens once.
86
- scratch.current ??= document.createElement("canvas");
87
- const sc = scratch.current;
88
- if (sc.width !== w || sc.height !== h) {
89
- sc.width = w;
90
- sc.height = h;
91
- }
92
- const sctx = sc.getContext("2d", { willReadFrequently: true });
93
- if (!sctx) return;
94
- if (acc.current?.length !== w * h * 4) acc.current = new Float32Array(w * h * 4);
95
- const sum = acc.current;
96
- sum.fill(0);
97
- for (let i = 0; i < samples; i++) {
98
- const dt = ((i + 0.5) / samples - 0.5) * 0.5 * (speed / config.fps);
99
- paint(sctx, t0 + dt);
100
- const d = sctx.getImageData(0, 0, w, h).data;
101
- for (let p = 0; p < d.length; p += 4) {
102
- const a = d[p + 3];
103
- if (!a) continue;
104
- sum[p] += d[p] * a;
105
- sum[p + 1] += d[p + 1] * a;
106
- sum[p + 2] += d[p + 2] * a;
107
- sum[p + 3] += a;
108
- }
109
- }
110
- const out = ctx.createImageData(w, h);
111
- const o = out.data;
112
- for (let p = 0; p < o.length; p += 4) {
113
- const a = sum[p + 3];
114
- if (!a) continue;
115
- o[p] = sum[p] / a;
116
- o[p + 1] = sum[p + 1] / a;
117
- o[p + 2] = sum[p + 2] / a;
118
- o[p + 3] = a / samples;
119
- }
120
- ctx.putImageData(out, 0, 0);
121
- });
122
-
123
- const sized = width !== undefined || height !== undefined;
124
- return (
125
- <canvas
126
- ref={ref}
127
- width={w}
128
- height={h}
129
- style={{ position: "absolute", left: 0, top: 0, width: sized ? w : "100%", height: sized ? h : "100%", ...style }}
130
- />
131
- );
132
- }
1
+ // Draws a seamless loop (or your own draw function) on a canvas for the current frame.
2
+ import { useLayoutEffect, useRef, type CSSProperties } from "react";
3
+ import { useCurrentFrame, useRemotionEnvironment, useVideoConfig } from "remotion";
4
+ import { LOOP, loopPalette, M, type LoopDraw, type LoopPalette, type LoopTone } from "./engine";
5
+ import { getLoop } from "./library";
6
+
7
+ export interface LoopCanvasProps {
8
+ /** A library loop id (see LOOPS) or your own draw function with the same contract. */
9
+ loop: string | LoopDraw;
10
+ /** Brand colours; the palette's three tones derive from them. */
11
+ accent?: string;
12
+ accent2?: string;
13
+ tone?: LoopTone;
14
+ /** Or a full palette (overrides accent, accent2 and tone). */
15
+ palette?: LoopPalette;
16
+ /** Playback speed (1 = the loop's 12 s cycle). Seamless at any speed; to repeat a clip, make duration × speed a multiple of 12 s. */
17
+ speed?: number;
18
+ /** Shifts where in the cycle it starts (seconds). */
19
+ offset?: number;
20
+ /** Varies the layout of the loop's elements. */
21
+ seed?: number;
22
+ /** Don't fill the background (shapes over footage or a Stage). */
23
+ transparent?: boolean;
24
+ /** Motion blur sub-frames in captures and exports (1 = none, 4 default, 8 for fast loops); the live preview draws 1. */
25
+ blur?: number;
26
+ /**
27
+ * Size in world px. Without them the loop is frame-sized and stretches to fill its parent (a
28
+ * full-frame parent, or one with the frame's aspect). With them it is drawn at exactly that size
29
+ * (CSS too), so it never distorts: pass the size of the box it sits in (a card, a Plane).
30
+ */
31
+ width?: number;
32
+ height?: number;
33
+ style?: CSSProperties;
34
+ }
35
+
36
+ /** A seamless motion loop drawn from the brand palette, frame-accurate in preview and export. */
37
+ export function LoopCanvas({
38
+ loop,
39
+ accent = "#7c5cff",
40
+ accent2 = "#ff5ca8",
41
+ tone = "dark",
42
+ palette,
43
+ speed = 1,
44
+ offset = 0,
45
+ seed = 0,
46
+ transparent = false,
47
+ blur = 4,
48
+ width,
49
+ height,
50
+ style,
51
+ }: LoopCanvasProps) {
52
+ const frame = useCurrentFrame();
53
+ const config = useVideoConfig();
54
+ const env = useRemotionEnvironment();
55
+ const ref = useRef<HTMLCanvasElement>(null);
56
+ const scratch = useRef<HTMLCanvasElement | null>(null);
57
+ const acc = useRef<Float32Array | null>(null);
58
+ const w = Math.round(width ?? config.width);
59
+ const h = Math.round(height ?? config.height);
60
+ const draw = typeof loop === "function" ? loop : getLoop(loop).draw;
61
+ const P = palette ?? loopPalette(accent, accent2, tone);
62
+ // The live preview skips motion blur; captures and exports draw every sub-frame.
63
+ const samples = env.isPlayer && !env.isRendering ? 1 : Math.max(1, Math.min(12, Math.round(blur)));
64
+
65
+ useLayoutEffect(() => {
66
+ const canvas = ref.current;
67
+ const ctx = canvas?.getContext("2d");
68
+ if (!canvas || !ctx) return;
69
+ const paint = (target: CanvasRenderingContext2D, t: number) => {
70
+ target.save();
71
+ target.clearRect(0, 0, w, h);
72
+ if (!transparent) {
73
+ target.fillStyle = P.bg;
74
+ target.fillRect(0, 0, w, h);
75
+ }
76
+ draw(target, w, h, ((t % LOOP) + LOOP) % LOOP, P, M, seed);
77
+ target.restore();
78
+ };
79
+ const t0 = (frame / config.fps) * speed + offset;
80
+ if (samples === 1) {
81
+ paint(ctx, t0);
82
+ return;
83
+ }
84
+ // Average sub-frames across a 180° shutter (half a frame), in premultiplied float so transparent
85
+ // pixels average correctly and 8-bit rounding happens once.
86
+ scratch.current ??= document.createElement("canvas");
87
+ const sc = scratch.current;
88
+ if (sc.width !== w || sc.height !== h) {
89
+ sc.width = w;
90
+ sc.height = h;
91
+ }
92
+ const sctx = sc.getContext("2d", { willReadFrequently: true });
93
+ if (!sctx) return;
94
+ if (acc.current?.length !== w * h * 4) acc.current = new Float32Array(w * h * 4);
95
+ const sum = acc.current;
96
+ sum.fill(0);
97
+ for (let i = 0; i < samples; i++) {
98
+ const dt = ((i + 0.5) / samples - 0.5) * 0.5 * (speed / config.fps);
99
+ paint(sctx, t0 + dt);
100
+ const d = sctx.getImageData(0, 0, w, h).data;
101
+ for (let p = 0; p < d.length; p += 4) {
102
+ const a = d[p + 3];
103
+ if (!a) continue;
104
+ sum[p] += d[p] * a;
105
+ sum[p + 1] += d[p + 1] * a;
106
+ sum[p + 2] += d[p + 2] * a;
107
+ sum[p + 3] += a;
108
+ }
109
+ }
110
+ const out = ctx.createImageData(w, h);
111
+ const o = out.data;
112
+ for (let p = 0; p < o.length; p += 4) {
113
+ const a = sum[p + 3];
114
+ if (!a) continue;
115
+ o[p] = sum[p] / a;
116
+ o[p + 1] = sum[p + 1] / a;
117
+ o[p + 2] = sum[p + 2] / a;
118
+ o[p + 3] = a / samples;
119
+ }
120
+ ctx.putImageData(out, 0, 0);
121
+ });
122
+
123
+ const sized = width !== undefined || height !== undefined;
124
+ return (
125
+ <canvas
126
+ ref={ref}
127
+ width={w}
128
+ height={h}
129
+ style={{ position: "absolute", left: 0, top: 0, width: sized ? w : "100%", height: sized ? h : "100%", ...style }}
130
+ />
131
+ );
132
+ }
@@ -1,184 +1,184 @@
1
- // Seamless motion loops: each loop is a pure function of time drawn on a 2D canvas. Every motion in a
2
- // loop repeats with a period that divides LOOP (12 s), so the frame at 12 s is the frame at 0 s and a
3
- // loop can run under a clip of any length, or repeat, without a seam. No React here.
4
-
5
- /** The loop length in seconds. Periods must divide it: 1, 1.5, 2, 3, 4, 6, 12. */
6
- export const LOOP = 12;
7
- export const TAU = Math.PI * 2;
8
-
9
- export const clamp = (v: number, a = 0, b = 1) => Math.min(b, Math.max(a, v));
10
- /** Fractional part in [0, 1): a tiny negative (float error) gives 0, never 1, so it is safe to index with. */
11
- export const fract = (v: number) => {
12
- const f = v - Math.floor(v);
13
- return f < 1 ? f : 0;
14
- };
15
- /** Modulo that stays positive. */
16
- export const mod = (a: number, n: number) => ((a % n) + n) % n;
17
- export const lerp = (a: number, b: number, k: number) => a + (b - a) * k;
18
-
19
- /** 0…1 position inside a cycle of `period` seconds (offset in cycles). */
20
- export const phase = (t: number, period: number, offset = 0) => fract(t / period + offset);
21
-
22
- /** A fixed pseudo-random number in [0, 1) per element index and salt (never Math.random). */
23
- export function rand(i: number, salt = 0) {
24
- return fract(Math.sin(i * 127.1 + salt * 311.7 + 74.7) * 43758.5453123);
25
- }
26
-
27
- /** 0 before a, eases 0→1 between a and b (as a linear 0…1), 1 after b. */
28
- export const win = (p: number, a: number, b: number) => clamp((p - a) / Math.max(1e-6, b - a));
29
-
30
- export const smoothstep = (a: number, b: number, v: number) => {
31
- const x = clamp((v - a) / (b - a));
32
- return x * x * (3 - 2 * x);
33
- };
34
-
35
- export const ease = {
36
- linear: (k: number) => k,
37
- inSine: (k: number) => 1 - Math.cos((k * Math.PI) / 2),
38
- outSine: (k: number) => Math.sin((k * Math.PI) / 2),
39
- inOutSine: (k: number) => -(Math.cos(Math.PI * k) - 1) / 2,
40
- inCubic: (k: number) => k * k * k,
41
- outCubic: (k: number) => 1 - Math.pow(1 - k, 3),
42
- inOutCubic: (k: number) => (k < 0.5 ? 4 * k * k * k : 1 - Math.pow(-2 * k + 2, 3) / 2),
43
- outExpo: (k: number) => (k >= 1 ? 1 : 1 - Math.pow(2, -10 * k)),
44
- inOutExpo: (k: number) =>
45
- k <= 0 ? 0 : k >= 1 ? 1 : k < 0.5 ? Math.pow(2, 20 * k - 10) / 2 : (2 - Math.pow(2, -20 * k + 10)) / 2,
46
- outBack: (k: number, s = 1.70158) => 1 + (s + 1) * Math.pow(k - 1, 3) + s * Math.pow(k - 1, 2),
47
- inBack: (k: number, s = 1.70158) => (s + 1) * k * k * k - s * k * k,
48
- /** Settles from 0 to 1 with a wobble; exactly 1 at k = 1. */
49
- spring: (k: number, zeta = 0.35, freq = 3) => {
50
- if (k >= 1) return 1;
51
- const w = TAU * freq;
52
- const v = 1 - Math.exp(-zeta * w * k) * Math.cos(w * Math.sqrt(1 - zeta * zeta) * k);
53
- return lerp(v, 1, smoothstep(0.75, 1, k));
54
- },
55
- };
56
-
57
- /** Smooth noise that repeats every `period` seconds (sines on a circle): drift, sway, breathing. */
58
- export function loopNoise(t: number, seed = 0, period = LOOP) {
59
- const a = TAU * phase(t, period);
60
- return (
61
- Math.sin(a + rand(seed, 1) * TAU) * 0.5 +
62
- Math.sin(2 * a + rand(seed, 2) * TAU) * 0.3 +
63
- Math.sin(3 * a + rand(seed, 3) * TAU) * 0.2
64
- );
65
- }
66
-
67
- /** Perspective projection, divided by depth once. */
68
- export function proj(x: number, y: number, z: number, f: number, cx: number, cy: number) {
69
- const s = f / Math.max(1e-3, z);
70
- return { x: cx + x * s, y: cy + y * s, s };
71
- }
72
-
73
- // ─── Colour ──────────────────────────────────────────────────────────────────────────────────────
74
-
75
- function parse(c: string): [number, number, number] {
76
- const hex = /^#?([0-9a-f]{3}|[0-9a-f]{6})$/i.exec(c.trim());
77
- if (hex) {
78
- const h = hex[1].length === 3 ? hex[1].replace(/./g, (x) => x + x) : hex[1];
79
- const n = parseInt(h, 16);
80
- return [(n >> 16) & 255, (n >> 8) & 255, n & 255];
81
- }
82
- const rgb = /rgba?\(([^)]+)\)/i.exec(c);
83
- if (rgb) {
84
- const [r, g, b] = rgb[1].split(",").map((v) => parseFloat(v));
85
- return [r || 0, g || 0, b || 0];
86
- }
87
- return [0, 0, 0];
88
- }
89
-
90
- /** A colour (hex or rgb()) at an alpha. */
91
- export function rgba(c: string, a: number) {
92
- const [r, g, b] = parse(c);
93
- return `rgba(${r},${g},${b},${clamp(a)})`;
94
- }
95
-
96
- /** Mix two colours (hex or rgb()). */
97
- export function mixColor(a: string, b: string, k: number) {
98
- const x = parse(a);
99
- const y = parse(b);
100
- return `rgb(${Math.round(lerp(x[0], y[0], k))},${Math.round(lerp(x[1], y[1], k))},${Math.round(lerp(x[2], y[2], k))})`;
101
- }
102
-
103
- const luma = (c: string) => {
104
- const [r, g, b] = parse(c);
105
- return (0.299 * r + 0.587 * g + 0.114 * b) / 255;
106
- };
107
-
108
- export type LoopTone = "dark" | "accent" | "light";
109
-
110
- /** The palette a loop draws with. Never use other colours inside a loop. */
111
- export interface LoopPalette {
112
- /** Filled before draw() unless the loop is transparent. */
113
- bg: string;
114
- /** Main motif. */
115
- fg: string;
116
- /** Second colour, sparingly. */
117
- fg2: string;
118
- /** Between bg and fg: grids, quiet details. */
119
- mid: string;
120
- accent: string;
121
- accent2: string;
122
- paper: string;
123
- ink: string;
124
- tone: LoopTone;
125
- }
126
-
127
- /**
128
- * Three tones from the brand colours: dark (deep brand-tinted background, accent motif), accent
129
- * (accent background, ink motif), light (paper background, ink motif, accent as the second colour).
130
- */
131
- export function loopPalette(accent: string, accent2: string, tone: LoopTone, paper = "#f5f3ee", ink = "#111216"): LoopPalette {
132
- if (tone === "accent") {
133
- const onAccent = luma(accent) > 0.6 ? ink : paper;
134
- return { bg: accent, fg: onAccent, fg2: accent2, mid: mixColor(accent, onAccent, 0.3), accent, accent2, paper, ink, tone };
135
- }
136
- if (tone === "light") {
137
- return { bg: paper, fg: ink, fg2: accent, mid: mixColor(paper, ink, 0.18), accent, accent2, paper, ink, tone };
138
- }
139
- const bg = mixColor(accent, "#07070b", 0.9);
140
- return { bg, fg: accent, fg2: accent2, mid: mixColor(bg, accent, 0.28), accent, accent2, paper, ink, tone };
141
- }
142
-
143
- /** What a loop's draw() receives besides the context. */
144
- export interface LoopHelpers {
145
- phase: typeof phase;
146
- rand: typeof rand;
147
- win: typeof win;
148
- ease: typeof ease;
149
- loopNoise: typeof loopNoise;
150
- proj: typeof proj;
151
- rgba: typeof rgba;
152
- mixColor: typeof mixColor;
153
- smoothstep: typeof smoothstep;
154
- clamp: typeof clamp;
155
- fract: typeof fract;
156
- mod: typeof mod;
157
- lerp: typeof lerp;
158
- TAU: number;
159
- LOOP: number;
160
- }
161
-
162
- export const M: LoopHelpers = { phase, rand, win, ease, loopNoise, proj, rgba, mixColor, smoothstep, clamp, fract, mod, lerp, TAU, LOOP };
163
-
164
- /**
165
- * draw(ctx, w, h, t, P, M): paint the frame at t seconds (0 ≤ t < 12). The background is already
166
- * filled (unless transparent). Sizes from u = h / 100 (min(w, h) for shapes); counts from w.
167
- * `seed` varies element layouts so the same loop can look different per video.
168
- */
169
- export type LoopDraw = (ctx: CanvasRenderingContext2D, w: number, h: number, t: number, P: LoopPalette, M: LoopHelpers, seed: number) => void;
170
-
171
- export const LOOP_CATEGORIES = ["Backgrounds", "Shapes", "Symmetry", "Morphing", "Games", "Physics", "Generative"] as const;
172
- export type LoopCategory = (typeof LOOP_CATEGORIES)[number];
173
-
174
- export interface LoopDef {
175
- id: string;
176
- name: string;
177
- kind: "background" | "shape";
178
- /** Gallery group (defaults from kind). */
179
- category?: LoopCategory;
180
- /** What it looks like and when it works (Claude reads this). */
181
- description: string;
182
- tags: string[];
183
- draw: LoopDraw;
184
- }
1
+ // Seamless motion loops: each loop is a pure function of time drawn on a 2D canvas. Every motion in a
2
+ // loop repeats with a period that divides LOOP (12 s), so the frame at 12 s is the frame at 0 s and a
3
+ // loop can run under a clip of any length, or repeat, without a seam. No React here.
4
+
5
+ /** The loop length in seconds. Periods must divide it: 1, 1.5, 2, 3, 4, 6, 12. */
6
+ export const LOOP = 12;
7
+ export const TAU = Math.PI * 2;
8
+
9
+ export const clamp = (v: number, a = 0, b = 1) => Math.min(b, Math.max(a, v));
10
+ /** Fractional part in [0, 1): a tiny negative (float error) gives 0, never 1, so it is safe to index with. */
11
+ export const fract = (v: number) => {
12
+ const f = v - Math.floor(v);
13
+ return f < 1 ? f : 0;
14
+ };
15
+ /** Modulo that stays positive. */
16
+ export const mod = (a: number, n: number) => ((a % n) + n) % n;
17
+ export const lerp = (a: number, b: number, k: number) => a + (b - a) * k;
18
+
19
+ /** 0…1 position inside a cycle of `period` seconds (offset in cycles). */
20
+ export const phase = (t: number, period: number, offset = 0) => fract(t / period + offset);
21
+
22
+ /** A fixed pseudo-random number in [0, 1) per element index and salt (never Math.random). */
23
+ export function rand(i: number, salt = 0) {
24
+ return fract(Math.sin(i * 127.1 + salt * 311.7 + 74.7) * 43758.5453123);
25
+ }
26
+
27
+ /** 0 before a, eases 0→1 between a and b (as a linear 0…1), 1 after b. */
28
+ export const win = (p: number, a: number, b: number) => clamp((p - a) / Math.max(1e-6, b - a));
29
+
30
+ export const smoothstep = (a: number, b: number, v: number) => {
31
+ const x = clamp((v - a) / (b - a));
32
+ return x * x * (3 - 2 * x);
33
+ };
34
+
35
+ export const ease = {
36
+ linear: (k: number) => k,
37
+ inSine: (k: number) => 1 - Math.cos((k * Math.PI) / 2),
38
+ outSine: (k: number) => Math.sin((k * Math.PI) / 2),
39
+ inOutSine: (k: number) => -(Math.cos(Math.PI * k) - 1) / 2,
40
+ inCubic: (k: number) => k * k * k,
41
+ outCubic: (k: number) => 1 - Math.pow(1 - k, 3),
42
+ inOutCubic: (k: number) => (k < 0.5 ? 4 * k * k * k : 1 - Math.pow(-2 * k + 2, 3) / 2),
43
+ outExpo: (k: number) => (k >= 1 ? 1 : 1 - Math.pow(2, -10 * k)),
44
+ inOutExpo: (k: number) =>
45
+ k <= 0 ? 0 : k >= 1 ? 1 : k < 0.5 ? Math.pow(2, 20 * k - 10) / 2 : (2 - Math.pow(2, -20 * k + 10)) / 2,
46
+ outBack: (k: number, s = 1.70158) => 1 + (s + 1) * Math.pow(k - 1, 3) + s * Math.pow(k - 1, 2),
47
+ inBack: (k: number, s = 1.70158) => (s + 1) * k * k * k - s * k * k,
48
+ /** Settles from 0 to 1 with a wobble; exactly 1 at k = 1. */
49
+ spring: (k: number, zeta = 0.35, freq = 3) => {
50
+ if (k >= 1) return 1;
51
+ const w = TAU * freq;
52
+ const v = 1 - Math.exp(-zeta * w * k) * Math.cos(w * Math.sqrt(1 - zeta * zeta) * k);
53
+ return lerp(v, 1, smoothstep(0.75, 1, k));
54
+ },
55
+ };
56
+
57
+ /** Smooth noise that repeats every `period` seconds (sines on a circle): drift, sway, breathing. */
58
+ export function loopNoise(t: number, seed = 0, period = LOOP) {
59
+ const a = TAU * phase(t, period);
60
+ return (
61
+ Math.sin(a + rand(seed, 1) * TAU) * 0.5 +
62
+ Math.sin(2 * a + rand(seed, 2) * TAU) * 0.3 +
63
+ Math.sin(3 * a + rand(seed, 3) * TAU) * 0.2
64
+ );
65
+ }
66
+
67
+ /** Perspective projection, divided by depth once. */
68
+ export function proj(x: number, y: number, z: number, f: number, cx: number, cy: number) {
69
+ const s = f / Math.max(1e-3, z);
70
+ return { x: cx + x * s, y: cy + y * s, s };
71
+ }
72
+
73
+ // ─── Colour ──────────────────────────────────────────────────────────────────────────────────────
74
+
75
+ function parse(c: string): [number, number, number] {
76
+ const hex = /^#?([0-9a-f]{3}|[0-9a-f]{6})$/i.exec(c.trim());
77
+ if (hex) {
78
+ const h = hex[1].length === 3 ? hex[1].replace(/./g, (x) => x + x) : hex[1];
79
+ const n = parseInt(h, 16);
80
+ return [(n >> 16) & 255, (n >> 8) & 255, n & 255];
81
+ }
82
+ const rgb = /rgba?\(([^)]+)\)/i.exec(c);
83
+ if (rgb) {
84
+ const [r, g, b] = rgb[1].split(",").map((v) => parseFloat(v));
85
+ return [r || 0, g || 0, b || 0];
86
+ }
87
+ return [0, 0, 0];
88
+ }
89
+
90
+ /** A colour (hex or rgb()) at an alpha. */
91
+ export function rgba(c: string, a: number) {
92
+ const [r, g, b] = parse(c);
93
+ return `rgba(${r},${g},${b},${clamp(a)})`;
94
+ }
95
+
96
+ /** Mix two colours (hex or rgb()). */
97
+ export function mixColor(a: string, b: string, k: number) {
98
+ const x = parse(a);
99
+ const y = parse(b);
100
+ return `rgb(${Math.round(lerp(x[0], y[0], k))},${Math.round(lerp(x[1], y[1], k))},${Math.round(lerp(x[2], y[2], k))})`;
101
+ }
102
+
103
+ const luma = (c: string) => {
104
+ const [r, g, b] = parse(c);
105
+ return (0.299 * r + 0.587 * g + 0.114 * b) / 255;
106
+ };
107
+
108
+ export type LoopTone = "dark" | "accent" | "light";
109
+
110
+ /** The palette a loop draws with. Never use other colours inside a loop. */
111
+ export interface LoopPalette {
112
+ /** Filled before draw() unless the loop is transparent. */
113
+ bg: string;
114
+ /** Main motif. */
115
+ fg: string;
116
+ /** Second colour, sparingly. */
117
+ fg2: string;
118
+ /** Between bg and fg: grids, quiet details. */
119
+ mid: string;
120
+ accent: string;
121
+ accent2: string;
122
+ paper: string;
123
+ ink: string;
124
+ tone: LoopTone;
125
+ }
126
+
127
+ /**
128
+ * Three tones from the brand colours: dark (deep brand-tinted background, accent motif), accent
129
+ * (accent background, ink motif), light (paper background, ink motif, accent as the second colour).
130
+ */
131
+ export function loopPalette(accent: string, accent2: string, tone: LoopTone, paper = "#f5f3ee", ink = "#111216"): LoopPalette {
132
+ if (tone === "accent") {
133
+ const onAccent = luma(accent) > 0.6 ? ink : paper;
134
+ return { bg: accent, fg: onAccent, fg2: accent2, mid: mixColor(accent, onAccent, 0.3), accent, accent2, paper, ink, tone };
135
+ }
136
+ if (tone === "light") {
137
+ return { bg: paper, fg: ink, fg2: accent, mid: mixColor(paper, ink, 0.18), accent, accent2, paper, ink, tone };
138
+ }
139
+ const bg = mixColor(accent, "#07070b", 0.9);
140
+ return { bg, fg: accent, fg2: accent2, mid: mixColor(bg, accent, 0.28), accent, accent2, paper, ink, tone };
141
+ }
142
+
143
+ /** What a loop's draw() receives besides the context. */
144
+ export interface LoopHelpers {
145
+ phase: typeof phase;
146
+ rand: typeof rand;
147
+ win: typeof win;
148
+ ease: typeof ease;
149
+ loopNoise: typeof loopNoise;
150
+ proj: typeof proj;
151
+ rgba: typeof rgba;
152
+ mixColor: typeof mixColor;
153
+ smoothstep: typeof smoothstep;
154
+ clamp: typeof clamp;
155
+ fract: typeof fract;
156
+ mod: typeof mod;
157
+ lerp: typeof lerp;
158
+ TAU: number;
159
+ LOOP: number;
160
+ }
161
+
162
+ export const M: LoopHelpers = { phase, rand, win, ease, loopNoise, proj, rgba, mixColor, smoothstep, clamp, fract, mod, lerp, TAU, LOOP };
163
+
164
+ /**
165
+ * draw(ctx, w, h, t, P, M): paint the frame at t seconds (0 ≤ t < 12). The background is already
166
+ * filled (unless transparent). Sizes from u = h / 100 (min(w, h) for shapes); counts from w.
167
+ * `seed` varies element layouts so the same loop can look different per video.
168
+ */
169
+ export type LoopDraw = (ctx: CanvasRenderingContext2D, w: number, h: number, t: number, P: LoopPalette, M: LoopHelpers, seed: number) => void;
170
+
171
+ export const LOOP_CATEGORIES = ["Backgrounds", "Shapes", "Symmetry", "Morphing", "Games", "Physics", "Generative"] as const;
172
+ export type LoopCategory = (typeof LOOP_CATEGORIES)[number];
173
+
174
+ export interface LoopDef {
175
+ id: string;
176
+ name: string;
177
+ kind: "background" | "shape";
178
+ /** Gallery group (defaults from kind). */
179
+ category?: LoopCategory;
180
+ /** What it looks like and when it works (Claude reads this). */
181
+ description: string;
182
+ tags: string[];
183
+ draw: LoopDraw;
184
+ }