vidspotai-shared 1.0.82 → 1.0.83

package/lib/services/agent/editExisting/editAssembler.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MIN_SEGMENT_MS = void 0;
+exports.totalSegmentMs = totalSegmentMs;
+exports.clampSegments = clampSegments;
+exports.remapCaptionWords = remapCaptionWords;
+exports.buildEditProject = buildEditProject;
+const project_schema_1 = require("../../../schemas/project.schema");
+/**
+ * Stream L · L-5 — pure assembly helpers for the edit-existing pipeline.
+ *
+ * Everything here is deterministic + IO-free so it can be unit/eval-tested
+ * without spend: segment clamping/ordering, caption-word remapping onto the
+ * cut timeline, and building the editable Project JSON (a single video track
+ * of source-trim clips, the same primitive the extend-chain layout uses).
+ */
+/** Drop kept spans shorter than this (sub-half-second slivers aren't usable cuts). */
+exports.MIN_SEGMENT_MS = 400;
+/** Total kept duration across segments, ms. */
+function totalSegmentMs(segments) {
+    return segments.reduce((sum, s) => sum + Math.max(0, s.endMs - s.startMs), 0);
+}
+/**
+ * Clamp segments into [0, sourceDurationMs], sort chronologically, remove
+ * overlaps (a later segment that starts before the previous one ended is
+ * pushed forward; if that collapses it, it's dropped), and drop slivers below
+ * MIN_SEGMENT_MS. Idempotent — safe to run on already-clean input.
+ */
+function clampSegments(segments, sourceDurationMs) {
+    const bounded = segments
+        .map((s) => {
+        const startMs = Math.max(0, Math.min(s.startMs, sourceDurationMs));
+        const endMs = Math.max(0, Math.min(s.endMs, sourceDurationMs));
+        return { ...s, startMs, endMs };
+    })
+        .filter((s) => s.endMs - s.startMs >= exports.MIN_SEGMENT_MS)
+        .sort((a, b) => a.startMs - b.startMs);
+    const out = [];
+    let prevEnd = 0;
+    for (const s of bounded) {
+        const start = Math.max(s.startMs, prevEnd);
+        if (s.endMs - start < exports.MIN_SEGMENT_MS)
+            continue; // collapsed by overlap removal
+        out.push({ ...s, startMs: start, endMs: s.endMs });
+        prevEnd = s.endMs;
+    }
+    return out;
+}
+/**
+ * Remap word timings from the SOURCE timeline onto the concatenated cut
+ * timeline (0-based at the start of the first kept segment). Only words that
+ * fall inside a kept segment survive; each is clamped to its segment and
+ * shifted by the cumulative offset of that segment in the output.
+ */
+function remapCaptionWords(words, segments) {
+    const out = [];
+    let cumulative = 0;
+    for (const seg of segments) {
+        const segLen = seg.endMs - seg.startMs;
+        for (const w of words) {
+            // Keep words that overlap the segment at all; clamp to segment bounds.
+            if (w.end <= seg.startMs || w.start >= seg.endMs)
+                continue;
+            const start = Math.max(w.start, seg.startMs) - seg.startMs + cumulative;
+            const end = Math.min(w.end, seg.endMs) - seg.startMs + cumulative;
+            if (end <= start)
+                continue;
+            out.push({ word: w.text, start, end });
+        }
+        cumulative += segLen;
+    }
+    return out.sort((a, b) => a.start - b.start);
+}
+const VIDEO_TRACK_ID = "track-video";
+const CAPTION_TRACK_ID = "track-caption";
+/**
+ * Build an editable Project JSON for the re-edit. The highlight clips reference
+ * the ORIGINAL source URL with trims (lossless — the user can re-extend a cut
+ * in the editor), intro/outro reference their own URLs, and captions (if any)
+ * land on a dedicated track over the highlight region. Validated against
+ * ProjectSchema before returning, so the editor + renderer accept it as-is.
+ */
+function buildEditProject(args) {
+    const fps = args.fps ?? 30;
+    const clips = [];
+    let cursor = 0;
+    if (args.intro && args.intro.durationMs > 0) {
+        clips.push({
+            id: "intro",
+            trackId: VIDEO_TRACK_ID,
+            type: "video",
+            src: args.intro.url,
+            display: { from: 0, to: args.intro.durationMs },
+            name: "Intro",
+            provenance: { tier: "T0", source: "user-upload" },
+            metadata: { editRole: "intro" },
+        });
+        cursor = args.intro.durationMs;
+    }
+    const highlightStart = cursor;
+    args.segments.forEach((seg, i) => {
+        const dur = seg.endMs - seg.startMs;
+        clips.push({
+            id: `clip-${i}`,
+            trackId: VIDEO_TRACK_ID,
+            type: "video",
+            src: args.sourceVideoUrl,
+            trim: { from: seg.startMs, to: seg.endMs },
+            display: { from: cursor, to: cursor + dur },
+            name: seg.label ?? `Highlight ${i + 1}`,
+            provenance: { tier: "T0", source: "edit-existing" },
+            metadata: {
+                editSegmentIndex: i,
+                sourceStartMs: seg.startMs,
+                sourceEndMs: seg.endMs,
+                reason: seg.reason,
+            },
+        });
+        cursor += dur;
+    });
+    const highlightEnd = cursor;
+    if (args.outro && args.outro.durationMs > 0) {
+        clips.push({
+            id: "outro",
+            trackId: VIDEO_TRACK_ID,
+            type: "video",
+            src: args.outro.url,
+            display: { from: cursor, to: cursor + args.outro.durationMs },
+            name: "Outro",
+            provenance: { tier: "T0", source: "user-upload" },
+            metadata: { editRole: "outro" },
+        });
+        cursor += args.outro.durationMs;
+    }
+    const tracks = [
+        { id: VIDEO_TRACK_ID, kind: "video", name: "Video", index: 0 },
+    ];
+    if (args.captionWords && args.captionWords.length > 0 && highlightEnd > highlightStart) {
+        tracks.push({
+            id: CAPTION_TRACK_ID,
+            kind: "caption",
+            name: "Captions",
+            index: 1,
+        });
+        clips.push({
+            id: "captions",
+            trackId: CAPTION_TRACK_ID,
+            type: "caption",
+            display: { from: highlightStart, to: highlightEnd },
+            text: args.captionWords.map((w) => w.word).join(" "),
+            words: args.captionWords,
+            language: args.captionLanguage ?? "en",
+        });
+    }
+    const totalMs = Math.max(cursor, 1);
+    const raw = {
+        schemaVersion: project_schema_1.PROJECT_SCHEMA_VERSION,
+        id: args.projectId,
+        name: args.name,
+        durationMs: totalMs,
+        fps,
+        size: { width: args.size.width, height: args.size.height },
+        aspect: args.aspect,
+        tracks,
+        clips,
+        agentRunId: args.agentRunId,
+        metadata: { producedBy: "edit-existing" },
+        createdAt: args.now,
+        updatedAt: args.now,
+    };
+    return project_schema_1.ProjectSchema.parse(raw);
+}

package/lib/services/agent/editExisting/editExisting.schema.d.ts

@@ -0,0 +1,119 @@
+import { z } from "zod";
+/**
+ * Stream L · L-5 — "edit-existing" pipeline schemas.
+ *
+ * This pipeline is DELIBERATELY separate from the planner: there is no brief,
+ * no persona, no VideoPlan. The user hands us a finished source video; we run
+ * ASR, let an LLM pick the highlight segments, ffmpeg-cut them, and reassemble
+ * a tighter cut (podcast clipping, vlog re-edit, interview highlights).
+ *
+ * Two artifacts come out the far end:
+ *   1. a stitched MP4 (the deliverable — fast, no Remotion render needed), and
+ *   2. an editable Project JSON (source-trim video clips) so the user can
+ *      keep editing + re-render in the in-frontend editor.
+ *
+ * Like the rest of the agent surface, the PURE logic (segment math, caption
+ * remap, project assembly, highlight validation) lives in `shared` so it is
+ * testable + eval-able; the IO-heavy stages (download, ASR poll, ffmpeg,
+ * upload) live in the node-express worker where ffmpeg + the stitcher already
+ * are.
+ */
+/**
+ * What the user wants out of the re-edit. Each goal nudges the highlight
+ * picker's prompt (see highlightPicker.ts) toward a different selection bias:
+ *   - highlights           : the single best moments, agnostic of format
+ *   - podcast-clips        : self-contained quotable segments (social clips)
+ *   - vlog-reedit          : keep narrative flow, cut dead air / filler
+ *   - interview-highlights : strongest Q→A exchanges, speaker-aware
+ */
+export declare const EditGoalSchema: z.ZodEnum<{
+    highlights: "highlights";
+    "podcast-clips": "podcast-clips";
+    "vlog-reedit": "vlog-reedit";
+    "interview-highlights": "interview-highlights";
+}>;
+export type EditGoal = z.infer<typeof EditGoalSchema>;
+export declare const EditExistingRequestSchema: z.ZodObject<{
+    sourceVideoUrl: z.ZodString;
+    sourceDurationSec: z.ZodNumber;
+    editGoal: z.ZodEnum<{
+        highlights: "highlights";
+        "podcast-clips": "podcast-clips";
+        "vlog-reedit": "vlog-reedit";
+        "interview-highlights": "interview-highlights";
+    }>;
+    targetDurationSec: z.ZodOptional<z.ZodNumber>;
+    maxClips: z.ZodOptional<z.ZodNumber>;
+    language: z.ZodOptional<z.ZodString>;
+    addCaptions: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    aspect: z.ZodOptional<z.ZodEnum<{
+        "9:16": "9:16";
+        "1:1": "1:1";
+        "4:5": "4:5";
+        "16:9": "16:9";
+    }>>;
+    introUrl: z.ZodOptional<z.ZodString>;
+    outroUrl: z.ZodOptional<z.ZodString>;
+    instructions: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type EditExistingRequest = z.infer<typeof EditExistingRequestSchema>;
+export declare const HighlightSegmentSchema: z.ZodObject<{
+    startMs: z.ZodNumber;
+    endMs: z.ZodNumber;
+    reason: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type HighlightSegment = z.infer<typeof HighlightSegmentSchema>;
+export declare const HighlightSelectionSchema: z.ZodObject<{
+    segments: z.ZodArray<z.ZodObject<{
+        startMs: z.ZodNumber;
+        endMs: z.ZodNumber;
+        reason: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    summary: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type HighlightSelection = z.infer<typeof HighlightSelectionSchema>;
+/**
+ * Tiny job envelope — same design rule as AgentRunJobPayload: the full request
+ * lives on `agentProjects/{projectId}` (the controller stows it under
+ * `editRequest`), the worker reads it from Firestore at job start. Keeps the
+ * Redis stream light.
+ */
+export declare const EditJobPayloadSchema: z.ZodObject<{
+    runId: z.ZodString;
+    projectId: z.ZodString;
+    userId: z.ZodString;
+    enqueuedAt: z.ZodNumber;
+}, z.core.$strict>;
+export type EditJobPayload = z.infer<typeof EditJobPayloadSchema>;
+/**
+ * Flat USD overheads for an edit job, beyond the per-second ASR cost:
+ *   - the highlight-picker LLM call (one structured Sonnet call over a
+ *     transcript — a few cents), and
+ *   - our ffmpeg compute (cut + normalize + concat — our own metal, but we
+ *     price a token amount so the op isn't free).
+ * Kept here (not in aiModels) because edit-existing isn't a generation model.
+ */
+export declare const EDIT_PICKER_LLM_USD = 0.04;
+export declare const EDIT_COMPUTE_USD = 0.06;
+/**
+ * Speaker diarization is only worth its surcharge when the picker is
+ * speaker-aware. Interview / podcast goals benefit; plain highlights / vlog
+ * don't. Centralized so the controller (estimate), the picker (prompt), and
+ * the worker (ASR submit) all agree on a single rule.
+ */
+export declare function editGoalUsesDiarization(goal: EditGoal): boolean;
+/**
+ * Pure upfront credit estimate for an edit job. Used by the controller to
+ * deduct before enqueue and by the worker to reconcile (passing the real
+ * ASR-reported duration). 1 credit = $0.10 (see costPreflight.CREDIT_USD_RATE);
+ * `getCreditsFromCost` applies the per-paid-op floor + canonical rounding.
+ */
+export declare function estimateEditCredits(args: {
+    sourceDurationSec: number;
+    goal: EditGoal;
+    addCaptions?: boolean;
+}): number;
+//# sourceMappingURL=editExisting.schema.d.ts.map

package/lib/services/agent/editExisting/editExisting.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"editExisting.schema.d.ts","sourceRoot":"","sources":["../../../../src/services/agent/editExisting/editExisting.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB;;;;;;;;;;;;;;;;;;GAkBG;AAIH;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc;;;;;EAKzB,CAAC;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAItD,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;kBAkC3B,CAAC;AACZ,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAI5E,eAAO,MAAM,sBAAsB;;;;;kBAe/B,CAAC;AACL,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE,eAAO,MAAM,wBAAwB;;;;;;;;kBAM1B,CAAC;AACZ,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAI1E;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB;;;;;kBAOtB,CAAC;AACZ,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAIlE;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,OAAO,CAAC;AACxC,eAAO,MAAM,gBAAgB,OAAO,CAAC;AAMrC;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAE/D;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE;IACxC,iBAAiB,EAAE,MAAM,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,GAAG,MAAM,CAUT"}

package/lib/services/agent/editExisting/editExisting.schema.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EDIT_COMPUTE_USD = exports.EDIT_PICKER_LLM_USD = exports.EditJobPayloadSchema = exports.HighlightSelectionSchema = exports.HighlightSegmentSchema = exports.EditExistingRequestSchema = exports.EditGoalSchema = void 0;
+exports.editGoalUsesDiarization = editGoalUsesDiarization;
+exports.estimateEditCredits = estimateEditCredits;
+const zod_1 = require("zod");
+const project_schema_1 = require("../../../schemas/project.schema");
+const helpers_1 = require("../../../utils/helpers");
+/**
+ * Stream L · L-5 — "edit-existing" pipeline schemas.
+ *
+ * This pipeline is DELIBERATELY separate from the planner: there is no brief,
+ * no persona, no VideoPlan. The user hands us a finished source video; we run
+ * ASR, let an LLM pick the highlight segments, ffmpeg-cut them, and reassemble
+ * a tighter cut (podcast clipping, vlog re-edit, interview highlights).
+ *
+ * Two artifacts come out the far end:
+ *   1. a stitched MP4 (the deliverable — fast, no Remotion render needed), and
+ *   2. an editable Project JSON (source-trim video clips) so the user can
+ *      keep editing + re-render in the in-frontend editor.
+ *
+ * Like the rest of the agent surface, the PURE logic (segment math, caption
+ * remap, project assembly, highlight validation) lives in `shared` so it is
+ * testable + eval-able; the IO-heavy stages (download, ASR poll, ffmpeg,
+ * upload) live in the node-express worker where ffmpeg + the stitcher already
+ * are.
+ */
+// ─── editing intent ────────────────────────────────────────────────────────
+/**
+ * What the user wants out of the re-edit. Each goal nudges the highlight
+ * picker's prompt (see highlightPicker.ts) toward a different selection bias:
+ *   - highlights           : the single best moments, agnostic of format
+ *   - podcast-clips        : self-contained quotable segments (social clips)
+ *   - vlog-reedit          : keep narrative flow, cut dead air / filler
+ *   - interview-highlights : strongest Q→A exchanges, speaker-aware
+ */
+exports.EditGoalSchema = zod_1.z.enum([
+    "highlights",
+    "podcast-clips",
+    "vlog-reedit",
+    "interview-highlights",
+]);
+// ─── request (the controller body) ───────────────────────────────────────────
+exports.EditExistingRequestSchema = zod_1.z
+    .object({
+    /** Publicly-fetchable URL of the source video (Firebase Storage / signed). */
+    sourceVideoUrl: zod_1.z.string().url(),
+    /**
+     * Source duration in seconds — the uploader already knows this, and we
+     * need it for the UPFRONT credit estimate (ASR is billed per second). The
+     * worker reconciles against the real ASR `audioDuration` after transcription.
+     */
+    sourceDurationSec: zod_1.z.number().positive(),
+    editGoal: exports.EditGoalSchema,
+    /**
+     * Target length of the re-edit in seconds. The picker treats this as a
+     * soft budget (selects segments whose total is within tolerance). Omitted
+     * → the picker keeps everything it judges genuinely strong.
+     */
+    targetDurationSec: zod_1.z.number().positive().optional(),
+    /** Hard cap on number of segments the picker may keep. */
+    maxClips: zod_1.z.number().int().positive().max(50).optional(),
+    /** ASR language hint (e.g. "en", "es"). Omitted → AssemblyAI autodetect. */
+    language: zod_1.z.string().min(2).max(10).optional(),
+    /** Burn word-timed captions (built from the ASR words, remapped to the cut). */
+    addCaptions: zod_1.z.boolean().optional().default(false),
+    /** Output aspect; defaults to 16:9 (long-form source). */
+    aspect: project_schema_1.AspectSchema.optional(),
+    /** Optional intro clip prepended before the first highlight. */
+    introUrl: zod_1.z.string().url().optional(),
+    /** Optional outro clip appended after the last highlight. */
+    outroUrl: zod_1.z.string().url().optional(),
+    /** Free-form steering for the picker ("focus on the funding story", etc.). */
+    instructions: zod_1.z.string().max(2000).optional(),
+    /** Display title for the produced project. */
+    title: zod_1.z.string().max(200).optional(),
+})
+    .strict();
+// ─── highlight selection (LLM output) ────────────────────────────────────────
+exports.HighlightSegmentSchema = zod_1.z
+    .object({
+    /** Inclusive start in the SOURCE timeline, ms. */
+    startMs: zod_1.z.number().nonnegative(),
+    /** Exclusive end in the SOURCE timeline, ms. Must be > startMs (refined below). */
+    endMs: zod_1.z.number().positive(),
+    /** Why this moment was kept — surfaced in the UI + useful for eval. */
+    reason: zod_1.z.string().max(500),
+    /** Short human label (e.g. "Cold open", "Q: pricing"). Optional. */
+    label: zod_1.z.string().max(120).optional(),
+})
+    .strict()
+    .refine((s) => s.endMs > s.startMs, {
+    message: "endMs must be greater than startMs",
+    path: ["endMs"],
+});
+exports.HighlightSelectionSchema = zod_1.z
+    .object({
+    segments: zod_1.z.array(exports.HighlightSegmentSchema).min(1),
+    /** One-line description of the resulting cut (optional; shown in UI). */
+    summary: zod_1.z.string().max(500).optional(),
+})
+    .strict();
+// ─── BullMQ envelope ─────────────────────────────────────────────────────────
+/**
+ * Tiny job envelope — same design rule as AgentRunJobPayload: the full request
+ * lives on `agentProjects/{projectId}` (the controller stows it under
+ * `editRequest`), the worker reads it from Firestore at job start. Keeps the
+ * Redis stream light.
+ */
+exports.EditJobPayloadSchema = zod_1.z
+    .object({
+    runId: zod_1.z.string().min(1),
+    projectId: zod_1.z.string().min(1),
+    userId: zod_1.z.string().min(1),
+    enqueuedAt: zod_1.z.number().int().nonnegative(),
+})
+    .strict();
+// ─── cost ────────────────────────────────────────────────────────────────────
+/**
+ * Flat USD overheads for an edit job, beyond the per-second ASR cost:
+ *   - the highlight-picker LLM call (one structured Sonnet call over a
+ *     transcript — a few cents), and
+ *   - our ffmpeg compute (cut + normalize + concat — our own metal, but we
+ *     price a token amount so the op isn't free).
+ * Kept here (not in aiModels) because edit-existing isn't a generation model.
+ */
+exports.EDIT_PICKER_LLM_USD = 0.04;
+exports.EDIT_COMPUTE_USD = 0.06;
+/** AssemblyAI Universal-2 base rate, $/hr (mirrors AssemblyAIService). */
+const ASR_USD_PER_HOUR = 0.15;
+/** Diarization (speaker labels) surcharge multiplier (≈ +13%). */
+const ASR_DIARIZATION_MULT = 1.133;
+/**
+ * Speaker diarization is only worth its surcharge when the picker is
+ * speaker-aware. Interview / podcast goals benefit; plain highlights / vlog
+ * don't. Centralized so the controller (estimate), the picker (prompt), and
+ * the worker (ASR submit) all agree on a single rule.
+ */
+function editGoalUsesDiarization(goal) {
+    return goal === "interview-highlights" || goal === "podcast-clips";
+}
+/**
+ * Pure upfront credit estimate for an edit job. Used by the controller to
+ * deduct before enqueue and by the worker to reconcile (passing the real
+ * ASR-reported duration). 1 credit = $0.10 (see costPreflight.CREDIT_USD_RATE);
+ * `getCreditsFromCost` applies the per-paid-op floor + canonical rounding.
+ */
+function estimateEditCredits(args) {
+    const diarize = editGoalUsesDiarization(args.goal);
+    const asrUsd = (ASR_USD_PER_HOUR / 3600) *
+        Math.max(0, args.sourceDurationSec) *
+        (diarize ? ASR_DIARIZATION_MULT : 1);
+    // Captions reuse the SAME transcript already produced for highlight picking,
+    // so they add no second ASR pass — no extra cost line for addCaptions today.
+    const totalUsd = asrUsd + exports.EDIT_PICKER_LLM_USD + exports.EDIT_COMPUTE_USD;
+    return (0, helpers_1.getCreditsFromCost)(totalUsd);
+}

package/lib/services/agent/editExisting/highlightPicker.d.ts

@@ -0,0 +1,48 @@
+import { LlmCaller } from "../llmCaller";
+import { EditExistingRequest, HighlightSelection } from "./editExisting.schema";
+/**
+ * Stream L · L-5 — highlight picker. The reasoning core of the edit-existing
+ * pipeline: given an ASR transcript with word/utterance timestamps, an LLM
+ * selects the segments of the source to keep. Pure (injected LlmCaller), so
+ * the worker, scripts, and a no-spend eval can all drive it.
+ */
+/** Word-level ASR output (ms timestamps), as AssemblyAI returns it. */
+export interface TranscriptWord {
+    text: string;
+    /** ms from audio start. */
+    start: number;
+    end: number;
+    speaker?: string;
+}
+/** Utterance (speaker-grouped) ASR output, present when diarization is on. */
+export interface TranscriptUtterance {
+    text: string;
+    start: number;
+    end: number;
+    speaker: string;
+}
+export interface TranscriptForPicking {
+    fullText: string;
+    words?: TranscriptWord[];
+    utterances?: TranscriptUtterance[];
+    /** Actual audio duration in ms (from ASR). Hard upper bound for any segment. */
+    audioDurationMs: number;
+}
+/**
+ * Render the transcript as timestamped lines the model can quote start/end
+ * from. Prefers utterances (speaker-aware, naturally chunked); falls back to
+ * grouping words into ~sentence lines by punctuation so the model still gets
+ * tight, pickable boundaries with real timestamps.
+ */
+export declare function buildTranscriptLines(transcript: TranscriptForPicking): string;
+/**
+ * Pick highlight segments from a transcript. Retries up to `maxRetries` times,
+ * feeding the model its previous problems. Throws only if every attempt yields
+ * zero usable segments.
+ */
+export declare function pickHighlightsCore(llm: LlmCaller, args: {
+    request: EditExistingRequest;
+    transcript: TranscriptForPicking;
+    maxRetries?: number;
+}): Promise<HighlightSelection>;
+//# sourceMappingURL=highlightPicker.d.ts.map

package/lib/services/agent/editExisting/highlightPicker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"highlightPicker.d.ts","sourceRoot":"","sources":["../../../../src/services/agent/editExisting/highlightPicker.ts"],"names":[],"mappings":"AAEA,OAAO,EAAe,SAAS,EAAE,MAAM,cAAc,CAAC;AAEtD,OAAO,EACL,mBAAmB,EAInB,kBAAkB,EACnB,MAAM,uBAAuB,CAAC;AAM/B;;;;;GAKG;AAEH,uEAAuE;AACvE,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,2BAA2B;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,8EAA8E;AAC9E,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,cAAc,EAAE,CAAC;IACzB,UAAU,CAAC,EAAE,mBAAmB,EAAE,CAAC;IACnC,gFAAgF;IAChF,eAAe,EAAE,MAAM,CAAC;CACzB;AAwCD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,oBAAoB,GAAG,MAAM,CAiC7E;AAkGD;;;;GAIG;AACH,wBAAsB,kBAAkB,CACtC,GAAG,EAAE,SAAS,EACd,IAAI,EAAE;IACJ,OAAO,EAAE,mBAAmB,CAAC;IAC7B,UAAU,EAAE,oBAAoB,CAAC;IACjC,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,GACA,OAAO,CAAC,kBAAkB,CAAC,CAyD7B"}