vidspotai-shared 1.0.94 → 1.0.96

package/lib/services/avatarGen/providers/tavusAvatarProvider.d.ts

@@ -0,0 +1,56 @@
+import { EVideoGenModels } from "../../../globals/aiModels";
+import { AvatarCapabilities, AvatarGenerateRequest, AvatarOption, AvatarStatusQuery, AvatarStatusResult, AvatarSubmitResult, ConsentRecord, EAvatarEngine, IAvatarVideoProvider, ISupportsHostedCatalog, ISupportsReplica, VoiceOption } from "../IAvatarVideoProvider";
+/**
+ * Tavus avatar engine — a HOSTED engine driven by a trained "replica"
+ * (Tavus's term for a likeness model). The caller supplies a replica_id + a
+ * script; Tavus synthesizes the voice (the replica's cloned voice) and lipsyncs
+ * natively. Tavus's differentiator is multilingual / dubbing — see the dubbing
+ * note at the bottom of this class.
+ *
+ * Contract (Tavus API, verified 2026-06-26 against docs.tavus.io):
+ *   • submit  : POST /v2/videos        { replica_id, script, video_name? }
+ *                                        → { video_id, status, hosted_url }
+ *   • status  : GET  /v2/videos/{id}    → { status: queued|generating|ready|
+ *                                            deleted|error, download_url,
+ *                                            stream_url, hosted_url, status_details }
+ *   • replicas: POST /v2/replicas       { train_video_url, consent_video_url?,
+ *                                          replica_name, callback_url? }
+ *                                        → { replica_id, status }
+ *               GET  /v2/replicas        → { data: [{ replica_id, replica_name,
+ *                                            status, thumbnail_video_url }] }
+ *   • auth    : x-api-key header
+ *
+ * For Tavus the hosted "avatar" IS the replica, so a hosted request maps
+ * `hostedAvatarId` → `replica_id` (`hostedVoiceId` is unused; the replica owns
+ * its voice). Standalone class — Tavus has no place in the generic video
+ * factory; avatar gen is its own concern (see IAvatarVideoProvider).
+ */
+export declare class TavusAvatarProvider implements IAvatarVideoProvider, ISupportsHostedCatalog, ISupportsReplica {
+    private readonly modelKey;
+    /** Static so callers can branch on capability without constructing (which
+     *  would require TAVUS_API_KEY just to read the input mode). */
+    static readonly CAPABILITIES: AvatarCapabilities;
+    readonly engine = EAvatarEngine.TAVUS;
+    readonly capabilities: AvatarCapabilities;
+    private readonly baseUrl;
+    private readonly apiKey;
+    private readonly submitTimeout;
+    private readonly statusTimeout;
+    constructor(modelKey?: EVideoGenModels);
+    generate(req: AvatarGenerateRequest): Promise<AvatarSubmitResult>;
+    checkStatus(query: AvatarStatusQuery): Promise<AvatarStatusResult>;
+    createReplica(trainingMediaUrl: string, consent: ConsentRecord): Promise<{
+        replicaId: string;
+    }>;
+    /** For Tavus the catalog of "avatars" is the account's trained replicas. */
+    listAvatars(): Promise<AvatarOption[]>;
+    /**
+     * Tavus voices are bound to the replica (its cloned voice), so there is no
+     * standalone voice catalog to pick from — return empty. Hosted requests leave
+     * `hostedVoiceId` unused for Tavus.
+     */
+    listVoices(): Promise<VoiceOption[]>;
+    private request;
+    private requestWithRetry;
+}
+//# sourceMappingURL=tavusAvatarProvider.d.ts.map

package/lib/services/avatarGen/providers/tavusAvatarProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tavusAvatarProvider.d.ts","sourceRoot":"","sources":["../../../../src/services/avatarGen/providers/tavusAvatarProvider.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAG5D,OAAO,EACL,kBAAkB,EAClB,qBAAqB,EACrB,YAAY,EACZ,iBAAiB,EACjB,kBAAkB,EAClB,kBAAkB,EAClB,aAAa,EACb,aAAa,EACb,oBAAoB,EACpB,sBAAsB,EACtB,gBAAgB,EAChB,WAAW,EACZ,MAAM,yBAAyB,CAAC;AAEjC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,mBACX,YAAW,oBAAoB,EAAE,sBAAsB,EAAE,gBAAgB;IAmBvE,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAjB3B;oEACgE;IAChE,MAAM,CAAC,QAAQ,CAAC,YAAY,EAAE,kBAAkB,CAI9C;IAEF,QAAQ,CAAC,MAAM,uBAAuB;IACtC,QAAQ,CAAC,YAAY,qBAAoC;IAEzD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA0B;IAClD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAW;IACzC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAU;gBAGrB,QAAQ,GAAE,eAA8C;IAQrE,QAAQ,CAAC,GAAG,EAAE,qBAAqB,GAAG,OAAO,CAAC,kBAAkB,CAAC;IA4BjE,WAAW,CAAC,KAAK,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAiClE,aAAa,CACjB,gBAAgB,EAAE,MAAM,EACxB,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;IA2BjC,4EAA4E;IACtE,WAAW,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC;IAgB5C;;;;OAIG;IACG,UAAU,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;YAM5B,OAAO;YA0BP,gBAAgB;CAiE/B"}

package/lib/services/avatarGen/providers/tavusAvatarProvider.js

@@ -0,0 +1,183 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TavusAvatarProvider = void 0;
+const axios_1 = __importDefault(require("axios"));
+const aiModels_1 = require("../../../globals/aiModels");
+const types_1 = require("../../../globals/types");
+const logger_1 = require("../../../utils/logger");
+const IAvatarVideoProvider_1 = require("../IAvatarVideoProvider");
+/**
+ * Tavus avatar engine — a HOSTED engine driven by a trained "replica"
+ * (Tavus's term for a likeness model). The caller supplies a replica_id + a
+ * script; Tavus synthesizes the voice (the replica's cloned voice) and lipsyncs
+ * natively. Tavus's differentiator is multilingual / dubbing — see the dubbing
+ * note at the bottom of this class.
+ *
+ * Contract (Tavus API, verified 2026-06-26 against docs.tavus.io):
+ *   • submit  : POST /v2/videos        { replica_id, script, video_name? }
+ *                                        → { video_id, status, hosted_url }
+ *   • status  : GET  /v2/videos/{id}    → { status: queued|generating|ready|
+ *                                            deleted|error, download_url,
+ *                                            stream_url, hosted_url, status_details }
+ *   • replicas: POST /v2/replicas       { train_video_url, consent_video_url?,
+ *                                          replica_name, callback_url? }
+ *                                        → { replica_id, status }
+ *               GET  /v2/replicas        → { data: [{ replica_id, replica_name,
+ *                                            status, thumbnail_video_url }] }
+ *   • auth    : x-api-key header
+ *
+ * For Tavus the hosted "avatar" IS the replica, so a hosted request maps
+ * `hostedAvatarId` → `replica_id` (`hostedVoiceId` is unused; the replica owns
+ * its voice). Standalone class — Tavus has no place in the generic video
+ * factory; avatar gen is its own concern (see IAvatarVideoProvider).
+ */
+class TavusAvatarProvider {
+    constructor(modelKey = aiModels_1.EVideoGenModels.TAVUS_AVATAR) {
+        this.modelKey = modelKey;
+        this.engine = IAvatarVideoProvider_1.EAvatarEngine.TAVUS;
+        this.capabilities = TavusAvatarProvider.CAPABILITIES;
+        this.baseUrl = "https://tavusapi.com";
+        this.submitTimeout = 120000;
+        this.statusTimeout = 60000;
+        if (!process.env.TAVUS_API_KEY) {
+            throw new Error("Missing TAVUS_API_KEY in environment variables");
+        }
+        this.apiKey = process.env.TAVUS_API_KEY;
+    }
+    async generate(req) {
+        if (req.mode !== "hosted") {
+            throw new Error(`TavusAvatarProvider only supports hosted requests (got "${req.mode}")`);
+        }
+        const body = {
+            replica_id: req.hostedAvatarId, // Tavus: the hosted avatar IS the replica
+            script: req.script,
+            video_name: `vidspot-${req.hostedAvatarId}-${req.script.slice(0, 24)}`,
+        };
+        const data = await this.request("/v2/videos", "POST", body, this.submitTimeout);
+        const videoId = data?.video_id;
+        if (!videoId) {
+            throw new Error(`Tavus submit returned no video_id: ${JSON.stringify(data?.message ?? data)}`);
+        }
+        return { providerTaskId: videoId };
+    }
+    async checkStatus(query) {
+        const data = await this.requestWithRetry(`/v2/videos/${encodeURIComponent(query.providerTaskId)}`, "GET", undefined, this.statusTimeout);
+        // Tavus status enum: queued | generating | ready | deleted | error.
+        if (data?.status === "ready") {
+            return {
+                status: types_1.EVideoSceneStatus.COMPLETED,
+                // Prefer the direct download URL; fall back to stream/hosted.
+                videoUrl: data.download_url ?? data.stream_url ?? data.hosted_url,
+            };
+        }
+        if (data?.status === "error" || data?.status === "deleted") {
+            return {
+                status: types_1.EVideoSceneStatus.FAILED,
+                errorMessage: data.status_details ?? `Tavus render ${data.status}`,
+            };
+        }
+        return { status: types_1.EVideoSceneStatus.PENDING };
+    }
+    // ─── ISupportsReplica ─────────────────────────────────────────────────────
+    async createReplica(trainingMediaUrl, consent) {
+        const body = {
+            train_video_url: trainingMediaUrl,
+            replica_name: `vidspot-${consent.userId}-${consent.capturedAt}`,
+            // Tavus accepts a separate consent clip; we pass the same training media
+            // when no dedicated consent video exists (the statement is recorded in
+            // our own ConsentRecord audit trail regardless).
+            consent_video_url: trainingMediaUrl,
+        };
+        const data = await this.request("/v2/replicas", "POST", body, this.submitTimeout);
+        if (!data?.replica_id) {
+            throw new Error(`Tavus createReplica returned no replica_id: ${JSON.stringify(data)}`);
+        }
+        return { replicaId: data.replica_id };
+    }
+    // ─── ISupportsHostedCatalog ───────────────────────────────────────────────
+    /** For Tavus the catalog of "avatars" is the account's trained replicas. */
+    async listAvatars() {
+        const data = await this.requestWithRetry("/v2/replicas", "GET", undefined, this.statusTimeout);
+        return (data?.data ?? []).map((r) => ({
+            id: r.replica_id,
+            name: r.replica_name ?? r.replica_id,
+            previewUrl: r.thumbnail_video_url,
+        }));
+    }
+    /**
+     * Tavus voices are bound to the replica (its cloned voice), so there is no
+     * standalone voice catalog to pick from — return empty. Hosted requests leave
+     * `hostedVoiceId` unused for Tavus.
+     */
+    async listVoices() {
+        return [];
+    }
+    // ─── Transport ────────────────────────────────────────────────────────────
+    async request(endpoint, method, body, timeout = this.submitTimeout) {
+        const config = {
+            method,
+            url: `${this.baseUrl}${endpoint}`,
+            headers: {
+                "x-api-key": this.apiKey,
+                "Content-Type": "application/json",
+            },
+            timeout,
+            data: body,
+        };
+        const response = await axios_1.default.request(config);
+        if (response.status < 200 || response.status >= 300) {
+            throw new Error(`Tavus API Error: ${response.status} ${response.statusText} — ${JSON.stringify(response.data)}`);
+        }
+        return response.data;
+    }
+    async requestWithRetry(endpoint, method, body, timeout = this.statusTimeout, maxAttempts = 4) {
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            try {
+                return await this.request(endpoint, method, body, timeout);
+            }
+            catch (err) {
+                const e = err;
+                const httpStatus = e.response?.status;
+                const isTimeout = e.code === "ECONNABORTED" || (e.message?.includes("timeout") ?? false);
+                const isNetworkError = e.code === "ECONNRESET" ||
+                    e.code === "ECONNREFUSED" ||
+                    e.code === "ENOTFOUND" ||
+                    e.code === "ERR_NETWORK";
+                const isRateLimit = httpStatus === 429;
+                const isRetryable = isTimeout || isNetworkError || isRateLimit;
+                if (!isRetryable || attempt === maxAttempts) {
+                    logger_1.logger.error("Tavus request failed (non-retryable or max attempts)", {
+                        endpoint,
+                        attempt,
+                        maxAttempts,
+                        httpStatus,
+                        errorCode: e.code,
+                        errorMessage: e.message,
+                    });
+                    throw err;
+                }
+                const backoffMs = isRateLimit ? 10000 : 1000;
+                logger_1.logger.warn("Tavus request failed — retrying", {
+                    endpoint,
+                    attempt,
+                    maxAttempts,
+                    httpStatus,
+                    backoffMs,
+                });
+                await new Promise((r) => setTimeout(r, backoffMs));
+            }
+        }
+        throw new Error("Unreachable");
+    }
+}
+exports.TavusAvatarProvider = TavusAvatarProvider;
+/** Static so callers can branch on capability without constructing (which
+ *  would require TAVUS_API_KEY just to read the input mode). */
+TavusAvatarProvider.CAPABILITIES = {
+    inputMode: "hosted",
+    nativeTts: true,
+    multiSceneSplit: false,
+};

package/lib/services/demo/demoAuthor.d.ts

@@ -0,0 +1,45 @@
+import { LlmCaller } from "../agent/llmCaller";
+import { ModelChoice, ModelRouter } from "../agent/modelRouter";
+import { DemoAuthorInput } from "./demoAuthorPrompt";
+import { NormalizeResult } from "./demoAuthorNormalize";
+export interface DemoAuthorDeps {
+    /** LLM caller. Defaults to the host-wired dispatcher. */
+    llm?: LlmCaller;
+    /** Model router. Defaults to DEFAULT_MODEL_ROUTING. */
+    router?: ModelRouter;
+    /** Route the planner to the premium tier (Opus) for higher-fidelity authoring. */
+    premium?: boolean;
+    /** Sampling temperature. Creative-but-structured default. */
+    temperature?: number;
+    /** Max output tokens — a full DemoSpec with rich scenes can be large. */
+    maxTokens?: number;
+    /**
+     * Allow the planner to propose Layer-B `custom` scenes (with an `intent`
+     * brief). Threaded from the worker's `DEMO_CODEGEN_ENABLED` gate; default
+     * false, so the author never emits a `custom` scene the pipeline can't fill.
+     */
+    allowCustomScenes?: boolean;
+    /**
+     * Allow the planner to commission AI-generated media (`generatedAssets` +
+     * `gen://` refs). Default true; the worker passes false only under the
+     * DEMO_GEN_ASSETS_DISABLED kill-switch.
+     */
+    allowGeneratedAssets?: boolean;
+}
+export interface DemoAuthorResult extends NormalizeResult {
+    /** Model that produced the spec (primary or fallback). */
+    modelUsed: ModelChoice;
+    usedFallback?: boolean;
+    usage?: {
+        promptTokens?: number;
+        completionTokens?: number;
+    };
+}
+/**
+ * Author a render-ready DemoSpec from inputs. Pure orchestration: build the
+ * prompt, attach screenshots as vision, call `.structured(DemoSpec)`, then
+ * normalize. Throws if the caller is unconfigured or the model returns an
+ * unparseable / scene-less spec (the normalize pass is the last guard).
+ */
+export declare function authorDemoSpec(input: DemoAuthorInput, deps?: DemoAuthorDeps): Promise<DemoAuthorResult>;
+//# sourceMappingURL=demoAuthor.d.ts.map

package/lib/services/demo/demoAuthor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"demoAuthor.d.ts","sourceRoot":"","sources":["../../../src/services/demo/demoAuthor.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAE/C,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,EACL,eAAe,EAGhB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,eAAe,EAAqB,MAAM,uBAAuB,CAAC;AAqB3E,MAAM,WAAW,cAAc;IAC7B,yDAAyD;IACzD,GAAG,CAAC,EAAE,SAAS,CAAC;IAChB,uDAAuD;IACvD,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,kFAAkF;IAClF,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,6DAA6D;IAC7D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,yEAAyE;IACzE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B;;;;OAIG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC;AAED,MAAM,WAAW,gBAAiB,SAAQ,eAAe;IACvD,0DAA0D;IAC1D,SAAS,EAAE,WAAW,CAAC;IACvB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,KAAK,CAAC,EAAE;QAAE,YAAY,CAAC,EAAE,MAAM,CAAC;QAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAC9D;AAED;;;;;GAKG;AACH,wBAAsB,cAAc,CAClC,KAAK,EAAE,eAAe,EACtB,IAAI,GAAE,cAAmB,GACxB,OAAO,CAAC,gBAAgB,CAAC,CAgD3B"}

package/lib/services/demo/demoAuthor.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authorDemoSpec = authorDemoSpec;
+const demoSpec_schema_1 = require("../../schemas/demoSpec.schema");
+const llmCallerRegistry_1 = require("../agent/llmCallerRegistry");
+const modelRouter_1 = require("../agent/modelRouter");
+const demoAuthorPrompt_1 = require("./demoAuthorPrompt");
+const demoAuthorNormalize_1 = require("./demoAuthorNormalize");
+/**
+ * DemoSpec author — the "plan" stage of the SaaS Demo Video pipeline (plan
+ * Phase 3 / §4 stage 2).
+ *
+ * ONE Claude `.structured<DemoSpec>()` call turns the user's product facts +
+ * brand tokens + product screenshots (as vision) + wizard answers into a valid,
+ * render-ready DemoSpec that the Layer-A engine renders to MP4. This is the
+ * equivalent of the agent Planner (`bibleBuilder`/`planner`) but for the demo
+ * generator: provider-agnostic (injected `LlmCaller`), model-routed, and
+ * hardened by a deterministic normalize pass (see demoAuthorNormalize.ts) that
+ * enforces the invariants a prompt can only request.
+ *
+ * The orchestration worker (Phase 4) calls `authorDemoSpec` at the plan stage;
+ * the returned `spec` is persisted on `demoVideoProjects.demoSpec` and rendered.
+ */
+/** Cap screenshots sent as vision (and thus citable) to bound token cost (plan §10). */
+const MAX_VISION_SCREENSHOTS = 6;
+/**
+ * Author a render-ready DemoSpec from inputs. Pure orchestration: build the
+ * prompt, attach screenshots as vision, call `.structured(DemoSpec)`, then
+ * normalize. Throws if the caller is unconfigured or the model returns an
+ * unparseable / scene-less spec (the normalize pass is the last guard).
+ */
+async function authorDemoSpec(input, deps = {}) {
+    const llm = deps.llm ?? (0, llmCallerRegistry_1.getLlmCaller)();
+    const router = deps.router ?? new modelRouter_1.ModelRouter();
+    const model = router.pickFor("planner", { premium: deps.premium });
+    const fallbackModel = router.fallbackFor("planner");
+    // Cap the screenshot set BEFORE prompting so the citable list matches exactly
+    // what the model can see (never advertise a URL we didn't attach as vision).
+    const visionScreenshots = (input.screenshotUrls ?? []).slice(0, MAX_VISION_SCREENSHOTS);
+    const cappedInput = {
+        ...input,
+        screenshotUrls: visionScreenshots.length ? visionScreenshots : undefined,
+    };
+    const system = (0, demoAuthorPrompt_1.buildDemoAuthorSystemPrompt)({
+        allowCustomScenes: deps.allowCustomScenes,
+        allowGeneratedAssets: deps.allowGeneratedAssets,
+    });
+    const userText = (0, demoAuthorPrompt_1.buildDemoAuthorUserText)(cappedInput);
+    const result = await llm.structured({
+        model,
+        fallbackModel,
+        messages: [
+            { role: "system", content: system },
+            {
+                role: "user",
+                content: userText,
+                imageUrls: visionScreenshots.length ? visionScreenshots : undefined,
+            },
+        ],
+        schema: demoSpec_schema_1.DemoSpecSchema,
+        schemaName: "DemoSpec",
+        temperature: deps.temperature ?? 0.5,
+        maxTokens: deps.maxTokens ?? 8000,
+    });
+    // The caller already validated against DemoSpecSchema; parse again defensively
+    // to get a concrete typed value before the deterministic normalize pass.
+    const raw = demoSpec_schema_1.DemoSpecSchema.parse(result.data);
+    const normalized = (0, demoAuthorNormalize_1.normalizeDemoSpec)(raw, cappedInput);
+    return {
+        ...normalized,
+        modelUsed: result.usedFallback && fallbackModel ? fallbackModel : model,
+        usedFallback: result.usedFallback,
+        usage: result.usage,
+    };
+}

package/lib/services/demo/demoAuthorNormalize.d.ts

@@ -0,0 +1,49 @@
+import { DemoScene, DemoSpec } from "../../schemas/demoSpec.schema";
+import { DemoAuthorInput } from "./demoAuthorPrompt";
+/**
+ * Deterministic post-processing for the authored DemoSpec (plan Phase 3).
+ *
+ * The prompt REQUESTS these invariants; this pass GUARANTEES them, because an
+ * LLM can (and occasionally will) drift on exactly the things that break a
+ * render or the brand:
+ *   1. Wizard pins — any axis the user explicitly locked wins over the model's pick.
+ *   2. Screenshot URLs — the model may only cite real uploaded URLs; anything else
+ *      is stripped (and screenshot-only scenes with no valid URL are dropped).
+ *   3. Brand colors — forced back to the user's tokens (copy is the model's, palette isn't).
+ *   4. Duration budget — total timeline scaled to land inside the target window.
+ *   5. Structural — >=1 scene, correct productName, schema-valid (defaults applied).
+ *
+ * Everything here is pure + typed (no `any`), so it's unit-testable without an LLM.
+ */
+export interface NormalizeResult {
+    spec: DemoSpec;
+    /** Human-readable notes on what the normalize pass changed (for logs/observability). */
+    adjustments: string[];
+}
+/** Hard caps on planner-requested AI media per spec (cost + wall-clock bound). */
+export declare const DEMO_GEN_ASSET_MAX_IMAGES = 4;
+export declare const DEMO_GEN_ASSET_MAX_VIDEOS = 1;
+/** Is this URL-slot value a reference to a declared generated asset? */
+export declare function isGenAssetRef(url: string | undefined): url is string;
+/** `gen://hero-shot` → `hero-shot` (undefined when not a gen ref). */
+export declare function genAssetIdFromRef(url: string): string;
+export interface GenAssetCitations {
+    /** Asset ids cited via `gen://<id>`. */
+    ids: Set<string>;
+    /** Raw string values cited in media slots — lets a READY asset that scenes
+     *  now cite by its resolved URL still count as referenced. */
+    urls: Set<string>;
+}
+/** Every `gen://` ref AND every raw media string cited anywhere in a scene list
+ *  (typed media slots + custom-scene prop bags, walked deeply so codegen props
+ *  count as usage). */
+export declare function collectGenAssetRefs(scenes: DemoScene[]): GenAssetCitations;
+/**
+ * Run the full deterministic normalize pipeline on a raw authored spec and
+ * return a schema-valid, render-ready DemoSpec plus the list of adjustments.
+ * Throws only if the model produced something with zero scenes (unrecoverable).
+ */
+export declare function normalizeDemoSpec(raw: DemoSpec, input: DemoAuthorInput): NormalizeResult;
+/** Convenience — total timeline of a normalized spec (ms). */
+export declare function specTotalMs(spec: DemoSpec): number;
+//# sourceMappingURL=demoAuthorNormalize.d.ts.map

package/lib/services/demo/demoAuthorNormalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"demoAuthorNormalize.d.ts","sourceRoot":"","sources":["../../../src/services/demo/demoAuthorNormalize.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,SAAS,EACT,QAAQ,EAIT,MAAM,+BAA+B,CAAC;AAEvC,OAAO,EAAE,eAAe,EAAmC,MAAM,oBAAoB,CAAC;AAEtF;;;;;;;;;;;;;;GAcG;AAEH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,QAAQ,CAAC;IACf,wFAAwF;IACxF,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB;AA6CD,kFAAkF;AAClF,eAAO,MAAM,yBAAyB,IAAI,CAAC;AAC3C,eAAO,MAAM,yBAAyB,IAAI,CAAC;AAE3C,wEAAwE;AACxE,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,GAAG,IAAI,MAAM,CAEpE;AAED,sEAAsE;AACtE,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAErD;AAED,MAAM,WAAW,iBAAiB;IAChC,wCAAwC;IACxC,GAAG,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACjB;kEAC8D;IAC9D,IAAI,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CACnB;AAED;;uBAEuB;AACvB,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,EAAE,GAAG,iBAAiB,CA2C1E;AA0MD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,QAAQ,EAAE,KAAK,EAAE,eAAe,GAAG,eAAe,CAsExF;AAED,8DAA8D;AAC9D,wBAAgB,WAAW,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,CAElD"}