vidspotai-shared 1.0.82 → 1.0.84

package/lib/services/crypto/tokenVault.js

@@ -0,0 +1,179 @@
+"use strict";
+/**
+ * Token vault — symmetric encryption for secrets stored at rest in Firestore.
+ *
+ * Social-account OAuth tokens (access + refresh) must NEVER live in Firestore as
+ * plaintext: anyone with a DB export (or an over-broad security rule) would
+ * inherit publish/DM/analytics access to every connected account. We encrypt
+ * them with AES-256-GCM (authenticated encryption) before write and decrypt only
+ * inside workers / Cloud Functions at call time.
+ *
+ * Key management: the 32-byte key comes from `SOCIAL_TOKEN_ENC_KEY` (hex or
+ * base64). In dev it can sit in `.env`; in prod it should be sourced from GCP
+ * Secret Manager and injected as an env var. Rotating the key is supported via
+ * a key-id prefix on the ciphertext (`v1:`) so a future key can decrypt old
+ * blobs by id — see `EncryptedBlob` format below.
+ *
+ * Ciphertext wire format (single string, safe for Firestore):
+ *   `<keyId>:<base64(iv)>:<base64(authTag)>:<base64(ciphertext)>`
+ * keyId lets us roll keys without a migration; iv is random per-encrypt (GCM
+ * must never reuse an iv under the same key).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTokenVaultConfigured = isTokenVaultConfigured;
+exports.encryptToken = encryptToken;
+exports.decryptToken = decryptToken;
+exports.tryDecryptToken = tryDecryptToken;
+exports.safeEqual = safeEqual;
+exports.__resetTokenVaultCacheForTests = __resetTokenVaultCacheForTests;
+const crypto_1 = require("crypto");
+const logger_1 = require("../../utils/logger");
+const ALGORITHM = "aes-256-gcm";
+const IV_BYTES = 12; // GCM standard nonce length
+const KEY_BYTES = 32; // AES-256
+const KEY_ENV = "SOCIAL_TOKEN_ENC_KEY";
+/** Current key id baked into new ciphertext. Bump when rotating keys. */
+const CURRENT_KEY_ID = "v1";
+/**
+ * Resolved encryption keys, indexed by key id. Lets old ciphertext (encrypted
+ * under a retired key) still decrypt after a rotation: set `SOCIAL_TOKEN_ENC_KEY`
+ * to the new key and `SOCIAL_TOKEN_ENC_KEY_<OLDID>` to each retired key.
+ */
+function loadKeys() {
+    const keys = {};
+    const primary = process.env[KEY_ENV];
+    if (primary)
+        keys[CURRENT_KEY_ID] = parseKey(primary, CURRENT_KEY_ID);
+    // Optional retired keys: SOCIAL_TOKEN_ENC_KEY_V0, ..._VN
+    for (const [name, value] of Object.entries(process.env)) {
+        const match = name.match(/^SOCIAL_TOKEN_ENC_KEY_([A-Z0-9]+)$/);
+        if (match && value) {
+            const id = match[1].toLowerCase();
+            keys[id] = parseKey(value, id);
+        }
+    }
+    return keys;
+}
+/** Accept a 32-byte key as hex (64 chars) or base64. Throws on wrong length. */
+function parseKey(raw, keyId) {
+    const trimmed = raw.trim();
+    let buf;
+    if (/^[0-9a-fA-F]{64}$/.test(trimmed)) {
+        buf = Buffer.from(trimmed, "hex");
+    }
+    else {
+        buf = Buffer.from(trimmed, "base64");
+    }
+    if (buf.length !== KEY_BYTES) {
+        throw new Error(`tokenVault: key '${keyId}' must be 32 bytes (got ${buf.length}). ` +
+            `Provide 64 hex chars or 32-byte base64.`);
+    }
+    return buf;
+}
+let keyCache = null;
+function keys() {
+    if (!keyCache)
+        keyCache = loadKeys();
+    return keyCache;
+}
+/** True when at least the current key is configured. Use to gate features. */
+function isTokenVaultConfigured() {
+    try {
+        return Boolean(keys()[CURRENT_KEY_ID]);
+    }
+    catch {
+        return false;
+    }
+}
+function requireKey(keyId) {
+    const k = keys()[keyId];
+    if (!k) {
+        throw new Error(`tokenVault: no key for id '${keyId}'. Set ${KEY_ENV}` +
+            (keyId === CURRENT_KEY_ID ? "" : `_${keyId.toUpperCase()}`) +
+            " (32-byte hex/base64).");
+    }
+    return k;
+}
+/**
+ * Encrypt a plaintext secret. Returns the opaque wire-format string to store.
+ * Empty/whitespace input throws — callers should not persist empty tokens.
+ */
+function encryptToken(plaintext) {
+    if (!plaintext)
+        throw new Error("tokenVault.encryptToken: empty plaintext");
+    const key = requireKey(CURRENT_KEY_ID);
+    const iv = (0, crypto_1.randomBytes)(IV_BYTES);
+    const cipher = (0, crypto_1.createCipheriv)(ALGORITHM, key, iv);
+    const ciphertext = Buffer.concat([
+        cipher.update(plaintext, "utf8"),
+        cipher.final(),
+    ]);
+    const authTag = cipher.getAuthTag();
+    return [
+        CURRENT_KEY_ID,
+        iv.toString("base64"),
+        authTag.toString("base64"),
+        ciphertext.toString("base64"),
+    ].join(":");
+}
+/**
+ * Decrypt a wire-format string produced by `encryptToken`. Throws if the blob is
+ * malformed, the key id is unknown, or the auth tag fails (tampering / wrong
+ * key). Never logs the plaintext.
+ */
+function decryptToken(blob) {
+    const parts = blob.split(":");
+    if (parts.length !== 4) {
+        throw new Error("tokenVault.decryptToken: malformed ciphertext");
+    }
+    const [keyId, ivB64, tagB64, dataB64] = parts;
+    const key = requireKey(keyId);
+    const iv = Buffer.from(ivB64, "base64");
+    const authTag = Buffer.from(tagB64, "base64");
+    const ciphertext = Buffer.from(dataB64, "base64");
+    const decipher = (0, crypto_1.createDecipheriv)(ALGORITHM, key, iv);
+    decipher.setAuthTag(authTag);
+    try {
+        return Buffer.concat([
+            decipher.update(ciphertext),
+            decipher.final(),
+        ]).toString("utf8");
+    }
+    catch (err) {
+        logger_1.logger.warn("tokenVault.decryptToken: auth failed", {
+            keyId,
+            error: err instanceof Error ? err.message : String(err),
+        });
+        throw new Error("tokenVault.decryptToken: authentication failed");
+    }
+}
+/**
+ * Safe wrapper: decrypt, returning null instead of throwing. Use on read paths
+ * where a single corrupt/rotated blob shouldn't crash a batch (e.g. analytics
+ * poller iterating many accounts).
+ */
+function tryDecryptToken(blob) {
+    if (!blob)
+        return null;
+    try {
+        return decryptToken(blob);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Constant-time compare for opaque secrets (e.g. OAuth `state`, webhook
+ * signatures). Avoids leaking length/contents via early-exit timing.
+ */
+function safeEqual(a, b) {
+    const ab = Buffer.from(a);
+    const bb = Buffer.from(b);
+    if (ab.length !== bb.length)
+        return false;
+    return (0, crypto_1.timingSafeEqual)(ab, bb);
+}
+/** Test-only: reset the memoized key cache so env changes take effect. */
+function __resetTokenVaultCacheForTests() {
+    keyCache = null;
+}

package/lib/services/editor/captionStyleHint.d.ts

@@ -0,0 +1,3 @@
+import type { CaptionStyle } from "../../schemas/videoPlan.schema";
+export declare function resolveCaptionStyleHint(hint: string | undefined | null): CaptionStyle;
+//# sourceMappingURL=captionStyleHint.d.ts.map

package/lib/services/editor/captionStyleHint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"captionStyleHint.d.ts","sourceRoot":"","sources":["../../../src/services/editor/captionStyleHint.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AA0EnE,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG,YAAY,CA8CrF"}

package/lib/services/editor/captionStyleHint.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveCaptionStyleHint = resolveCaptionStyleHint;
+/**
+ * CH-1 — translate a free-form caption "style hint" into the structured
+ * {@link CaptionStyle} the renderer actually reads. The in-editor chat agent
+ * accepts hints like "bold yellow", "thin minimal white", or "big TikTok-style
+ * word-pop"; the model usually emits structured fields directly, but the
+ * `add_captions` tool still takes a free-form `styleHint`, and that text was
+ * previously recorded and then discarded. This resolver gives that hint a
+ * deterministic, testable mapping onto color / highlightColor / fontSize /
+ * fontWeight so the look is persisted on the plan (see planToProject) and
+ * survives future caption regenerations.
+ *
+ * Intentionally conservative: only well-understood vocabulary maps to a field.
+ * Anything it can't interpret yields no entry for that field (the renderer
+ * default stands). Returns {} when nothing is recognised — callers should treat
+ * an empty object as "no structured style derived from the hint".
+ */
+/** Named colors we map to stable hex. Kept small + deliberate (not full CSS). */
+const NAMED_COLORS = {
+    white: "#ffffff",
+    black: "#000000",
+    yellow: "#facc15",
+    gold: "#fbbf24",
+    red: "#ef4444",
+    orange: "#fb923c",
+    green: "#22c55e",
+    blue: "#3b82f6",
+    cyan: "#22d3ee",
+    pink: "#ec4899",
+    purple: "#a855f7",
+    violet: "#8b5cf6",
+    lime: "#a3e635",
+};
+/** Weight keywords → numeric font-weight (100–900). */
+const WEIGHT_WORDS = [
+    [/\b(thin|hairline)\b/, 100],
+    [/\b(extra[\s-]?light|ultra[\s-]?light)\b/, 200],
+    [/\b(light)\b/, 300],
+    [/\b(normal|regular|book)\b/, 400],
+    [/\b(medium)\b/, 500],
+    [/\b(semi[\s-]?bold|demi[\s-]?bold)\b/, 600],
+    // "extra/ultra/heavy/black/boldest/bolder" outrank plain "bold".
+    [/\b(extra[\s-]?bold|ultra[\s-]?bold|heavy|black|boldest|bolder)\b/, 900],
+    [/\b(bold)\b/, 700],
+];
+/** Size keywords → px. Only applied when no explicit pixel value is present. */
+const SIZE_WORDS = [
+    [/\b(huge|giant|massive|enormous)\b/, 96],
+    [/\b(big|large|larger|bigger)\b/, 72],
+    [/\b(small|smaller|tiny)\b/, 36],
+];
+/** Every color mention (hex or named) with its position, sorted left-to-right. */
+function colorHits(text) {
+    const hits = [];
+    const hexRe = /#[0-9a-f]{3,8}\b/gi;
+    let m;
+    while ((m = hexRe.exec(text)))
+        hits.push({ index: m.index, value: m[0].toLowerCase() });
+    for (const [name, value] of Object.entries(NAMED_COLORS)) {
+        const re = new RegExp(`\\b${name}\\b`, "g");
+        while ((m = re.exec(text)))
+            hits.push({ index: m.index, value });
+    }
+    return hits.sort((a, b) => a.index - b.index);
+}
+function resolveCaptionStyleHint(hint) {
+    const out = {};
+    if (typeof hint !== "string" || !hint.trim())
+        return out;
+    const text = hint.toLowerCase();
+    // Weight — first matching rule wins (heavier synonyms are listed first).
+    for (const [re, weight] of WEIGHT_WORDS) {
+        if (re.test(text)) {
+            out.fontWeight = weight;
+            break;
+        }
+    }
+    // Size — explicit "<n>px" / "size <n>" beats keyword buckets.
+    const px = /(\d{2,3})\s*px\b/.exec(text) ?? /\bsize\s+(\d{2,3})\b/.exec(text);
+    if (px) {
+        const n = Number.parseInt(px[1], 10);
+        if (Number.isFinite(n))
+            out.fontSize = Math.max(8, Math.min(200, n));
+    }
+    else {
+        for (const [re, size] of SIZE_WORDS) {
+            if (re.test(text)) {
+                out.fontSize = size;
+                break;
+            }
+        }
+    }
+    // Color assignment is position-aware. When "highlight" appears, the color
+    // nearest that word is the highlightColor; the first *other* color (by
+    // position) becomes the base color. Without "highlight", the first color is
+    // the base.
+    const hits = colorHits(text);
+    if (hits.length) {
+        const hi = text.search(/\bhighlight/);
+        let highlightHit;
+        if (hi >= 0) {
+            highlightHit = hits.reduce((best, h) => Math.abs(h.index - hi) < Math.abs(best.index - hi) ? h : best);
+            out.highlightColor = highlightHit.value;
+        }
+        const base = hits.find((h) => h !== highlightHit);
+        if (base)
+            out.color = base.value;
+    }
+    return out;
+}

package/lib/services/editor/planToProject.d.ts

@@ -1,5 +1,7 @@
-import type { Project, TextClip } from "../../schemas/project.schema";
-import type { TextOverlay, VideoPlan } from "../../schemas/videoPlan.schema";
+import type { Project } from "../../schemas/project.schema";
+import type { PlanToProjectInput } from "./planToProject.types";
+export { TRACK_ID, buildOverlayClipsForScene } from "./planToProject.helpers";
+export type { PlanToProjectInput, SceneRenderOutcome } from "./planToProject.types";
 /**
  * planToProject — pure translator from an approved VideoPlan + per-scene
  * executor outcomes into the canonical Project IR. The Project is what gets
@@ -14,71 +16,10 @@ import type { TextOverlay, VideoPlan } from "../../schemas/videoPlan.schema";
  * a placeholder data URL is emitted so the Project is schema-valid and the
  * editor can render a grey placeholder pinned to the scene's intended
  * duration. Worker fills in the real URL via Firestore update later.
- */
-export interface SceneRenderOutcome {
-    /** Resolved URL for the scene's visual asset (image or video). */
-    visualUrl?: string;
-    /** Resolved URL for the scene's voiceover. */
-    voiceoverUrl?: string;
-    /**
-     * VO duration in ms used by planToProject to size the clip's display
-     * window. When set from a probed actual mp3 (preferred), reflects real
-     * playback length; when set from the wpm estimator it can undershoot
-     * emotive/punctuated lines by 400–900ms and the editor's Remotion Audio
-     * truncates at endAt. Caller should set the actual when available.
-     */
-    voiceoverDurationMs?: number;
-    /** Resolved URL for an external captions file (.vtt/.srt) if any. */
-    captionsUrl?: string;
-    /** Word-level caption timing (start/end ms within scene). */
-    captionWords?: Array<{
-        word: string;
-        start: number;
-        end: number;
-    }>;
-    /** Final model key the executor landed on (may differ from preferredModel). */
-    modelKey?: string;
-    /** Provider chain walked, primary first; recorded in provenance. */
-    attemptedProviders?: string[];
-    /** Provider idempotency key (used for reuse on regen). */
-    generationId?: string;
-    /** Credits actually spent on this scene. */
-    creditsSpent?: number;
-    /** Content hash of the visual asset, when computed. */
-    assetHash?: string;
-}
-export interface PlanToProjectInput {
-    plan: VideoPlan;
-    outcomes?: Record<number, SceneRenderOutcome | undefined>;
-    projectId: string;
-    name?: string;
-    agentRunId?: string;
-    /** When set, overrides plan.music.url (caller can swap to CDN-hosted version). */
-    musicUrl?: string;
-    /** Music duration in ms; falls back to plan.music.durationSec*1000 if unset. */
-    musicDurationMs?: number;
-    /** Project createdAt; defaults to now. */
-    createdAt?: string;
-    /** Project updatedAt; defaults to now. */
-    updatedAt?: string;
-}
-export declare const TRACK_ID: {
-    readonly visual: "track-visual";
-    readonly voiceover: "track-vo";
-    readonly music: "track-music";
-    readonly text: "track-text";
-    readonly caption: "track-caption";
-};
-/**
- * Build the TextClip[] for a single scene's overlays at a known timeline
- * offset. Extracted from the planToProject loop so the regen handlers
- * (Stage 6 slice 4) can splice fresh overlays into projectJson without
- * duplicating the role → font/size/weight mapping. Pure / no I/O.
  *
- * `offsetMs` is the scene's start on the master timeline (cumulative sum
- * of prior scene durations). `sceneDurationMs` clamps any overlay.endMs
- * that overshoots the scene.
+ * Input/outcome types live in ./planToProject.types; the pure clip-builder
+ * helpers (track ids, size/transition lookups, overlay styling) in
+ * ./planToProject.helpers.
  */
-export declare function buildOverlayClipsForScene(sceneIndex: number, offsetMs: number, sceneDurationMs: number, overlays: readonly TextOverlay[], frameHeight: number): TextClip[];
 export declare function planToProject(input: PlanToProjectInput): Project;
 //# sourceMappingURL=planToProject.d.ts.map

package/lib/services/editor/planToProject.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"planToProject.d.ts","sourceRoot":"","sources":["../../../src/services/editor/planToProject.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAKV,OAAO,EAEP,QAAQ,EAIT,MAAM,8BAA8B,CAAC;AAEtC,OAAO,KAAK,EAGV,WAAW,EAEX,SAAS,EACV,MAAM,gCAAgC,CAAC;AAExC;;;;;;;;;;;;;;GAcG;AAEH,MAAM,WAAW,kBAAkB;IACjC,kEAAkE;IAClE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,8CAA8C;IAC9C,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;;OAMG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,qEAAqE;IACrE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,6DAA6D;IAC7D,YAAY,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACnE,+EAA+E;IAC/E,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,oEAAoE;IACpE,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC9B,0DAA0D;IAC1D,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,4CAA4C;IAC5C,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,uDAAuD;IACvD,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,SAAS,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,GAAG,SAAS,CAAC,CAAC;IAC1D,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,kFAAkF;IAClF,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,gFAAgF;IAChF,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,0CAA0C;IAC1C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,0CAA0C;IAC1C,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAID,eAAO,MAAM,QAAQ;;;;;;CAMX,CAAC;AA4GX;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CACvC,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,eAAe,EAAE,MAAM,EACvB,QAAQ,EAAE,SAAS,WAAW,EAAE,EAChC,WAAW,EAAE,MAAM,GAClB,QAAQ,EAAE,CAoCZ;AAID,wBAAgB,aAAa,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAuPhE"}
+{"version":3,"file":"planToProject.d.ts","sourceRoot":"","sources":["../../../src/services/editor/planToProject.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAKV,OAAO,EAIR,MAAM,8BAA8B,CAAC;AAEtC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAchE,OAAO,EAAE,QAAQ,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAC;AAC9E,YAAY,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAEpF;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAmYhE"}

package/lib/services/editor/planToProject.helpers.d.ts

@@ -0,0 +1,40 @@
+import type { Provenance, TextClip, Track, Transition } from "../../schemas/project.schema";
+import type { PlannedScene, SceneAssetStrategy, TextOverlay, TransitionKind, VideoPlan } from "../../schemas/videoPlan.schema";
+import type { SceneRenderOutcome } from "./planToProject.types";
+/**
+ * Pure building blocks for planToProject: track ids, strategy/transition/size
+ * lookups, provenance + overlay styling, the per-scene overlay clip builder,
+ * and the track factory. No I/O. Split out so the translator reads as the
+ * scene-walk orchestration and the regen handlers can reuse
+ * buildOverlayClipsForScene without re-deriving the role → font mapping.
+ */
+export declare const TRACK_ID: {
+    readonly visual: "track-visual";
+    readonly broll: "track-broll";
+    readonly voiceover: "track-vo";
+    readonly music: "track-music";
+    readonly text: "track-text";
+    readonly caption: "track-caption";
+};
+export declare function isStillStrategy(s: SceneAssetStrategy): boolean;
+/** A passable URL we can put in skeleton clips so ProjectSchema.url() passes. */
+export declare const PLACEHOLDER_URL = "data:,placeholder";
+export declare function sizeForAspect(aspect: VideoPlan["aspect"]): {
+    width: number;
+    height: number;
+};
+export declare const TRANSITION_KIND_MAP: Record<TransitionKind, Transition["kind"] | null>;
+export declare function provenanceForScene(scene: PlannedScene, outcome: SceneRenderOutcome | undefined): Provenance;
+/**
+ * Build the TextClip[] for a single scene's overlays at a known timeline
+ * offset. Extracted from the planToProject loop so the regen handlers
+ * (Stage 6 slice 4) can splice fresh overlays into projectJson without
+ * duplicating the role → font/size/weight mapping. Pure / no I/O.
+ *
+ * `offsetMs` is the scene's start on the master timeline (cumulative sum
+ * of prior scene durations). `sceneDurationMs` clamps any overlay.endMs
+ * that overshoots the scene.
+ */
+export declare function buildOverlayClipsForScene(sceneIndex: number, offsetMs: number, sceneDurationMs: number, overlays: readonly TextOverlay[], frameHeight: number): TextClip[];
+export declare function makeTrack(id: string, kind: Track["kind"], index: number, name: string): Track;
+//# sourceMappingURL=planToProject.helpers.d.ts.map

package/lib/services/editor/planToProject.helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"planToProject.helpers.d.ts","sourceRoot":"","sources":["../../../src/services/editor/planToProject.helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,QAAQ,EACR,KAAK,EACL,UAAU,EACX,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EACV,YAAY,EACZ,kBAAkB,EAClB,WAAW,EACX,cAAc,EACd,SAAS,EACV,MAAM,gCAAgC,CAAC;AACxC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAEhE;;;;;;GAMG;AAIH,eAAO,MAAM,QAAQ;;;;;;;CASX,CAAC;AASX,wBAAgB,eAAe,CAAC,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAE9D;AAED,iFAAiF;AACjF,eAAO,MAAM,eAAe,sBAAsB,CAAC;AAInD,wBAAgB,aAAa,CAAC,MAAM,EAAE,SAAS,CAAC,QAAQ,CAAC,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAW5F;AAID,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,cAAc,EAAE,UAAU,CAAC,MAAM,CAAC,GAAG,IAAI,CASjF,CAAC;AAIF,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,YAAY,EACnB,OAAO,EAAE,kBAAkB,GAAG,SAAS,GACtC,UAAU,CAiBZ;AA4CD;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CACvC,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,eAAe,EAAE,MAAM,EACvB,QAAQ,EAAE,SAAS,WAAW,EAAE,EAChC,WAAW,EAAE,MAAM,GAClB,QAAQ,EAAE,CAoCZ;AAED,wBAAgB,SAAS,CACvB,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,EACnB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,GACX,KAAK,CAWP"}

package/lib/services/editor/planToProject.helpers.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TRANSITION_KIND_MAP = exports.PLACEHOLDER_URL = exports.TRACK_ID = void 0;
+exports.isStillStrategy = isStillStrategy;
+exports.sizeForAspect = sizeForAspect;
+exports.provenanceForScene = provenanceForScene;
+exports.buildOverlayClipsForScene = buildOverlayClipsForScene;
+exports.makeTrack = makeTrack;
+/**
+ * Pure building blocks for planToProject: track ids, strategy/transition/size
+ * lookups, provenance + overlay styling, the per-scene overlay clip builder,
+ * and the track factory. No I/O. Split out so the translator reads as the
+ * scene-walk orchestration and the regen handlers can reuse
+ * buildOverlayClipsForScene without re-deriving the role → font mapping.
+ */
+// ─── track id constants ──────────────────────────────────────────────────
+exports.TRACK_ID = {
+    visual: "track-visual",
+    // CH-6 — second video lane for B-roll overlays, composited ABOVE the main
+    // visual (higher track index → painted on top).
+    broll: "track-broll",
+    voiceover: "track-vo",
+    music: "track-music",
+    text: "track-text",
+    caption: "track-caption",
+};
+// ─── strategy → clip kind ────────────────────────────────────────────────
+const STILL_STRATEGIES = new Set([
+    "stock-image-ken-burns",
+    "ai-image-static",
+]);
+function isStillStrategy(s) {
+    return STILL_STRATEGIES.has(s);
+}
+/** A passable URL we can put in skeleton clips so ProjectSchema.url() passes. */
+exports.PLACEHOLDER_URL = "data:,placeholder";
+// ─── aspect → size defaults ──────────────────────────────────────────────
+function sizeForAspect(aspect) {
+    switch (aspect) {
+        case "9:16":
+            return { width: 1080, height: 1920 };
+        case "1:1":
+            return { width: 1080, height: 1080 };
+        case "4:5":
+            return { width: 1080, height: 1350 };
+        case "16:9":
+            return { width: 1920, height: 1080 };
+    }
+}
+// ─── transition kind → renderable subset ─────────────────────────────────
+exports.TRANSITION_KIND_MAP = {
+    none: null,
+    cut: null,
+    fade: "fade",
+    crossfade: "crossfade",
+    wipe: "wipe",
+    whipPan: "whipPan",
+    dipToBlack: "dipToBlack",
+    dipToWhite: "dipToWhite",
+};
+// ─── provenance builder ──────────────────────────────────────────────────
+function provenanceForScene(scene, outcome) {
+    const attempted = outcome?.attemptedProviders;
+    const source = (attempted && attempted.length > 0 ? attempted[0] : undefined) ??
+        scene.preferredProvider ??
+        scene.strategy;
+    return {
+        tier: scene.tier,
+        source,
+        modelKey: outcome?.modelKey ?? scene.preferredModel,
+        prompt: scene.prompt,
+        assetHash: outcome?.assetHash,
+        creditsSpent: outcome?.creditsSpent ?? scene.estimatedCredits,
+        generationId: outcome?.generationId,
+        // P-UNS-2: visible-credit attribution for licenses that require it (Unsplash).
+        attribution: outcome?.attribution,
+    };
+}
+// ─── overlay role → text styling defaults ────────────────────────────────
+function fontSizeForOverlay(o, frameHeight) {
+    // Explicit px wins.
+    if (typeof o.fontSize === "number")
+        return o.fontSize;
+    // sizePct (2–20% of frame height) → px. Resolution-independent.
+    if (typeof o.sizePct === "number") {
+        return Math.max(8, Math.round((o.sizePct / 100) * frameHeight));
+    }
+    switch (o.role) {
+        case "headline":
+            return 96;
+        case "cta":
+            return 72;
+        case "subheadline":
+        case "body":
+            return 48;
+        case "watermark":
+        case "disclaimer":
+        case "label":
+            return 28;
+    }
+}
+function fontWeightForOverlay(o) {
+    if (o.weight) {
+        return { regular: 400, medium: 500, bold: 700, black: 900 }[o.weight];
+    }
+    switch (o.role) {
+        case "headline":
+        case "cta":
+            return 900;
+        case "subheadline":
+            return 700;
+        case "watermark":
+        case "disclaimer":
+            return 400;
+        default:
+            return 700;
+    }
+}
+/**
+ * Build the TextClip[] for a single scene's overlays at a known timeline
+ * offset. Extracted from the planToProject loop so the regen handlers
+ * (Stage 6 slice 4) can splice fresh overlays into projectJson without
+ * duplicating the role → font/size/weight mapping. Pure / no I/O.
+ *
+ * `offsetMs` is the scene's start on the master timeline (cumulative sum
+ * of prior scene durations). `sceneDurationMs` clamps any overlay.endMs
+ * that overshoots the scene.
+ */
+function buildOverlayClipsForScene(sceneIndex, offsetMs, sceneDurationMs, overlays, frameHeight) {
+    const clips = [];
+    for (const [oi, overlay] of overlays.entries()) {
+        const overlayFrom = offsetMs + Math.max(0, overlay.startMs ?? 0);
+        const overlayTo = offsetMs + Math.min(sceneDurationMs, overlay.endMs ?? sceneDurationMs);
+        if (overlayTo <= overlayFrom)
+            continue;
+        clips.push({
+            id: `scene-${sceneIndex}-overlay-${oi}`,
+            trackId: exports.TRACK_ID.text,
+            type: "text",
+            display: { from: overlayFrom, to: overlayTo },
+            name: overlay.role,
+            text: overlay.text,
+            fontFamily: overlay.font ?? "Poppins",
+            fontSize: fontSizeForOverlay(overlay, frameHeight),
+            fontWeight: fontWeightForOverlay(overlay),
+            color: overlay.color ?? "#ffffff",
+            align: "center",
+            backgroundColor: overlay.bgColor,
+            effects: [],
+            transform: { x: 0, y: 0, scaleX: 1, scaleY: 1, rotation: 0, opacity: 1 },
+            locked: false,
+            metadata: {
+                sceneIndex,
+                role: overlay.role,
+                position: overlay.position,
+                emphasis: overlay.emphasis,
+                animation: overlay.animation,
+                bgStyle: overlay.bgStyle,
+                sizePct: overlay.sizePct,
+                persistAcrossScenes: overlay.persistAcrossScenes ?? false,
+            },
+        });
+    }
+    return clips;
+}
+function makeTrack(id, kind, index, name) {
+    return {
+        id,
+        kind,
+        name,
+        index,
+        muted: false,
+        hidden: false,
+        locked: false,
+        gainDb: 0,
+    };
+}