plotlink-ows 1.2.94 → 1.2.96

package/app/lib/active-wallet.ts

@@ -0,0 +1,260 @@
+import type { WalletInfo } from "../../lib/ows/types";
+import { getBaseAddress, listAgentWallets } from "../../lib/ows/wallet";
+import { db } from "../db";
+
+const ACTIVE_WALLET_SETTING_KEY = "activeOwsWallet.v1";
+const PLOTLINK_WALLET_PREFIX = "plotlink-writer";
+
+export interface StoredWalletSelection {
+  walletId?: string;
+  name?: string;
+  address?: string;
+  source: "ows";
+  label?: string;
+}
+
+export interface WalletChoice {
+  walletId?: string;
+  name: string;
+  address?: string;
+  normalizedAddress?: string;
+  source: "ows";
+  label: string;
+  recognized: boolean;
+  active: boolean;
+}
+
+export interface ActiveWallet {
+  wallet: WalletInfo;
+  walletId?: string;
+  name: string;
+  address: string;
+  normalizedAddress: string;
+  source: "ows";
+  label: string;
+}
+
+export interface PublicActiveWallet {
+  walletId?: string;
+  name: string;
+  address: string;
+  normalizedAddress: string;
+  source: "ows";
+  label: string;
+}
+
+export interface ActiveWalletResolution {
+  activeWallet: ActiveWallet | null;
+  wallets: WalletChoice[];
+  selectionRequired: boolean;
+  error?: string;
+}
+
+function normalizeAddress(address: string | undefined): string | undefined {
+  const trimmed = address?.trim();
+  return trimmed ? trimmed.toLowerCase() : undefined;
+}
+
+function getWalletId(wallet: WalletInfo): string | undefined {
+  const maybeId = (wallet as WalletInfo & { id?: unknown }).id;
+  return typeof maybeId === "string" && maybeId.trim() ? maybeId : undefined;
+}
+
+function toWalletChoice(wallet: WalletInfo, activeSelection?: StoredWalletSelection): WalletChoice {
+  const address = getBaseAddress(wallet);
+  const normalizedAddress = normalizeAddress(address);
+  const walletId = getWalletId(wallet);
+  const recognized = wallet.name.startsWith(PLOTLINK_WALLET_PREFIX);
+  return {
+    walletId,
+    name: wallet.name,
+    address: normalizedAddress,
+    normalizedAddress,
+    source: "ows",
+    label: recognized ? "PlotLink writer wallet" : "OWS wallet",
+    recognized,
+    active: matchesSelection(wallet, address, activeSelection),
+  };
+}
+
+function matchesSelection(wallet: WalletInfo, address: string | undefined, selection: StoredWalletSelection | null | undefined): boolean {
+  if (!selection) return false;
+  const walletId = getWalletId(wallet);
+  const normalizedAddress = normalizeAddress(address);
+  const selectedAddress = normalizeAddress(selection.address);
+  if (selection.walletId && walletId && selection.walletId === walletId) return true;
+  if (selectedAddress && normalizedAddress && selectedAddress === normalizedAddress) return true;
+  if (selection.name && selection.name === wallet.name) return true;
+  return false;
+}
+
+function storedSelectionFor(wallet: WalletInfo): StoredWalletSelection {
+  const address = normalizeAddress(getBaseAddress(wallet));
+  return {
+    walletId: getWalletId(wallet),
+    name: wallet.name,
+    address,
+    source: "ows",
+    label: wallet.name.startsWith(PLOTLINK_WALLET_PREFIX) ? "PlotLink writer wallet" : "OWS wallet",
+  };
+}
+
+async function readStoredSelection(): Promise<StoredWalletSelection | null> {
+  try {
+    const row = await db.setting.findUnique({ where: { key: ACTIVE_WALLET_SETTING_KEY } });
+    if (!row?.value) return null;
+    const parsed = JSON.parse(row.value) as Partial<StoredWalletSelection>;
+    if (parsed.source !== "ows") return null;
+    return {
+      walletId: typeof parsed.walletId === "string" ? parsed.walletId : undefined,
+      name: typeof parsed.name === "string" ? parsed.name : undefined,
+      address: normalizeAddress(parsed.address),
+      source: "ows",
+      label: typeof parsed.label === "string" ? parsed.label : undefined,
+    };
+  } catch {
+    return null;
+  }
+}
+
+async function writeStoredSelection(selection: StoredWalletSelection): Promise<void> {
+  try {
+    await db.setting.upsert({
+      where: { key: ACTIVE_WALLET_SETTING_KEY },
+      create: { key: ACTIVE_WALLET_SETTING_KEY, value: JSON.stringify(selection) },
+      update: { value: JSON.stringify(selection) },
+    });
+  } catch {
+    // The app can still operate in legacy single-wallet mode if persistence is
+    // temporarily unavailable; signing never depends on this write succeeding.
+  }
+}
+
+function findSelectedWallet(wallets: WalletInfo[], selection: StoredWalletSelection | null): WalletInfo | null {
+  if (!selection) return null;
+  return wallets.find((wallet) => matchesSelection(wallet, getBaseAddress(wallet), selection)) ?? null;
+}
+
+function toActiveWallet(wallet: WalletInfo): ActiveWallet | null {
+  const address = normalizeAddress(getBaseAddress(wallet));
+  if (!address) return null;
+  return {
+    wallet,
+    walletId: getWalletId(wallet),
+    name: wallet.name,
+    address,
+    normalizedAddress: address,
+    source: "ows",
+    label: wallet.name.startsWith(PLOTLINK_WALLET_PREFIX) ? "PlotLink writer wallet" : "OWS wallet",
+  };
+}
+
+export async function listWalletChoices(): Promise<WalletChoice[]> {
+  const wallets = listAgentWallets();
+  const selection = await readStoredSelection();
+  return wallets.map((wallet) => toWalletChoice(wallet, selection));
+}
+
+export async function resolveActiveWallet(): Promise<ActiveWalletResolution> {
+  const wallets = listAgentWallets();
+  const selection = await readStoredSelection();
+  const storedWallet = findSelectedWallet(wallets, selection);
+  const activeFromStored = storedWallet ? toActiveWallet(storedWallet) : null;
+  if (activeFromStored) {
+    return {
+      activeWallet: activeFromStored,
+      wallets: wallets.map((wallet) => toWalletChoice(wallet, storedSelectionFor(storedWallet))),
+      selectionRequired: false,
+    };
+  }
+
+  const evmWallets = wallets.filter((wallet) => Boolean(getBaseAddress(wallet)));
+  const recognizedWallets = evmWallets.filter((wallet) => wallet.name.startsWith(PLOTLINK_WALLET_PREFIX));
+  const autoSelected = recognizedWallets.length === 1
+    ? recognizedWallets[0]
+    : recognizedWallets.length === 0 && evmWallets.length === 1
+      ? evmWallets[0]
+      : null;
+
+  if (autoSelected) {
+    const stored = storedSelectionFor(autoSelected);
+    await writeStoredSelection(stored);
+    return {
+      activeWallet: toActiveWallet(autoSelected),
+      wallets: wallets.map((wallet) => toWalletChoice(wallet, stored)),
+      selectionRequired: false,
+    };
+  }
+
+  const choices = wallets.map((wallet) => toWalletChoice(wallet, null));
+  const hasSelectableWallets = evmWallets.length > 0;
+  return {
+    activeWallet: null,
+    wallets: choices,
+    selectionRequired: hasSelectableWallets,
+    error: hasSelectableWallets
+      ? "Multiple OWS wallets found. Select an active wallet before publishing or signing."
+      : "No OWS wallet found",
+  };
+}
+
+export async function selectActiveWallet(input: { walletId?: string; name?: string; address?: string }): Promise<ActiveWalletResolution> {
+  const wallets = listAgentWallets();
+  const normalizedInputAddress = normalizeAddress(input.address);
+  const selected = wallets.find((wallet) => {
+    const walletId = getWalletId(wallet);
+    const address = normalizeAddress(getBaseAddress(wallet));
+    if (input.walletId && walletId && walletId === input.walletId) return true;
+    if (normalizedInputAddress && address && address === normalizedInputAddress) return true;
+    if (input.name && wallet.name === input.name) return true;
+    return false;
+  });
+
+  if (!selected) {
+    return {
+      activeWallet: null,
+      wallets: wallets.map((wallet) => toWalletChoice(wallet, null)),
+      selectionRequired: true,
+      error: "Selected OWS wallet was not found",
+    };
+  }
+
+  const activeWallet = toActiveWallet(selected);
+  if (!activeWallet) {
+    return {
+      activeWallet: null,
+      wallets: wallets.map((wallet) => toWalletChoice(wallet, null)),
+      selectionRequired: true,
+      error: "Selected OWS wallet has no EVM address",
+    };
+  }
+
+  const stored = storedSelectionFor(selected);
+  await writeStoredSelection(stored);
+  return {
+    activeWallet,
+    wallets: wallets.map((wallet) => toWalletChoice(wallet, stored)),
+    selectionRequired: false,
+  };
+}
+
+export function nextPlotlinkWalletName(wallets: WalletInfo[]): string {
+  const names = new Set(wallets.map((wallet) => wallet.name));
+  if (!names.has(PLOTLINK_WALLET_PREFIX)) return PLOTLINK_WALLET_PREFIX;
+  for (let index = 2; index < 1000; index += 1) {
+    const name = `${PLOTLINK_WALLET_PREFIX}-${index}`;
+    if (!names.has(name)) return name;
+  }
+  return `${PLOTLINK_WALLET_PREFIX}-${Date.now()}`;
+}
+
+export function toPublicActiveWallet(wallet: ActiveWallet): PublicActiveWallet {
+  return {
+    walletId: wallet.walletId,
+    name: wallet.name,
+    address: wallet.address,
+    normalizedAddress: wallet.normalizedAddress,
+    source: wallet.source,
+    label: wallet.label,
+  };
+}

package/app/lib/cartoon-coach.ts

@@ -168,7 +168,7 @@ function coachForEpisode(ep: EpisodeProgress, undetectedClean: number): CartoonC
   }
 
   // 2) Lettering — place speech bubbles & captions in the cut workspace.
-  if (c.withText < c.needClean) {
+  if (c.withText < c.total) {
     return ui("Clean images ready", "Review cuts and start lettering", "open-lettering", file);
   }
 

package/app/lib/cartoon-readiness.ts

@@ -492,7 +492,7 @@ export interface CartoonCutProgress {
   needClean: number;
   /** Of `needClean`, how many have a clean image recorded. */
   withClean: number;
-  /** Of the clean-image cuts, how many have text overlays placed. */
+  /** Cuts with lettering overlays placed. Image cuts still require clean art first; text panels are first-class lettering targets. */
   withText: number;
   /** Cuts (any kind) with an exported final image. */
   exported: number;
@@ -517,8 +517,8 @@ export function summarizeCutProgress(cuts: Cut[]): CartoonCutProgress {
   let uploaded = 0;
   for (const cut of cuts) {
     // Image cuts need a clean image → lettering; text/interstitial panels (#350)
-    // do not (they're text on a styled background). Every panel still exports +
-    // uploads a final image, so those are counted for both kinds.
+    // do not (they're text on a styled background). Text panels still require
+    // lettering overlays before the shared workflow can advance to export (#488).
     if (!isTextPanel(cut)) {
       needClean++;
       // A PNG clean image is a draft intermediate, not a finished clean asset
@@ -531,6 +531,8 @@ export function summarizeCutProgress(cuts: Cut[]): CartoonCutProgress {
         // every cut-list render now (#414), so a bad persisted cut must not crash it.
         if ((cut.overlays?.length ?? 0) > 0) withText++;
       }
+    } else if ((cut.overlays?.length ?? 0) > 0) {
+      withText++;
     }
     if (cut.finalImagePath && cut.exportedAt) exported++;
     if (cut.uploadedUrl) uploaded++;
@@ -583,12 +585,12 @@ export function cartoonChecklist(input: { cuts: Cut[]; published?: boolean }): C
   const p = summarizeCutProgress(cuts);
   if (p.total === 0) return { steps: [], nextStep: null };
 
-  // Clean + letter gate only IMAGE cuts (needClean); export + upload gate EVERY
-  // cut including text panels (total). For an all-image story needClean === total
-  // so this is unchanged from before (#350).
+  // Clean gates only IMAGE cuts (needClean); lettering/export/upload gate EVERY
+  // cut including text panels. Text panels need no clean art, but they are still
+  // editable lettering targets before export (#488).
   const planDone = p.total > 0;
   const cleanDone = planDone && p.withClean === p.needClean;
-  const letterDone = cleanDone && p.withText === p.needClean;
+  const letterDone = cleanDone && p.withText === p.total;
   const exportDone = letterDone && p.exported === p.total;
   const uploadDone = exportDone && p.uploaded === p.total;
   const publishDone = uploadDone && published;
@@ -604,13 +606,13 @@ export function cartoonChecklist(input: { cuts: Cut[]; published?: boolean }): C
   const order: CartoonStepKey[] = ["plan", "clean", "letter", "export", "upload", "publish"];
   const currentIdx = order.findIndex((k) => !complete[k]);
 
-  // Clean/letter count image cuts (needClean); export/upload count every cut
+  // Clean counts image cuts (needClean); lettering/export/upload count every cut
   // (total). An all-text-panel episode has needClean === 0 → "no image cuts".
   const imageDetail = (done: number) => (p.needClean > 0 ? fraction(done, p.needClean) : "no image cuts");
   const detail: Record<CartoonStepKey, string | null> = {
     plan: fraction(p.total, p.total),
     clean: imageDetail(p.withClean),
-    letter: imageDetail(p.withText),
+    letter: fraction(p.withText, p.total),
     export: fraction(p.exported, p.total),
     upload: fraction(p.uploaded, p.total),
     publish: null,
@@ -702,7 +704,7 @@ export function previewFooterGuidance(ctx: PreviewFooterContext): string | null
       if (p.withClean < p.needClean) {
         return "Genesis has a cut plan — generate the clean images for its cuts next.";
       }
-      if (p.withText < p.needClean) {
+      if (p.withText < p.total) {
         return "Genesis clean art is ready — review the cuts and add speech bubbles & captions next.";
       }
       if (p.exported < p.total) {

package/app/lib/cuts.ts

@@ -1,8 +1,17 @@
 import fs from "fs";
 import path from "path";
-import { hasVisibleSpeechTail, CARTOON_BUBBLE_RENDERER_VERSION, type Overlay } from "./overlays";
+import {
+  hasVisibleSpeechTail,
+  CARTOON_BUBBLE_RENDERER_VERSION,
+  type Overlay,
+} from "./overlays";
 
-export const SHOT_TYPES = ["wide", "medium", "close-up", "extreme-close-up"] as const;
+export const SHOT_TYPES = [
+  "wide",
+  "medium",
+  "close-up",
+  "extreme-close-up",
+] as const;
 export type ShotType = (typeof SHOT_TYPES)[number];
 
 export interface CutDialogue {
@@ -19,6 +28,19 @@ export interface CutDialogue {
  */
 export type CutKind = "image" | "text";
 
+/**
+ * AI draft lettering state (#494). `generated` means OWS created a first-pass
+ * overlay set from the cut script and it has not been user-tuned yet. `edited`
+ * means the writer has since adjusted or replaced that draft in the editor.
+ */
+export interface CutAiDraft {
+  status: "generated" | "edited";
+  /** Signature of the generated overlay set, for edit-detection on save. */
+  baseSig?: string;
+  generatedAt?: string;
+  updatedAt?: string;
+}
+
 export interface Cut {
   id: number;
   shotType: ShotType;
@@ -41,6 +63,8 @@ export interface Cut {
   finalRendererVersion?: number;
   /** Panel kind (#350). Absent ⇒ "image" (backward-compatible). */
   kind?: CutKind;
+  /** AI draft lettering state (#494). Optional and backward-compatible. */
+  aiDraft?: CutAiDraft | null;
   /** Text-panel background color (CSS color), e.g. "#101820". Optional (#350). */
   background?: string;
   /** Text-panel aspect ratio hint, e.g. "4:5". Optional (#350). */
@@ -89,7 +113,11 @@ export function cutNextAction(
   if (cut.cleanImagePath || isTextPanel(cut)) {
     return { key: "letter", label: "Letter this cut", opensEditor: true };
   }
-  return { key: "add-art", label: "Add clean art for this cut", opensEditor: false };
+  return {
+    key: "add-art",
+    label: "Add clean art for this cut",
+    opensEditor: false,
+  };
 }
 
 /**
@@ -115,7 +143,9 @@ export function staleTailedCutIds(
   cutsFile: Pick<CutsFile, "cuts">,
   currentVersion: number = CARTOON_BUBBLE_RENDERER_VERSION,
 ): number[] {
-  return cutsFile.cuts.filter((c) => isStaleTailedExport(c, currentVersion)).map((c) => c.id);
+  return cutsFile.cuts
+    .filter((c) => isStaleTailedExport(c, currentVersion))
+    .map((c) => c.id);
 }
 
 /** Base canvas width for a text panel sized from its aspect ratio (#351). */
@@ -127,14 +157,19 @@ export const TEXT_PANEL_BASE_WIDTH = 800;
  * panel letters and exports at the SAME shape. Returns null for a missing or
  * malformed ratio; callers fall back to 800×600.
  */
-export function textPanelDimensions(aspectRatio: string | undefined): { width: number; height: number } | null {
+export function textPanelDimensions(
+  aspectRatio: string | undefined,
+): { width: number; height: number } | null {
   if (!aspectRatio) return null;
   const m = aspectRatio.match(/^\s*(\d+(?:\.\d+)?)\s*:\s*(\d+(?:\.\d+)?)\s*$/);
   if (!m) return null;
   const w = parseFloat(m[1]);
   const h = parseFloat(m[2]);
   if (!(w > 0) || !(h > 0)) return null;
-  return { width: TEXT_PANEL_BASE_WIDTH, height: Math.round((TEXT_PANEL_BASE_WIDTH * h) / w) };
+  return {
+    width: TEXT_PANEL_BASE_WIDTH,
+    height: Math.round((TEXT_PANEL_BASE_WIDTH * h) / w),
+  };
 }
 
 export interface CutsFile {
@@ -170,7 +205,9 @@ export function createDefaultCut(id: number, _plotFile: string): Cut {
 }
 
 export function createCutsFile(plotFile: string, cutCount = 1): CutsFile {
-  const cuts = Array.from({ length: cutCount }, (_, i) => createDefaultCut(i + 1, plotFile));
+  const cuts = Array.from({ length: cutCount }, (_, i) =>
+    createDefaultCut(i + 1, plotFile),
+  );
   return { version: 1, plotFile, cuts };
 }
 
@@ -178,7 +215,10 @@ function cutsFilePath(storyDir: string, plotFile: string): string {
   return path.join(storyDir, `${plotFile}.cuts.json`);
 }
 
-export function readCutsFile(storyDir: string, plotFile: string): CutsFile | null {
+export function readCutsFile(
+  storyDir: string,
+  plotFile: string,
+): CutsFile | null {
   const filePath = cutsFilePath(storyDir, plotFile);
   if (!fs.existsSync(filePath)) return null;
 
@@ -186,7 +226,9 @@ export function readCutsFile(storyDir: string, plotFile: string): CutsFile | nul
   try {
     raw = fs.readFileSync(filePath, "utf-8");
   } catch (err) {
-    throw new Error(`Cannot read ${plotFile}.cuts.json: ${(err as Error).message}`);
+    throw new Error(
+      `Cannot read ${plotFile}.cuts.json: ${(err as Error).message}`,
+    );
   }
 
   let data: unknown;
@@ -204,12 +246,19 @@ export function readCutsFile(storyDir: string, plotFile: string): CutsFile | nul
   return data as CutsFile;
 }
 
-export function writeCutsFile(storyDir: string, plotFile: string, cutsFile: CutsFile): void {
+export function writeCutsFile(
+  storyDir: string,
+  plotFile: string,
+  cutsFile: CutsFile,
+): void {
   const filePath = cutsFilePath(storyDir, plotFile);
   fs.writeFileSync(filePath, JSON.stringify(cutsFile, null, 2) + "\n");
 }
 
-export function validateCutsFile(data: unknown): { valid: boolean; error?: string } {
+export function validateCutsFile(data: unknown): {
+  valid: boolean;
+  error?: string;
+} {
   if (typeof data !== "object" || data === null || Array.isArray(data)) {
     return { valid: false, error: "Must be a JSON object" };
   }
@@ -254,7 +303,10 @@ export function validateCutsFile(data: unknown): { valid: boolean; error?: strin
     }
     for (let j = 0; j < (cut.characters as unknown[]).length; j++) {
       if (typeof (cut.characters as unknown[])[j] !== "string") {
-        return { valid: false, error: `Cut ${i} characters[${j}] must be a string` };
+        return {
+          valid: false,
+          error: `Cut ${i} characters[${j}] must be a string`,
+        };
       }
     }
     if (!Array.isArray(cut.dialogue)) {
@@ -262,8 +314,16 @@ export function validateCutsFile(data: unknown): { valid: boolean; error?: strin
     }
     for (let j = 0; j < (cut.dialogue as unknown[]).length; j++) {
       const d = (cut.dialogue as Record<string, unknown>[])[j];
-      if (typeof d !== "object" || d === null || typeof d.speaker !== "string" || typeof d.text !== "string") {
-        return { valid: false, error: `Cut ${i} dialogue[${j}] must have speaker and text strings` };
+      if (
+        typeof d !== "object" ||
+        d === null ||
+        typeof d.speaker !== "string" ||
+        typeof d.text !== "string"
+      ) {
+        return {
+          valid: false,
+          error: `Cut ${i} dialogue[${j}] must have speaker and text strings`,
+        };
       }
     }
     if (typeof cut.narration !== "string") {
@@ -272,10 +332,19 @@ export function validateCutsFile(data: unknown): { valid: boolean; error?: strin
     if (typeof cut.sfx !== "string") {
       return { valid: false, error: `Cut ${i} missing sfx` };
     }
-    const nullableStrings = ["cleanImagePath", "finalImagePath", "exportedAt", "uploadedCid", "uploadedUrl"] as const;
+    const nullableStrings = [
+      "cleanImagePath",
+      "finalImagePath",
+      "exportedAt",
+      "uploadedCid",
+      "uploadedUrl",
+    ] as const;
     for (const field of nullableStrings) {
       if (cut[field] !== null && typeof cut[field] !== "string") {
-        return { valid: false, error: `Cut ${i} ${field} must be a string or null` };
+        return {
+          valid: false,
+          error: `Cut ${i} ${field} must be a string or null`,
+        };
       }
     }
     if (cut.overlays !== undefined && !Array.isArray(cut.overlays)) {
@@ -285,6 +354,48 @@ export function validateCutsFile(data: unknown): { valid: boolean; error?: strin
     if (cut.kind !== undefined && cut.kind !== "image" && cut.kind !== "text") {
       return { valid: false, error: `Cut ${i} kind must be "image" or "text"` };
     }
+    if (cut.aiDraft !== undefined && cut.aiDraft !== null) {
+      if (typeof cut.aiDraft !== "object") {
+        return {
+          valid: false,
+          error: `Cut ${i} aiDraft must be an object or null`,
+        };
+      }
+      const aiDraft = cut.aiDraft as Record<string, unknown>;
+      if (aiDraft.status !== "generated" && aiDraft.status !== "edited") {
+        return {
+          valid: false,
+          error: `Cut ${i} aiDraft.status must be "generated" or "edited"`,
+        };
+      }
+      if (
+        aiDraft.baseSig !== undefined &&
+        typeof aiDraft.baseSig !== "string"
+      ) {
+        return {
+          valid: false,
+          error: `Cut ${i} aiDraft.baseSig must be a string`,
+        };
+      }
+      if (
+        aiDraft.generatedAt !== undefined &&
+        typeof aiDraft.generatedAt !== "string"
+      ) {
+        return {
+          valid: false,
+          error: `Cut ${i} aiDraft.generatedAt must be a string`,
+        };
+      }
+      if (
+        aiDraft.updatedAt !== undefined &&
+        typeof aiDraft.updatedAt !== "string"
+      ) {
+        return {
+          valid: false,
+          error: `Cut ${i} aiDraft.updatedAt must be a string`,
+        };
+      }
+    }
     if (cut.background !== undefined && typeof cut.background !== "string") {
       return { valid: false, error: `Cut ${i} background must be a string` };
     }
@@ -293,8 +404,14 @@ export function validateCutsFile(data: unknown): { valid: boolean; error?: strin
     }
     // Bubble-renderer version stamp (#381) — optional, backward-compatible
     // (absent ⇒ pre-versioning final image).
-    if (cut.finalRendererVersion !== undefined && typeof cut.finalRendererVersion !== "number") {
-      return { valid: false, error: `Cut ${i} finalRendererVersion must be a number` };
+    if (
+      cut.finalRendererVersion !== undefined &&
+      typeof cut.finalRendererVersion !== "number"
+    ) {
+      return {
+        valid: false,
+        error: `Cut ${i} finalRendererVersion must be a number`,
+      };
     }
   }