creator-editing-studio 1.3.5 → 1.3.7

package/template/scripts/track_head.py

@@ -0,0 +1,157 @@
+"""Track a person's head through a clip, so graphics can ride with it.
+
+Usage (from the project root):
+    python scripts/track_head.py <video> <first_frame> <last_frame> <out.json> [--check <image.jpg>]
+
+Frames are SOURCE frames of <video>. If <out.json> already exists, the new stretch is merged into it (same
+frames replaced), so one file per video can hold every tracked stretch.
+
+Writes, per source frame, where the head is: centre x/y, size (relative to the first frame) and tilt, in the
+video's own pixels. A composition reads it and pins text or graphics to the head (`src/lib/track.ts`).
+
+How: the head is found once — on the first frame, from the subject's silhouette (the same matting model as
+make_cutout.py; no face model to download, works on any footage). Then dozens of small points on the face
+are followed frame to frame (optical flow). A point is kept only if tracking it backwards lands where it
+started, so points that slide off the face are dropped and fresh ones are found when too few remain. The
+path is smoothed with a centred window — it removes jitter without making the graphic lag behind the head.
+
+--check draws the tracked box on frames across the range into one image, to confirm by eye.
+"""
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+import numpy as np
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+sys.path.insert(0, str(Path(__file__).resolve().parent / "lib"))
+import cv2  # noqa: E402
+from make_cutout import load_segmenter, probe, read_frames, segment  # noqa: E402
+
+
+def head_box(alpha: np.ndarray):
+    """The head from a silhouette: the top of the person, as wide as the silhouette is in that band."""
+    h, w = alpha.shape
+    rows = np.where((alpha > 0.5).sum(axis=1) > w * 0.02)[0]
+    if not len(rows):
+        raise SystemExit("No person found in the first frame.")
+    top = int(rows[0])
+    band = int(h * 0.12)  # a head is about an eighth of a vertical frame's height
+    cols = np.where((alpha[top : top + band] > 0.5).any(axis=0))[0]
+    x0, x1 = int(cols.min()), int(cols.max())
+    # The face sits below the crown: start a little lower so the points land on features, not hair.
+    return x0, top + int(band * 0.25), x1 - x0, int(band * 0.85)
+
+
+def seed(gray, box):
+    x, y, w, h = box
+    mask = np.zeros_like(gray)
+    mask[max(0, y) : y + h, max(0, x) : x + w] = 255
+    pts = cv2.goodFeaturesToTrack(gray, maxCorners=120, qualityLevel=0.01, minDistance=6, mask=mask)
+    return pts if pts is not None else np.empty((0, 1, 2), np.float32)
+
+
+def smooth(values, win):
+    """Centred moving average with edge padding — no lag, no shrinking at the ends."""
+    v = np.asarray(values, np.float64)
+    pad = win // 2
+    p = np.pad(v, pad, mode="edge")
+    return np.convolve(p, np.ones(win) / win, mode="valid")
+
+
+def main() -> None:
+    # A Windows console is not UTF-8 by default; printing → or … would crash after the work is done.
+    for stream in (sys.stdout, sys.stderr):
+        try:
+            stream.reconfigure(encoding="utf-8", errors="replace")
+        except (AttributeError, ValueError):
+            pass
+    ap = argparse.ArgumentParser()
+    ap.add_argument("video")
+    ap.add_argument("first", type=int)
+    ap.add_argument("last", type=int)
+    ap.add_argument("out")
+    ap.add_argument("--check", default=None)
+    ap.add_argument("--fresh", action="store_true", help="replace the file instead of merging into it")
+    args = ap.parse_args()
+
+    w, h, fps = probe(args.video)
+    count = args.last - args.first + 1
+    frames = list(read_frames(args.video, args.first, count, w, h, fps))
+    if not frames:
+        raise SystemExit("Could not read those frames.")
+
+    torch, model, device = load_segmenter("lite")
+    box = head_box(segment(torch, model, device, frames[0]))
+    bx, by, bw, bh = box
+
+    lk = dict(winSize=(21, 21), maxLevel=3, criteria=(cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 30, 0.01))
+    prev = cv2.cvtColor(frames[0], cv2.COLOR_RGB2GRAY)
+    pts = seed(prev, box)
+    cx, cy, scale, angle = bx + bw / 2, by + bh / 2, 1.0, 0.0
+    track = [(cx, cy, scale, angle)]
+    for rgb in frames[1:]:
+        gray = cv2.cvtColor(rgb, cv2.COLOR_RGB2GRAY)
+        if len(pts) >= 6:
+            nxt, st, _ = cv2.calcOpticalFlowPyrLK(prev, gray, pts, None, **lk)
+            back, st2, _ = cv2.calcOpticalFlowPyrLK(gray, prev, nxt, None, **lk)
+            ok = (st.ravel() == 1) & (st2.ravel() == 1) & (np.linalg.norm((back - pts).reshape(-1, 2), axis=1) < 1.0)
+            a, b = pts[ok], nxt[ok]
+            if len(a) >= 6:
+                # Similarity transform (move, scale, rotate) of the face from the last frame to this one.
+                m, _ = cv2.estimateAffinePartial2D(a, b, method=cv2.RANSAC, ransacReprojThreshold=2.0)
+                if m is not None:
+                    s = float(np.hypot(m[0, 0], m[1, 0]))
+                    r = float(np.degrees(np.arctan2(m[1, 0], m[0, 0])))
+                    cx, cy = m[0, 0] * cx + m[0, 1] * cy + m[0, 2], m[1, 0] * cx + m[1, 1] * cy + m[1, 2]
+                    scale *= s
+                    angle += r
+            pts = b.reshape(-1, 1, 2)
+        if len(pts) < 30:
+            # Too few points left: find fresh ones in the head's current box.
+            hw, hh = bw * scale / 2, bh * scale / 2
+            pts = seed(gray, (int(cx - hw), int(cy - hh), int(hw * 2), int(hh * 2)))
+        track.append((cx, cy, scale, angle))
+        prev = gray
+
+    xs, ys, ss, rs = (smooth([t[i] for t in track], win) for i, win in ((0, 7), (1, 7), (2, 11), (3, 11)))
+    out = {
+        "source": str(args.video),
+        "fps": fps,
+        "size": [w, h],
+        "first": args.first,
+        "box": {"w": bw, "h": bh},
+        "frames": [
+            {"f": args.first + i, "x": round(float(xs[i]), 1), "y": round(float(ys[i]), 1), "s": round(float(ss[i]), 4), "r": round(float(rs[i]), 2)}
+            for i in range(len(track))
+        ],
+    }
+    Path(args.out).parent.mkdir(parents=True, exist_ok=True)
+    if Path(args.out).exists() and not args.fresh:
+        old = json.loads(Path(args.out).read_text())
+        if old.get("source") == out["source"]:
+            mine = {f["f"] for f in out["frames"]}
+            out["frames"] = sorted([f for f in old["frames"] if f["f"] not in mine] + out["frames"], key=lambda f: f["f"])
+            out["first"] = out["frames"][0]["f"]
+    Path(args.out).write_text(json.dumps(out, indent=1))
+    span = lambda k: f"{min(f[k] for f in out['frames']):.1f}…{max(f[k] for f in out['frames']):.1f}"
+    print(f"tracked {len(track)} frames · head x {span('x')} · y {span('y')} · size {span('s')} · tilt {span('r')}° → {args.out}")
+
+    if args.check:
+        picks = np.linspace(0, len(frames) - 1, 8).astype(int)
+        tiles = []
+        for i in picks:
+            img = cv2.cvtColor(frames[i], cv2.COLOR_RGB2BGR).copy()
+            f = out["frames"][i]
+            hw, hh = bw * f["s"] / 2, bh * f["s"] / 2
+            cv2.rectangle(img, (int(f["x"] - hw), int(f["y"] - hh)), (int(f["x"] + hw), int(f["y"] + hh)), (0, 255, 255), 4)
+            cv2.circle(img, (int(f["x"]), int(f["y"])), 10, (0, 0, 255), -1)
+            cv2.putText(img, str(f["f"]), (20, 60), cv2.FONT_HERSHEY_SIMPLEX, 2, (255, 255, 255), 4)
+            tiles.append(cv2.resize(img, (w // 4, h // 4)))
+        cv2.imwrite(args.check, np.hstack(tiles))
+
+
+if __name__ == "__main__":
+    main()

package/template/scripts/transcribe.py

@@ -1,103 +1,172 @@
-"""Word-level transcript for a clip: WhisperX transcription + wav2vec2 forced alignment.
-
-Usage (from the project root):
-    python scripts/transcribe.py <media> [--language en] [--model small]
-
-Writes work/<clip-name>/words.json. Models are cached under the studio's .models folder.
-Words the aligner cannot place (often digits like "186%") keep start/end = null and must be
-fixed against the script before building the spine.
-"""
-
-import argparse
-import json
-import os
-import time
-from pathlib import Path
-
-import sys as _sys  # noqa: E402
-_sys.path.insert(0, str(Path(__file__).resolve().parent / "lib"))
-from media import FFMPEG, use_certifi  # noqa: E402
-
-# Models are large; cache them inside the studio so they survive and are easy to find.
-_MODELS = Path(__file__).resolve().parent.parent / ".models"
-os.environ.setdefault("HF_HOME", str(_MODELS / "huggingface"))
-os.environ.setdefault("TORCH_HOME", str(_MODELS / "torch"))
-os.environ["PATH"] = str(Path(FFMPEG).parent) + os.pathsep + os.environ["PATH"]
-
-# torch.hub fetches the word-alignment model with urllib, which on a python.org macOS
-# build has no root certificates — transcription then dies with CERTIFICATE_VERIFY_FAILED
-# after the slow part has already succeeded. Must run before torch is imported.
-use_certifi()
-
-try:
-    import whisperx  # noqa: E402  (must import after the cache/PATH/cert setup above)
-except ModuleNotFoundError as exc:  # pragma: no cover
-    # Run with the wrong interpreter and the bare error reads as "never installed", which
-    # sends you off to fix the wrong thing. Say which python is running and what to do.
-    _venv = Path(__file__).resolve().parent.parent / ".venv"
-    _venv_py = _venv / ("Scripts/python.exe" if os.name == "nt" else "bin/python3")
-    print(f"Cannot import {exc.name}.", file=_sys.stderr)
-    print(f"  running: {_sys.executable}  (python {_sys.version.split()[0]})", file=_sys.stderr)
-    if _venv_py.exists():
-        print(f"  the studio's environment is at {_venv_py}", file=_sys.stderr)
-        print("  run the transcriber with that python, or use: npm run prep", file=_sys.stderr)
-    else:
-        print("  the studio has no .venv yet. Build one with python 3.11 or 3.12:", file=_sys.stderr)
-        print("    py -3.12 -m venv .venv", file=_sys.stderr)
-        print("    .venv/Scripts/python.exe -m pip install -r requirements.txt", file=_sys.stderr)
-    print("  see what you have with: npm run doctor", file=_sys.stderr)
-    raise SystemExit(2)
-
-
-def main() -> None:
-    parser = argparse.ArgumentParser()
-    parser.add_argument("media")
-    parser.add_argument("--language", default=None, help="e.g. en, hi. Detected when omitted.")
-    parser.add_argument("--project", default=None, help="Video project name: writes to work/<project>/<clip>/")
-    parser.add_argument("--model", default="small", help="Whisper size: small (fast on CPU) or medium (more accurate)")
-    args = parser.parse_args()
-
-    media = Path(args.media)
-    out_dir = (Path("work") / args.project / media.stem) if args.project else (Path("work") / media.stem)
-    out_dir.mkdir(parents=True, exist_ok=True)
-    started = time.time()
-
-    audio = whisperx.load_audio(str(media))
-    model = whisperx.load_model(args.model, device="cpu", compute_type="int8", language=args.language)
-    result = model.transcribe(audio, batch_size=4, language=args.language)
-    language = result["language"]
-
-    align_model, metadata = whisperx.load_align_model(language_code=language, device="cpu")
-    aligned = whisperx.align(result["segments"], align_model, metadata, audio, device="cpu", return_char_alignments=False)
-
-    words = []
-    for segment in aligned["segments"]:
-        for w in segment.get("words", []):
-            words.append(
-                {
-                    "word": w["word"],
-                    "start": round(w["start"], 3) if "start" in w else None,
-                    "end": round(w["end"], 3) if "end" in w else None,
-                    "score": round(w["score"], 3) if "score" in w else None,
-                }
-            )
-
-    output = {
-        "source": str(media),
-        "language": language,
-        "model": args.model,
-        "durationSec": round(len(audio) / 16000, 3),
-        "text": " ".join(s["text"].strip() for s in aligned["segments"]),
-        "words": words,
-    }
-    out_file = out_dir / "words.json"
-    out_file.write_text(json.dumps(output, indent=2, ensure_ascii=False), encoding="utf-8")
-
-    unplaced = [w["word"] for w in words if w["start"] is None]
-    print(f"language: {language} | words: {len(words)} | unplaced: {len(unplaced)} {unplaced if unplaced else ''}")
-    print(f"text: {output['text']}")
-    print(f"wrote {out_file} in {time.time() - started:.0f}s")
-
-
-if __name__ == "__main__":
-    main()
+"""Word-level transcript for a clip: WhisperX transcription + wav2vec2 forced alignment.
+
+Usage (from the project root):
+    python scripts/transcribe.py <media> [--language en] [--model small]
+
+Writes work/<clip-name>/words.json. Models are cached under the studio's .models folder.
+Words the aligner cannot place (often digits like "186%") keep start/end = null and must be
+fixed against the script before building the spine.
+"""
+
+import argparse
+import json
+import os
+import time
+from pathlib import Path
+
+import sys as _sys  # noqa: E402
+_sys.path.insert(0, str(Path(__file__).resolve().parent / "lib"))
+from media import FFMPEG, use_certifi  # noqa: E402
+from languages import lang, load_aligner, studio_language  # noqa: E402
+
+# Models are large; cache them inside the studio so they survive and are easy to find.
+_MODELS = Path(__file__).resolve().parent.parent / ".models"
+os.environ.setdefault("HF_HOME", str(_MODELS / "huggingface"))
+os.environ.setdefault("TORCH_HOME", str(_MODELS / "torch"))
+os.environ["PATH"] = str(Path(FFMPEG).parent) + os.pathsep + os.environ["PATH"]
+
+# torch.hub fetches the word-alignment model with urllib, which on a python.org macOS
+# build has no root certificates — transcription then dies with CERTIFICATE_VERIFY_FAILED
+# after the slow part has already succeeded. Must run before torch is imported.
+use_certifi()
+
+try:
+    import whisperx  # noqa: E402  (must import after the cache/PATH/cert setup above)
+except ModuleNotFoundError as exc:  # pragma: no cover
+    # Run with the wrong interpreter and the bare error reads as "never installed", which
+    # sends you off to fix the wrong thing. Say which python is running and what to do.
+    _venv = Path(__file__).resolve().parent.parent / ".venv"
+    _venv_py = _venv / ("Scripts/python.exe" if os.name == "nt" else "bin/python3")
+    print(f"Cannot import {exc.name}.", file=_sys.stderr)
+    print(f"  running: {_sys.executable}  (python {_sys.version.split()[0]})", file=_sys.stderr)
+    if _venv_py.exists():
+        print(f"  the studio's environment is at {_venv_py}", file=_sys.stderr)
+        print("  run the transcriber with that python, or use: npm run prep", file=_sys.stderr)
+    else:
+        print("  the studio has no .venv yet. Build one with python 3.11 or 3.12:", file=_sys.stderr)
+        print("    py -3.12 -m venv .venv", file=_sys.stderr)
+        print("    .venv/Scripts/python.exe -m pip install -r requirements.txt", file=_sys.stderr)
+    print("  see what you have with: npm run doctor", file=_sys.stderr)
+    raise SystemExit(2)
+
+
+# Indian languages: the small model cannot do them. On Malayalam it ignored the speech, invented one
+# English sentence and repeated it, then drifted into Devanagari (2026-10-17). large-v3 is the
+# smallest model that transcribes these reliably, so it is the default for them.
+INDIC = {"ml", "ta", "te", "kn", "hi", "bn", "mr", "gu", "pa", "or", "as", "ur", "ne", "si"}
+
+# The script each language must come out in. A transcript mostly in another script is a model
+# failure (translated, or a neighbouring language), never a usable result, so it stops here.
+SCRIPTS = {
+    "ml": (0x0D00, 0x0D7F), "ta": (0x0B80, 0x0BFF), "te": (0x0C00, 0x0C7F), "kn": (0x0C80, 0x0CFF),
+    "hi": (0x0900, 0x097F), "mr": (0x0900, 0x097F), "ne": (0x0900, 0x097F), "bn": (0x0980, 0x09FF),
+    "as": (0x0980, 0x09FF), "gu": (0x0A80, 0x0AFF), "pa": (0x0A00, 0x0A7F), "or": (0x0B00, 0x0B7F),
+    "si": (0x0D80, 0x0DFF), "ur": (0x0600, 0x06FF),
+}
+
+
+def script_share(text: str, language: str) -> float | None:
+    """Share of letters in the language's own script (Latin words like brand names are allowed)."""
+    span = SCRIPTS.get(language)
+    if not span:
+        return None
+    letters = [c for c in text if c.isalpha()]
+    if not letters:
+        return 0.0
+    return sum(span[0] <= ord(c) <= span[1] for c in letters) / len(letters)
+
+
+def main() -> None:
+    # Windows consoles default to cp1252, which cannot print Malayalam: the script used to finish
+    # the transcription and then crash on its own summary line.
+    for stream in (_sys.stdout, _sys.stderr):
+        try:
+            stream.reconfigure(encoding="utf-8", errors="replace")
+        except (AttributeError, ValueError):
+            pass
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("media")
+    parser.add_argument("--language", default=None, help="e.g. en, hi, ml. Default: the language chosen at setup (studio.config.json), else detected.")
+    parser.add_argument("--project", default=None, help="Video project name: writes to work/<project>/<clip>/")
+    parser.add_argument("--model", default=None, help="Whisper size. Default: what the language needs (scripts/lib/languages.py)")
+    args = parser.parse_args()
+
+    media = Path(args.media)
+    out_dir = (Path("work") / args.project / media.stem) if args.project else (Path("work") / media.stem)
+    out_dir.mkdir(parents=True, exist_ok=True)
+    started = time.time()
+
+    if args.language is None:
+        args.language = studio_language()
+    info = lang(args.language) if args.language else None
+    if info:
+        args.language = info["code"]  # Hinglish is transcribed as Hindi
+    if args.model is None:
+        args.model = info["whisper"] if info else "small"
+    audio = whisperx.load_audio(str(media))
+    model = whisperx.load_model(args.model, device="cpu", compute_type="int8", language=args.language)
+    # task="transcribe" always: without it a weak model may answer in English instead.
+    result = model.transcribe(audio, batch_size=4, language=args.language, task="transcribe")
+    language = result["language"]
+
+    align_model, metadata = load_aligner(whisperx, language)
+    if align_model is not None:
+        aligned = whisperx.align(result["segments"], align_model, metadata, audio, device="cpu", return_char_alignments=False)
+    else:
+        # No word-timing model for this language: spread each segment's words across its time, by length.
+        # Looser than real alignment — good enough to cut on, worth checking where captions must land exactly.
+        aligned = {"segments": []}
+        for seg in result["segments"]:
+            ws = seg["text"].split()
+            total = sum(len(w) for w in ws) or 1
+            t, words_ = seg["start"], []
+            for w in ws:
+                d = (seg["end"] - seg["start"]) * len(w) / total
+                words_.append({"word": w, "start": t, "end": t + d})
+                t += d
+            aligned["segments"].append({**seg, "words": words_})
+
+    words = []
+    for segment in aligned["segments"]:
+        for w in segment.get("words", []):
+            words.append(
+                {
+                    "word": w["word"],
+                    "start": round(w["start"], 3) if "start" in w else None,
+                    "end": round(w["end"], 3) if "end" in w else None,
+                    "score": round(w["score"], 3) if "score" in w else None,
+                }
+            )
+
+    output = {
+        "source": str(media),
+        "language": language,
+        "model": args.model,
+        "durationSec": round(len(audio) / 16000, 3),
+        "text": " ".join(s["text"].strip() for s in aligned["segments"]),
+        "words": words,
+    }
+    out_file = out_dir / "words.json"
+    out_file.write_text(json.dumps(output, indent=2, ensure_ascii=False), encoding="utf-8")
+
+    share = script_share(output["text"], language)
+    # Low bar on purpose: everyday Malayalam mixes in English words ("Instagram", "business"), but a
+    # failed run scores near zero (the small model's Malayalam came out at 0%).
+    if share is not None and share < 0.3:
+        print(
+            f"WARNING: only {share:.0%} of this transcript is in the {language} script, so the model did not "
+            f"really transcribe it (it translated, or heard another language). Do not cut from it. "
+            f"Re-run with a larger --model, and check --language is right.",
+            file=_sys.stderr,
+        )
+        raise SystemExit(3)
+
+    unplaced = [w["word"] for w in words if w["start"] is None]
+    print(f"language: {language} | words: {len(words)} | unplaced: {len(unplaced)} {unplaced if unplaced else ''}")
+    print(f"text: {output['text']}")
+    print(f"wrote {out_file} in {time.time() - started:.0f}s")
+
+
+if __name__ == "__main__":
+    main()

package/template/src/components/CommandCard.tsx

@@ -1,6 +1,7 @@
 import React from 'react';
 import {useCurrentFrame, useVideoConfig} from 'remotion';
-import {COLOR, FONT, PALETTE, RADIUS, SHADOW, SPACE, TYPE, WEIGHT} from '../design/tokens';
+import {withAlpha} from '../design/color';
+import {COLOR, FONT, RADIUS, SHADOW, SPACE, TYPE, WEIGHT} from '../design/tokens';
 import {EASE} from '../design/motion';
 import {progress} from '../lib/animate';
 
@@ -38,8 +39,8 @@ export type Segment =
   | {kind: 'redacted'; text: string; label?: string};
 
 const COLOR_FOR: Record<Segment['kind'], string> = {
-  plain: PALETTE.stone100,
-  flag: PALETTE.stone400,
+  plain: COLOR.fgOnDark,
+  flag: COLOR.fgMuted,
   accent: COLOR.accent,
   redacted: 'transparent',
 };
@@ -59,8 +60,8 @@ const Redaction: React.FC<{width: number; label?: string}> = ({width, label}) =>
       verticalAlign: 'middle',
       borderRadius: RADIUS.sm / 2,
       // Accent at low alpha, not a grey smear: it reads as a deliberate mark rather than a mistake.
-      backgroundColor: `${PALETTE.lime400}2e`,
-      border: `2px solid ${PALETTE.lime400}66`,
+      backgroundColor: withAlpha(COLOR.accent, 0.18),
+      border: `2px solid ${withAlpha(COLOR.accent, 0.4)}`,
     }}
   >
     <span
@@ -113,7 +114,7 @@ export const CommandCard: React.FC<{
         width,
         maxWidth: '100%',
         borderRadius: RADIUS.md,
-        backgroundColor: PALETTE.ink900,
+        backgroundColor: COLOR.surfaceDark,
         boxShadow: SHADOW.pop,
         overflow: 'hidden',
         opacity: land,
@@ -126,11 +127,11 @@ export const CommandCard: React.FC<{
           alignItems: 'center',
           gap: SPACE[2],
           padding: `${SPACE[2]}px ${SPACE[3]}px`,
-          backgroundColor: PALETTE.ink800,
-          borderBottom: `2px solid ${PALETTE.ink700}`,
+          backgroundColor: COLOR.borderStrong,
+          borderBottom: `2px solid ${withAlpha(COLOR.fgOnDark, 0.08)}`,
         }}
       >
-        {[PALETTE.stone600, PALETTE.stone600, PALETTE.stone600].map((c, i) => (
+        {[COLOR.fgSecondary, COLOR.fgSecondary, COLOR.fgSecondary].map((c, i) => (
           <span key={i} style={{width: 14, height: 14, borderRadius: RADIUS.pill, backgroundColor: c}} />
         ))}
         <span style={{flex: 1}} />
@@ -141,7 +142,7 @@ export const CommandCard: React.FC<{
             fontWeight: WEIGHT.medium,
             letterSpacing: TYPE.eyebrow.tracking,
             textTransform: 'uppercase',
-            color: note ? COLOR.accent : PALETTE.stone400,
+            color: note ? COLOR.accent : COLOR.fgMuted,
           }}
         >
           {note ?? (platform === 'mac' ? 'macOS' : platform === 'windows' ? 'Windows' : '')}
@@ -155,7 +156,7 @@ export const CommandCard: React.FC<{
           fontSize,
           lineHeight: 1.65,
           letterSpacing: '-0.01em',
-          color: PALETTE.stone100,
+          color: COLOR.fgOnDark,
           wordBreak: 'break-word',
         }}
       >