vidspotai-shared 1.0.55 → 1.0.56

package/lib/schemas/project.schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"project.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/project.schema.ts"],"names":[],"mappings":"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"}

package/lib/schemas/project.schema.js

@@ -1,238 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProjectSchema = exports.ProjectBackgroundSchema = exports.TrackSchema = exports.TrackKindSchema = exports.ClipSchema = exports.CaptionClipSchema = exports.TextClipSchema = exports.AudioClipSchema = exports.ImageClipSchema = exports.VideoClipSchema = exports.CaptionWordSchema = exports.TransitionSchema = exports.EffectSchema = exports.ProvenanceSchema = exports.TierSchema = exports.ColorGradeSchema = exports.TransformSchema = exports.TrimSchema = exports.TimeRangeSchema = exports.AspectSchema = exports.SizeSchema = exports.PROJECT_SCHEMA_VERSION = void 0;
-const zod_1 = require("zod");
-/**
- * Canonical Project JSON schema.
- *
- * This is the persistent, agent-facing representation of a video project.
- * It is the single contract shared by:
- *   - the editor (loads/edits this; runtime adds scale/scroll/selection on top)
- *   - the agent tool layer (produces and patches this via compose_scene etc.)
- *   - the headless renderer (consumes this to produce MP4)
- *
- * What this schema deliberately does NOT include:
- *   - editor runtime state (zoom, scroll, active selection, undo history)
- *   - browser-only handles (Blob, ReadableStream)
- *   - rich-effect details that aren't yet renderable end-to-end
- *
- * Fields evolve forward only. Add new optional fields; never repurpose existing ones.
- * Bump PROJECT_SCHEMA_VERSION on any breaking change.
- */
-exports.PROJECT_SCHEMA_VERSION = 1;
-// ─── primitives ───────────────────────────────────────────────────────────
-exports.SizeSchema = zod_1.z.object({
-    width: zod_1.z.number().int().positive(),
-    height: zod_1.z.number().int().positive(),
-});
-exports.AspectSchema = zod_1.z.enum(["9:16", "1:1", "4:5", "16:9"]);
-exports.TimeRangeSchema = zod_1.z.object({
-    /** Inclusive start, in milliseconds from project t=0. */
-    from: zod_1.z.number().nonnegative(),
-    /** Exclusive end, in milliseconds. Must be > from. */
-    to: zod_1.z.number().positive(),
-});
-exports.TrimSchema = zod_1.z.object({
-    /** Inclusive start within the source asset, in milliseconds. */
-    from: zod_1.z.number().nonnegative(),
-    to: zod_1.z.number().positive(),
-});
-exports.TransformSchema = zod_1.z.object({
-    x: zod_1.z.number().default(0),
-    y: zod_1.z.number().default(0),
-    scaleX: zod_1.z.number().default(1),
-    scaleY: zod_1.z.number().default(1),
-    rotation: zod_1.z.number().default(0),
-    opacity: zod_1.z.number().min(0).max(1).default(1),
-});
-exports.ColorGradeSchema = zod_1.z.object({
-    exposure: zod_1.z.number().min(-100).max(100).default(0),
-    contrast: zod_1.z.number().min(-100).max(100).default(0),
-    saturation: zod_1.z.number().min(-100).max(100).default(0),
-    warmth: zod_1.z.number().min(-100).max(100).default(0),
-});
-// ─── agent provenance ────────────────────────────────────────────────────
-/** Generation tier per the cheap-bulk strategy. */
-exports.TierSchema = zod_1.z.enum(["T0", "T1", "T2", "T3"]);
-/** Provenance attached to every clip whose asset was generated or sourced by the agent. */
-exports.ProvenanceSchema = zod_1.z.object({
-    tier: exports.TierSchema,
-    /** Provider key as registered in aiModels.ts, or "pexels", "user-upload", etc. */
-    source: zod_1.z.string(),
-    modelKey: zod_1.z.string().optional(),
-    prompt: zod_1.z.string().optional(),
-    /** Content-hash of the underlying asset, for cache dedupe. */
-    assetHash: zod_1.z.string().optional(),
-    /** Credits actually spent producing this asset. */
-    creditsSpent: zod_1.z.number().nonnegative().optional(),
-    /** Idempotency key used when calling the provider. */
-    generationId: zod_1.z.string().optional(),
-});
-// ─── effects & transitions ───────────────────────────────────────────────
-exports.EffectSchema = zod_1.z.object({
-    id: zod_1.z.string(),
-    /** e.g. "lut", "vignette", "stabilize", "blur", "chroma". */
-    kind: zod_1.z.string(),
-    enabled: zod_1.z.boolean().default(true),
-    /** Free-form effect-specific params; validated per-effect at the renderer. */
-    params: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).default({}),
-});
-exports.TransitionSchema = zod_1.z.object({
-    id: zod_1.z.string(),
-    fromClipId: zod_1.z.string(),
-    toClipId: zod_1.z.string(),
-    /** Restricted to renderable kinds. */
-    kind: zod_1.z.enum([
-        "none",
-        "fade",
-        "crossfade",
-        "wipe",
-        "slide",
-        "whipPan",
-        "dipToBlack",
-        "dipToWhite",
-    ]),
-    durationMs: zod_1.z.number().positive(),
-});
-// ─── caption sub-shape ───────────────────────────────────────────────────
-exports.CaptionWordSchema = zod_1.z.object({
-    word: zod_1.z.string(),
-    /** ms from clip start. */
-    start: zod_1.z.number().nonnegative(),
-    end: zod_1.z.number().nonnegative(),
-});
-// ─── clips (discriminated union) ─────────────────────────────────────────
-const ClipBase = {
-    id: zod_1.z.string(),
-    trackId: zod_1.z.string(),
-    display: exports.TimeRangeSchema,
-    name: zod_1.z.string().optional(),
-    /** True if this clip carries a generated/sourced asset the agent placed. */
-    provenance: exports.ProvenanceSchema.optional(),
-    effects: zod_1.z.array(exports.EffectSchema).default([]),
-    transform: exports.TransformSchema.default({}),
-    /** Locked clips can't be moved/trimmed by the agent or user. */
-    locked: zod_1.z.boolean().default(false),
-    /** Opaque per-app metadata (UI hints, etc.). Renderer ignores. */
-    metadata: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).default({}),
-};
-exports.VideoClipSchema = zod_1.z.object({
-    ...ClipBase,
-    type: zod_1.z.literal("video"),
-    src: zod_1.z.string().url(),
-    trim: exports.TrimSchema.optional(),
-    volume: zod_1.z.number().min(0).max(2).default(1),
-    playbackRate: zod_1.z.number().positive().default(1),
-    colorGrade: exports.ColorGradeSchema.optional(),
-    /** Optional cropping in source pixels. */
-    crop: zod_1.z
-        .object({
-        x: zod_1.z.number(),
-        y: zod_1.z.number(),
-        width: zod_1.z.number().positive(),
-        height: zod_1.z.number().positive(),
-    })
-        .optional(),
-});
-exports.ImageClipSchema = zod_1.z.object({
-    ...ClipBase,
-    type: zod_1.z.literal("image"),
-    src: zod_1.z.string().url(),
-    /** Ken-Burns / parallax motion hint resolved by renderer for T1 image+motion clips. */
-    motion: zod_1.z
-        .object({
-        kind: zod_1.z.enum(["kenBurnsIn", "kenBurnsOut", "panLeft", "panRight", "parallax"]),
-        intensity: zod_1.z.number().min(0).max(1).default(0.5),
-    })
-        .optional(),
-    colorGrade: exports.ColorGradeSchema.optional(),
-});
-exports.AudioClipSchema = zod_1.z.object({
-    ...ClipBase,
-    type: zod_1.z.literal("audio"),
-    src: zod_1.z.string().url(),
-    trim: exports.TrimSchema.optional(),
-    volume: zod_1.z.number().min(0).max(2).default(1),
-    /** Sidechain-duck this audio against another track id (e.g. music ducked under VO). */
-    duckAgainstTrackId: zod_1.z.string().optional(),
-    fadeInMs: zod_1.z.number().nonnegative().default(0),
-    fadeOutMs: zod_1.z.number().nonnegative().default(0),
-});
-exports.TextClipSchema = zod_1.z.object({
-    ...ClipBase,
-    type: zod_1.z.literal("text"),
-    text: zod_1.z.string(),
-    fontFamily: zod_1.z.string().default("Poppins"),
-    fontSize: zod_1.z.number().positive().default(48),
-    fontWeight: zod_1.z.number().int().min(100).max(900).default(700),
-    color: zod_1.z.string().default("#ffffff"),
-    align: zod_1.z.enum(["left", "center", "right"]).default("center"),
-    backgroundColor: zod_1.z.string().optional(),
-    shadow: zod_1.z.string().optional(),
-});
-exports.CaptionClipSchema = zod_1.z.object({
-    ...ClipBase,
-    type: zod_1.z.literal("caption"),
-    text: zod_1.z.string(),
-    words: zod_1.z.array(exports.CaptionWordSchema).default([]),
-    fontFamily: zod_1.z.string().default("Poppins"),
-    fontSize: zod_1.z.number().positive().default(48),
-    color: zod_1.z.string().default("#ffffff"),
-    highlightColor: zod_1.z.string().optional(),
-    language: zod_1.z.string().default("en"),
-});
-exports.ClipSchema = zod_1.z.discriminatedUnion("type", [
-    exports.VideoClipSchema,
-    exports.ImageClipSchema,
-    exports.AudioClipSchema,
-    exports.TextClipSchema,
-    exports.CaptionClipSchema,
-]);
-// ─── tracks & project ────────────────────────────────────────────────────
-exports.TrackKindSchema = zod_1.z.enum([
-    "video",
-    "audio",
-    "text",
-    "caption",
-    "fx",
-]);
-exports.TrackSchema = zod_1.z.object({
-    id: zod_1.z.string(),
-    kind: exports.TrackKindSchema,
-    name: zod_1.z.string().optional(),
-    /** Track stacking order; lower = behind. */
-    index: zod_1.z.number().int().nonnegative(),
-    muted: zod_1.z.boolean().default(false),
-    hidden: zod_1.z.boolean().default(false),
-    locked: zod_1.z.boolean().default(false),
-    /** Track-level gain for audio tracks, in dB. Ignored on visual tracks. */
-    gainDb: zod_1.z.number().default(0),
-});
-exports.ProjectBackgroundSchema = zod_1.z.discriminatedUnion("type", [
-    zod_1.z.object({ type: zod_1.z.literal("color"), value: zod_1.z.string() }),
-    zod_1.z.object({ type: zod_1.z.literal("image"), src: zod_1.z.string().url() }),
-    zod_1.z.object({ type: zod_1.z.literal("transparent") }),
-]);
-exports.ProjectSchema = zod_1.z.object({
-    schemaVersion: zod_1.z.literal(exports.PROJECT_SCHEMA_VERSION),
-    id: zod_1.z.string(),
-    name: zod_1.z.string(),
-    /** Total project duration in ms. Renderer uses this; agent edits keep it in sync. */
-    durationMs: zod_1.z.number().positive(),
-    fps: zod_1.z.number().int().positive().default(30),
-    size: exports.SizeSchema,
-    aspect: exports.AspectSchema,
-    background: exports.ProjectBackgroundSchema.default({
-        type: "color",
-        value: "#000000",
-    }),
-    tracks: zod_1.z.array(exports.TrackSchema),
-    clips: zod_1.z.array(exports.ClipSchema),
-    transitions: zod_1.z.array(exports.TransitionSchema).default([]),
-    /** Top-level provenance: which agent run produced this project, if any. */
-    agentRunId: zod_1.z.string().optional(),
-    /** Free-form per-app metadata. Renderer ignores. */
-    metadata: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).default({}),
-    createdAt: zod_1.z.string().datetime(),
-    updatedAt: zod_1.z.string().datetime(),
-});

package/lib/schemas/videoPlan.schema.d.ts

@@ -1,145 +0,0 @@
-import { z } from "zod";
-/**
- * VideoPlan — the planner LLM's structured output. Reviewed by the user as a
- * storyboard BEFORE any generation spend. Once approved, the executor walks
- * the scenes in order and runs the prescribed tools per scene.
- *
- * Validated against this Zod schema; if validation fails, the planner is
- * retried up to N=2 with the validation errors fed back as correction context.
- */
-export declare const SceneAssetStrategySchema: z.ZodEnum<{
-    "stock-video": "stock-video";
-    "stock-image-ken-burns": "stock-image-ken-burns";
-    "ai-image-static": "ai-image-static";
-    "ai-image-motion": "ai-image-motion";
-    "ai-image-to-video": "ai-image-to-video";
-    "ai-text-to-video": "ai-text-to-video";
-    "user-asset": "user-asset";
-    "talking-head-avatar": "talking-head-avatar";
-}>;
-export declare const TransitionKindSchema: z.ZodEnum<{
-    none: "none";
-    fade: "fade";
-    crossfade: "crossfade";
-    wipe: "wipe";
-    whipPan: "whipPan";
-    dipToBlack: "dipToBlack";
-    dipToWhite: "dipToWhite";
-    cut: "cut";
-}>;
-export declare const PlannedSceneSchema: z.ZodObject<{
-    sceneIndex: z.ZodNumber;
-    intent: z.ZodString;
-    strategy: z.ZodEnum<{
-        "stock-video": "stock-video";
-        "stock-image-ken-burns": "stock-image-ken-burns";
-        "ai-image-static": "ai-image-static";
-        "ai-image-motion": "ai-image-motion";
-        "ai-image-to-video": "ai-image-to-video";
-        "ai-text-to-video": "ai-text-to-video";
-        "user-asset": "user-asset";
-        "talking-head-avatar": "talking-head-avatar";
-    }>;
-    tier: z.ZodEnum<{
-        T0: "T0";
-        T1: "T1";
-        T2: "T2";
-        T3: "T3";
-    }>;
-    preferredProvider: z.ZodOptional<z.ZodString>;
-    preferredModel: z.ZodOptional<z.ZodString>;
-    prompt: z.ZodString;
-    durationMs: z.ZodNumber;
-    voiceoverLine: z.ZodOptional<z.ZodString>;
-    onScreenText: z.ZodOptional<z.ZodString>;
-    transitionIn: z.ZodDefault<z.ZodEnum<{
-        none: "none";
-        fade: "fade";
-        crossfade: "crossfade";
-        wipe: "wipe";
-        whipPan: "whipPan";
-        dipToBlack: "dipToBlack";
-        dipToWhite: "dipToWhite";
-        cut: "cut";
-    }>>;
-    estimatedCredits: z.ZodNumber;
-    avatarFaceUrl: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export declare const VideoPlanSchema: z.ZodObject<{
-    briefId: z.ZodOptional<z.ZodString>;
-    persona: z.ZodEnum<{
-        "ugc-ad": "ugc-ad";
-        "faceless-yt": "faceless-yt";
-        "product-demo": "product-demo";
-        "talking-head": "talking-head";
-        "social-recap": "social-recap";
-    }>;
-    aspect: z.ZodEnum<{
-        "9:16": "9:16";
-        "16:9": "16:9";
-        "1:1": "1:1";
-        "4:5": "4:5";
-    }>;
-    totalDurationMs: z.ZodNumber;
-    totalEstimatedCredits: z.ZodNumber;
-    scenes: z.ZodArray<z.ZodObject<{
-        sceneIndex: z.ZodNumber;
-        intent: z.ZodString;
-        strategy: z.ZodEnum<{
-            "stock-video": "stock-video";
-            "stock-image-ken-burns": "stock-image-ken-burns";
-            "ai-image-static": "ai-image-static";
-            "ai-image-motion": "ai-image-motion";
-            "ai-image-to-video": "ai-image-to-video";
-            "ai-text-to-video": "ai-text-to-video";
-            "user-asset": "user-asset";
-            "talking-head-avatar": "talking-head-avatar";
-        }>;
-        tier: z.ZodEnum<{
-            T0: "T0";
-            T1: "T1";
-            T2: "T2";
-            T3: "T3";
-        }>;
-        preferredProvider: z.ZodOptional<z.ZodString>;
-        preferredModel: z.ZodOptional<z.ZodString>;
-        prompt: z.ZodString;
-        durationMs: z.ZodNumber;
-        voiceoverLine: z.ZodOptional<z.ZodString>;
-        onScreenText: z.ZodOptional<z.ZodString>;
-        transitionIn: z.ZodDefault<z.ZodEnum<{
-            none: "none";
-            fade: "fade";
-            crossfade: "crossfade";
-            wipe: "wipe";
-            whipPan: "whipPan";
-            dipToBlack: "dipToBlack";
-            dipToWhite: "dipToWhite";
-            cut: "cut";
-        }>>;
-        estimatedCredits: z.ZodNumber;
-        avatarFaceUrl: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-    music: z.ZodOptional<z.ZodObject<{
-        strategy: z.ZodEnum<{
-            none: "none";
-            "stock-track": "stock-track";
-            generated: "generated";
-        }>;
-        query: z.ZodOptional<z.ZodString>;
-        moodTag: z.ZodOptional<z.ZodString>;
-        bpm: z.ZodOptional<z.ZodNumber>;
-        url: z.ZodOptional<z.ZodString>;
-        durationSec: z.ZodOptional<z.ZodNumber>;
-        source: z.ZodOptional<z.ZodString>;
-        attribution: z.ZodOptional<z.ZodString>;
-        onsets: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
-    }, z.core.$strip>>;
-    voiceId: z.ZodOptional<z.ZodString>;
-    notes: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export type VideoPlan = z.infer<typeof VideoPlanSchema>;
-export type PlannedScene = z.infer<typeof PlannedSceneSchema>;
-export type SceneAssetStrategy = z.infer<typeof SceneAssetStrategySchema>;
-export type TransitionKind = z.infer<typeof TransitionKindSchema>;
-//# sourceMappingURL=videoPlan.schema.d.ts.map

package/lib/schemas/videoPlan.schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"videoPlan.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/videoPlan.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB;;;;;;;GAOG;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;EASnC,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;EAS/B,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0B7B,CAAC;AAEH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoD1B,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AACxD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/lib/schemas/videoPlan.schema.js

@@ -1,109 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VideoPlanSchema = exports.PlannedSceneSchema = exports.TransitionKindSchema = exports.SceneAssetStrategySchema = void 0;
-const zod_1 = require("zod");
-const agentPersona_schema_1 = require("./agentPersona.schema");
-const project_schema_1 = require("./project.schema");
-/**
- * VideoPlan — the planner LLM's structured output. Reviewed by the user as a
- * storyboard BEFORE any generation spend. Once approved, the executor walks
- * the scenes in order and runs the prescribed tools per scene.
- *
- * Validated against this Zod schema; if validation fails, the planner is
- * retried up to N=2 with the validation errors fed back as correction context.
- */
-exports.SceneAssetStrategySchema = zod_1.z.enum([
-    "stock-video",
-    "stock-image-ken-burns",
-    "ai-image-static",
-    "ai-image-motion",
-    "ai-image-to-video",
-    "ai-text-to-video",
-    "user-asset",
-    "talking-head-avatar",
-]);
-exports.TransitionKindSchema = zod_1.z.enum([
-    "none",
-    "cut",
-    "fade",
-    "crossfade",
-    "wipe",
-    "whipPan",
-    "dipToBlack",
-    "dipToWhite",
-]);
-exports.PlannedSceneSchema = zod_1.z.object({
-    sceneIndex: zod_1.z.number().int().nonnegative(),
-    /** Plain-English description of what this scene shows. */
-    intent: zod_1.z.string(),
-    /** Asset acquisition strategy for this scene. */
-    strategy: exports.SceneAssetStrategySchema,
-    /** Tier the planner picked for this scene; usually <= brief.tierBudget. */
-    tier: project_schema_1.TierSchema,
-    /** Provider key the planner suggests; executor may swap on rate-limit. */
-    preferredProvider: zod_1.z.string().optional(),
-    /** Suggested model key, if applicable. */
-    preferredModel: zod_1.z.string().optional(),
-    /** Visual prompt (for AI generation strategies) or stock query terms. */
-    prompt: zod_1.z.string(),
-    durationMs: zod_1.z.number().positive(),
-    voiceoverLine: zod_1.z.string().optional(),
-    onScreenText: zod_1.z.string().optional(),
-    transitionIn: exports.TransitionKindSchema.default("cut"),
-    /** Up-front estimated credit cost for this scene. */
-    estimatedCredits: zod_1.z.number().nonnegative(),
-    /**
-     * Required only when strategy = "talking-head-avatar". URL of the presenter
-     * face still the avatar pipeline animates. Planner sources from
-     * brandKit.presenterFaceUrl; if absent, planner must NOT pick this strategy.
-     */
-    avatarFaceUrl: zod_1.z.string().url().optional(),
-});
-exports.VideoPlanSchema = zod_1.z.object({
-    briefId: zod_1.z.string().optional(),
-    /** Persona the router selected (UGC ad / faceless YT / etc.). */
-    persona: agentPersona_schema_1.AgentPersonaSchema,
-    aspect: project_schema_1.AspectSchema,
-    totalDurationMs: zod_1.z.number().positive(),
-    totalEstimatedCredits: zod_1.z.number().nonnegative(),
-    /** Scene list, in render order. */
-    scenes: zod_1.z.array(exports.PlannedSceneSchema).min(1),
-    /** Music recommendation for the whole video. */
-    music: zod_1.z
-        .object({
-        strategy: zod_1.z.enum(["stock-track", "generated", "none"]),
-        query: zod_1.z.string().optional(),
-        moodTag: zod_1.z.string().optional(),
-        /**
-         * Beats-per-minute of the chosen / target track. Drives the beat-snap
-         * pass so scene cuts land on bar boundaries. Optional: when absent the
-         * snap pass falls back to a persona default (or no-ops for cinematic
-         * personas where free-form pacing reads better).
-         */
-        bpm: zod_1.z.number().int().positive().optional(),
-        /**
-         * URL of the chosen music track. Set by the post-planner music selection
-         * step (selectMusicForPlan) when strategy = "stock-track" / "generated"
-         * and a provider returns a hit.
-         */
-        url: zod_1.z.string().url().optional(),
-        /** Track length in seconds, when known. */
-        durationSec: zod_1.z.number().positive().optional(),
-        /** Source label for attribution / debugging ("curated", "jamendo", "mubert"). */
-        source: zod_1.z.string().optional(),
-        /** Best-effort attribution text; surface in UI when present. */
-        attribution: zod_1.z.string().optional(),
-        /**
-         * Onset timestamps (seconds) from essentia.js RhythmExtractor2013.
-         * When present, the snap pass aligns scene cuts to the nearest onset
-         * instead of the uniform BPM grid — cuts land on actual transients
-         * (kicks / snares / vocal entries) rather than mathematical bars.
-         */
-        onsets: zod_1.z.array(zod_1.z.number().nonnegative()).optional(),
-    })
-        .optional(),
-    /** Voice id to use across all VO scenes. */
-    voiceId: zod_1.z.string().optional(),
-    /** Free-form planner notes — e.g. why a particular tier mix was chosen. */
-    notes: zod_1.z.string().optional(),
-});

package/lib/services/agent/beatSnap.d.ts

@@ -1,10 +0,0 @@
-import { VideoPlan } from "../../schemas/videoPlan.schema";
-export interface SnapOptions {
-    /** Used only when neither plan.music.bpm nor the persona default exists. */
-    fallbackBpm?: number;
-    /** Override beats-per-bar (default 4 — cut on whole bars, not individual beats). */
-    beatsPerBar?: number;
-}
-export declare function resolveBpm(plan: VideoPlan, opts?: SnapOptions): number | undefined;
-export declare function snapPlanToBeats(plan: VideoPlan, opts?: SnapOptions): VideoPlan;
-//# sourceMappingURL=beatSnap.d.ts.map

package/lib/services/agent/beatSnap.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"beatSnap.d.ts","sourceRoot":"","sources":["../../../src/services/agent/beatSnap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,SAAS,EAAE,MAAM,gCAAgC,CAAC;AA+BzE,MAAM,WAAW,WAAW;IAC1B,4EAA4E;IAC5E,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,oFAAoF;IACpF,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,GAAE,WAAgB,GAAG,MAAM,GAAG,SAAS,CAKtF;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,GAAE,WAAgB,GAAG,SAAS,CAMlF"}

package/lib/services/agent/beatSnap.js

@@ -1,128 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveBpm = resolveBpm;
-exports.snapPlanToBeats = snapPlanToBeats;
-const personas_1 = require("./personas");
-/**
- * Beat-snap pass — adjusts each scene's durationMs so cuts land on bar
- * boundaries of the chosen music. Cuts that land on bars feel produced;
- * arbitrary durations feel like a slideshow with music laid over the top.
- *
- * Two modes, picked automatically:
- *
- *   1. ONSET MODE (preferred). When plan.music.onsets is populated by
- *      detectOnsets() (essentia.js), each scene's cumulative end time snaps
- *      to the nearest detected onset — cuts land on actual transients
- *      (kicks / snares / vocal entries), not a uniform grid. This is what
- *      a human editor does.
- *
- *   2. BPM MODE (fallback). When no onsets are available we fall back to
- *      uniform bar math at the resolved BPM:
- *        - plan.music.bpm  → PERSONA_PACKS[plan.persona].defaultBpm
- *          → opts.fallbackBpm → no-op
- *      Each scene rounds to the nearest barMs (4 beats by default).
- *
- * Both modes:
- *   - never go below 1 bar of duration
- *   - never go shorter than the voiceover line needs (~3 wps), rounded up
- *   - recompute plan.totalDurationMs from the snapped sum
- */
-const BEATS_PER_BAR = 4;
-const ESTIMATED_WORDS_PER_SECOND = 3;
-function resolveBpm(plan, opts = {}) {
-    if (plan.music?.bpm)
-        return plan.music.bpm;
-    const personaDefault = personas_1.PERSONA_PACKS[plan.persona]?.defaultBpm;
-    if (personaDefault)
-        return personaDefault;
-    return opts.fallbackBpm;
-}
-function snapPlanToBeats(plan, opts = {}) {
-    const onsets = plan.music?.onsets;
-    if (onsets && onsets.length >= plan.scenes.length) {
-        return snapToOnsets(plan, onsets);
-    }
-    return snapToBpmGrid(plan, opts);
-}
-function snapToOnsets(plan, onsets) {
-    // Build cumulative target end-times then snap each to the nearest onset.
-    // Scenes flow sequentially, so the second scene's start = first scene's end.
-    const sortedOnsets = [...onsets].sort((a, b) => a - b);
-    const snappedScenes = [];
-    let cumulativeMs = 0;
-    for (const scene of plan.scenes) {
-        const minDurMs = sceneMinMs(scene);
-        const targetEndMs = cumulativeMs + Math.max(scene.durationMs, minDurMs);
-        const snappedEndMs = Math.max(cumulativeMs + minDurMs, nearestOnsetMs(targetEndMs, sortedOnsets, cumulativeMs + minDurMs));
-        const newDurationMs = snappedEndMs - cumulativeMs;
-        snappedScenes.push(newDurationMs === scene.durationMs ? scene : { ...scene, durationMs: newDurationMs });
-        cumulativeMs = snappedEndMs;
-    }
-    return {
-        ...plan,
-        scenes: snappedScenes,
-        totalDurationMs: cumulativeMs,
-    };
-}
-function snapToBpmGrid(plan, opts) {
-    const bpm = resolveBpm(plan, opts);
-    if (!bpm)
-        return plan;
-    const beatsPerBar = opts.beatsPerBar ?? BEATS_PER_BAR;
-    const barMs = (60000 / bpm) * beatsPerBar;
-    const snappedScenes = plan.scenes.map((scene) => snapScene(scene, barMs));
-    const totalDurationMs = snappedScenes.reduce((sum, s) => sum + s.durationMs, 0);
-    return {
-        ...plan,
-        music: {
-            strategy: plan.music?.strategy ?? "stock-track",
-            ...plan.music,
-            bpm,
-        },
-        scenes: snappedScenes,
-        totalDurationMs,
-    };
-}
-function snapScene(scene, barMs) {
-    const minMs = Math.max(barMs, ceilToBar(sceneMinMs(scene), barMs));
-    const snapped = Math.max(minMs, roundToBar(scene.durationMs, barMs));
-    return snapped === scene.durationMs ? scene : { ...scene, durationMs: snapped };
-}
-function sceneMinMs(scene) {
-    return scene.voiceoverLine ? estimateVoMs(scene.voiceoverLine) : 0;
-}
-function nearestOnsetMs(targetMs, onsetsSec, minMs) {
-    // Binary search would be faster but onsets list is short (1 per beat for a
-    // 3-min track at 120bpm = ~360 entries) and snap runs once per plan.
-    let bestMs = targetMs;
-    let bestDiff = Infinity;
-    for (const sec of onsetsSec) {
-        const ms = sec * 1000;
-        if (ms < minMs)
-            continue;
-        const diff = Math.abs(ms - targetMs);
-        if (diff < bestDiff) {
-            bestDiff = diff;
-            bestMs = ms;
-        }
-        else if (ms > targetMs && diff > bestDiff) {
-            // Past the target — onsets are sorted, so no closer match ahead.
-            break;
-        }
-    }
-    return bestMs;
-}
-function roundToBar(ms, barMs) {
-    return Math.max(barMs, Math.round(ms / barMs) * barMs);
-}
-function ceilToBar(ms, barMs) {
-    if (ms <= 0)
-        return 0;
-    return Math.ceil(ms / barMs) * barMs;
-}
-function estimateVoMs(line) {
-    const words = line.trim().split(/\s+/).filter(Boolean).length;
-    if (words === 0)
-        return 0;
-    return Math.ceil((words / ESTIMATED_WORDS_PER_SECOND) * 1000);
-}

package/lib/services/agent/costPreflight.d.ts

@@ -1,22 +0,0 @@
-import { Project, Tier } from "../../schemas/project.schema";
-import { VideoPlan } from "../../schemas/videoPlan.schema";
-export interface CostBreakdown {
-    totalCredits: number;
-    byTier: Record<Tier, number>;
-    perClip: Array<{
-        clipId: string;
-        tier?: Tier;
-        credits: number;
-        estimated: boolean;
-    }>;
-}
-export declare function estimateProjectCost(project: Project): CostBreakdown;
-/**
- * Plan-side estimate (pre-execution). The planner already writes
- * `estimatedCredits` per scene + a `totalEstimatedCredits` rollup, so this
- * mostly trusts those values and re-aggregates by tier for the UI chip.
- * Falls back to the same per-second tier curve as `estimateProjectCost`
- * when a scene omits its own estimate.
- */
-export declare function estimatePlanCost(plan: VideoPlan): CostBreakdown;
-//# sourceMappingURL=costPreflight.d.ts.map

package/lib/services/agent/costPreflight.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"costPreflight.d.ts","sourceRoot":"","sources":["../../../src/services/agent/costPreflight.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,OAAO,EAAE,IAAI,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,EAAE,SAAS,EAAE,MAAM,gCAAgC,CAAC;AAqB3D,MAAM,WAAW,aAAa;IAC5B,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;IAC7B,OAAO,EAAE,KAAK,CAAC;QACb,MAAM,EAAE,MAAM,CAAC;QACf,IAAI,CAAC,EAAE,IAAI,CAAC;QACZ,OAAO,EAAE,MAAM,CAAC;QAChB,SAAS,EAAE,OAAO,CAAC;KACpB,CAAC,CAAC;CACJ;AAKD,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG,aAAa,CAuBnE;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,SAAS,GAAG,aAAa,CAuB/D"}