@nodetool-ai/websocket 0.7.0-rc.23 → 0.8.2

package/dist/trpc/routers/timeline.js

@@ -0,0 +1,669 @@
+/**
+ * Timeline router — tRPC.
+ *
+ * Procedures:
+ *   list        (query)    — TimelineSequenceListItem[]
+ *   get         (query)    — TimelineSequenceResponse
+ *   create      (mutation) — TimelineSequenceResponse
+ *   update      (mutation) — TimelineSequenceResponse (optional baseUpdatedAt for optimistic concurrency)
+ *   delete      (mutation) — { ok: true }
+ *   clips.create        (mutation) — TimelineClipResponse
+ *   versions.list       (query)    — TimelineVersionListItem[]
+ *   versions.get        (query)    — TimelineVersionResponse
+ *   versions.create     (mutation) — TimelineVersionListItem (manual snapshot)
+ *   versions.restore    (mutation) — TimelineSequenceResponse (snapshots the
+ *                                    pre-restore state first, so it is undoable)
+ *   versions.delete     (mutation) — { ok: true }
+ *
+ * Auth: every procedure uses `protectedProcedure`. Ownership is enforced by
+ * comparing `seq.user_id` against `ctx.userId`.
+ */
+import { z } from "zod";
+import { TimelineSequence, TimelineSequenceConflictError, TimelineSequenceVersion, Workflow, createTimeOrderedUuid, getSecret } from "@nodetool-ai/models";
+import { makeClip } from "@nodetool-ai/timeline";
+import { contextSecretAvailability, createCapabilityRun, gateFromContext } from "@nodetool-ai/agents";
+import { PERMISSION_GATE_CONTEXT_KEY, ProcessingContext, headlessGate } from "@nodetool-ai/runtime";
+import { collectStrippedPaths } from "@nodetool-ai/execution/timeline-debug";
+import { createLogger } from "@nodetool-ai/config";
+import { computeDependencyHash } from "@nodetool-ai/timeline/dependencyHash.js";
+import { createClipInput, createTimelineInput, exampleTimelineSummary, installExampleTimelineInput, createTimelineVersionInput, deleteTimelineVersionInput, getTimelineVersionInput, listTimelineVersionsInput, patchTimelineInput, restoreTimelineVersionInput, timelineClipResponse, timelineSequenceListItem, timelineSequenceResponse, timelineVersionListItem, timelineVersionResponse } from "@nodetool-ai/protocol/api-schemas/timeline.js";
+import { ApiErrorCode } from "../../error-codes.js";
+import { router } from "../index.js";
+import { protectedProcedure } from "../middleware.js";
+import { throwApiError } from "../error-formatter.js";
+import { isString } from "../../lib/wire-values.js";
+import { installExampleTimeline, listExampleTimelines } from "../../lib/example-timelines.js";
+const log = createLogger("nodetool.websocket.trpc.timeline");
+// ── input shapes specific to this router ────────────────────────────────────
+const listInput = z.object({
+    projectId: z.string().optional()
+});
+// ── timeline.code — authoring code, baked and merged onto the document ─────
+//
+// This sub-router is a thin translation over the `get_timeline_code` /
+// `set_timeline_code` / `edit_timeline_code` / `rebake_timeline_code` /
+// `detach_timeline_code` capabilities in `@nodetool-ai/agents` — the same
+// implementation an agent reaches through the sandbox object model
+// (`nodetool.timelines.code.*`), so the editor and an agent write the exact
+// same bytes. The wire shape here is the fixed contract this surface was
+// designed against: `code.get` answers camelCase (`bakedAt`, `groupId`),
+// `code.set`/`code.rebake` answer `timeline_id` (snake_case, matching the
+// capability's own field) alongside camelCase `scenes`/`conflicts` entries.
+const timelineCodeForceInput = z
+    .union([z.boolean(), z.array(z.string())])
+    .optional();
+const timelineCodeSetInput = z.object({
+    id: z.string(),
+    code: z.string(),
+    force: timelineCodeForceInput
+});
+const timelineCodeRebakeInput = z.object({
+    id: z.string(),
+    force: timelineCodeForceInput
+});
+const timelineCodeDetachInput = z.object({
+    id: z.string(),
+    scenes: z.union([z.literal("all"), z.array(z.string()).min(1)])
+});
+const timelineCodeSceneReport = z.object({
+    name: z.string(),
+    groupId: z.string(),
+    edited: z.boolean()
+});
+const timelineCodeGetOutput = z.object({
+    code: z.string().nullable(),
+    bakedAt: z.string().nullable(),
+    scenes: z.array(timelineCodeSceneReport)
+});
+const timelineCodeConflict = z.object({
+    scene: z.string(),
+    reason: z.string()
+});
+const timelineCodeWriteOutput = z.object({
+    timeline_id: z.string(),
+    errors: z.array(z.string()),
+    warnings: z.array(z.string()),
+    conflicts: z.array(timelineCodeConflict),
+    scenes: z.array(timelineCodeSceneReport)
+});
+const timelineCodeDetachOutput = z.object({
+    scenes: z.array(z.string())
+});
+const TIMELINE_CODE_HOST = "timeline.code";
+/**
+ * A run over the timeline-code capabilities. There is nobody to ask (a route
+ * handler, not a chat turn), so it runs the same headless `auto` gate every
+ * other server-side capability call does.
+ */
+function timelineCodeRun(userId) {
+    const context = new ProcessingContext({
+        jobId: `timeline-code-${Date.now()}`,
+        userId,
+        secretResolver: getSecret
+    });
+    context.set(PERMISSION_GATE_CONTEXT_KEY, headlessGate(TIMELINE_CODE_HOST));
+    return createCapabilityRun({
+        context,
+        gate: gateFromContext(context, TIMELINE_CODE_HOST),
+        availableSecrets: contextSecretAvailability(context)
+    });
+}
+function mapTimelineCodeScenes(scenes) {
+    return (scenes ?? []).map((scene) => ({
+        name: scene.name,
+        groupId: scene.group_id,
+        edited: scene.edited
+    }));
+}
+/**
+ * A capability-level `{error}` with no `timeline_id` is a refusal before any
+ * bake ran — bad ownership, an empty `code`, no authoring code to edit or
+ * rebake. Thrown as a tRPC error rather than folded into the write-result
+ * shape, which is reserved for a call that found the timeline and tried.
+ */
+function throwTimelineCodeError(error) {
+    const code = /was not found/i.test(error)
+        ? ApiErrorCode.NOT_FOUND
+        : ApiErrorCode.INVALID_INPUT;
+    throwApiError(code, error);
+}
+function timelineCodeCapabilityError(result) {
+    if (result !== null &&
+        typeof result === "object" &&
+        typeof result.error === "string" &&
+        !("timeline_id" in result)) {
+        return result.error;
+    }
+    return null;
+}
+function mapTimelineCodeWriteResult(result) {
+    return {
+        timeline_id: String(result["timeline_id"]),
+        errors: Array.isArray(result["errors"])
+            ? result["errors"]
+            : [],
+        warnings: Array.isArray(result["warnings"])
+            ? result["warnings"]
+            : [],
+        conflicts: Array.isArray(result["conflicts"])
+            ? result["conflicts"]
+            : [],
+        scenes: mapTimelineCodeScenes(result["scenes"])
+    };
+}
+const idInput = z.object({ id: z.string() });
+/**
+ * `patchTimelineInput.document` is a stripping schema: a clip field this build
+ * does not declare is dropped by the parse and lost on the write, and nothing
+ * downstream ever sees it again. The handler compares the document it is about
+ * to store against what the client actually sent, so the parse must not be the
+ * only place the raw value exists — `rawDocument` carries it through unparsed.
+ */
+const updateInput = z.preprocess((raw) => isRecord(raw) && !("rawDocument" in raw)
+    ? { ...raw, rawDocument: raw.document }
+    : raw, patchTimelineInput.and(z.object({
+    id: z.string(),
+    baseUpdatedAt: z.string().optional(),
+    rawDocument: z.unknown().optional()
+})));
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/**
+ * Paths the schema dropped between what the client sent and what is stored.
+ * Same walk the timeline debug report uses, so the save path and the report
+ * cannot disagree about what was lost.
+ */
+function strippedDocumentPaths(raw, parsed) {
+    const found = new Set();
+    collectStrippedPaths(raw, parsed, "", found);
+    return [...found].sort();
+}
+const okOutput = z.object({ ok: z.literal(true) });
+/**
+ * The stored sequence, plus the paths the schema dropped on the way in. The
+ * field is absent on a clean save; every existing caller reads the sequence and
+ * is unaffected.
+ */
+const updateOutput = timelineSequenceResponse.extend({
+    stripped: z.array(z.string()).optional()
+});
+// ── helpers ─────────────────────────────────────────────────────────────────
+function toListItem(seq) {
+    return {
+        id: seq.id,
+        projectId: seq.project_id,
+        name: seq.name,
+        updatedAt: seq.updated_at
+    };
+}
+/**
+ * A version row carries its document as JSON text on SQLite and as an object on
+ * Postgres, so parse only when it is a string.
+ */
+function parseVersionDocument(raw) {
+    const value = isString(raw) ? JSON.parse(raw) : raw;
+    return (value ?? { tracks: [], clips: [], markers: [] });
+}
+function toVersionListItem(version) {
+    return {
+        id: version.id,
+        timelineId: version.timeline_id,
+        version: version.version,
+        name: version.name ?? null,
+        saveType: version.save_type,
+        fps: version.fps,
+        width: version.width,
+        height: version.height,
+        durationMs: version.duration_ms,
+        createdAt: version.created_at
+    };
+}
+// ── autosave snapshot cadence ───────────────────────────────────────────────
+/** A document write only snapshots when the last autosave is this old. */
+const AUTOSAVE_VERSION_INTERVAL_MS = 5 * 60 * 1000;
+/** Autosave snapshots kept per timeline; older ones are pruned. */
+const MAX_AUTOSAVE_VERSIONS = 20;
+const lastAutosaveVersionTime = new Map();
+// Entries older than the interval can never suppress a snapshot again, so drop
+// them. Without this the map grows one permanent entry per timeline ever saved
+// (including deleted ones) for the lifetime of the process.
+function recordAutosaveVersion(id, now) {
+    for (const [key, ts] of lastAutosaveVersionTime) {
+        if (now - ts >= AUTOSAVE_VERSION_INTERVAL_MS) {
+            lastAutosaveVersionTime.delete(key);
+        }
+    }
+    lastAutosaveVersionTime.set(id, now);
+}
+/** Test hook: forget the autosave cadence so a suite can drive it from zero. */
+export function __resetTimelineAutosaveVersionState() {
+    lastAutosaveVersionTime.clear();
+}
+async function loadOwned(ctxUserId, id) {
+    if (!ctxUserId)
+        throwApiError(ApiErrorCode.UNAUTHORIZED, "Unauthorized");
+    const seq = await TimelineSequence.findById(id);
+    if (!seq || seq.user_id !== ctxUserId) {
+        throwApiError(ApiErrorCode.NOT_FOUND, "Timeline sequence not found");
+    }
+    return seq;
+}
+// ── Node-type helpers ────────────────────────────────────────────────────────
+/** Known terminal media-output node type suffixes → mediaType */
+const OUTPUT_NODE_MEDIA_TYPES = {
+    "nodetool.output.ImageOutput": "image",
+    "nodetool.output.VideoOutput": "video",
+    "nodetool.output.AudioOutput": "audio"
+};
+function isOutputNode(nodeType) {
+    return nodeType in OUTPUT_NODE_MEDIA_TYPES;
+}
+function mediaTypeForOutputNode(nodeType) {
+    return OUTPUT_NODE_MEDIA_TYPES[nodeType] ?? null;
+}
+function isInputNode(nodeType) {
+    return nodeType.startsWith("nodetool.input.");
+}
+/** Extract the node's `name` property from its `data` or `dynamic_properties`. */
+function inputNodeName(node) {
+    const data = node.data;
+    return (data?.name ??
+        node.dynamic_properties?.name ??
+        null);
+}
+/** Extract the default value for an input node from its `data`. */
+function inputNodeDefault(node) {
+    // SAFETY: the graph is stored as JSON, so a node's `data` holds JSON members.
+    const data = node.data;
+    return data?.value ?? null;
+}
+/** Default durationMs for each media type. */
+const DEFAULT_DURATION_MS = {
+    image: 4000,
+    video: 4000,
+    audio: 4000,
+    overlay: 4000
+};
+async function mutateTimelineDocument(id, mutator) {
+    try {
+        return await TimelineSequence.mutateDocument(id, mutator);
+    }
+    catch (error) {
+        if (error instanceof TimelineSequenceConflictError) {
+            throwApiError(ApiErrorCode.ALREADY_EXISTS, "Timeline changed concurrently; retry the operation");
+        }
+        throw error;
+    }
+}
+// ── clips sub-router input ───────────────────────────────────────────────────
+// (defined in protocol; re-used here)
+// ── router ──────────────────────────────────────────────────────────────────
+export const timelineRouter = router({
+    examples: protectedProcedure
+        .output(z.array(exampleTimelineSummary))
+        .query(({ ctx }) => listExampleTimelines(ctx.apiOptions)),
+    installExample: protectedProcedure
+        .input(installExampleTimelineInput)
+        .output(timelineSequenceResponse)
+        .mutation(({ ctx, input }) => installExampleTimeline(ctx.userId, ctx.apiOptions, input)),
+    list: protectedProcedure
+        .input(listInput)
+        .output(z.array(timelineSequenceListItem))
+        .query(async ({ ctx, input }) => {
+        const seqs = input.projectId
+            ? await TimelineSequence.listByProject(input.projectId, ctx.userId)
+            : await TimelineSequence.listByUser(ctx.userId);
+        return seqs.map(toListItem);
+    }),
+    get: protectedProcedure
+        .input(idInput)
+        .output(timelineSequenceResponse)
+        .query(async ({ ctx, input }) => {
+        const seq = await loadOwned(ctx.userId, input.id);
+        return seq.toTimelineSequence();
+    }),
+    create: protectedProcedure
+        .input(createTimelineInput)
+        .output(timelineSequenceResponse)
+        .mutation(async ({ ctx, input }) => {
+        // A client-minted id makes create idempotent: a retry (or a second
+        // surface racing to create the same sequence) returns the existing row
+        // instead of duplicating it.
+        if (input.id) {
+            const existing = await TimelineSequence.findById(input.id);
+            if (existing) {
+                if (existing.user_id !== ctx.userId) {
+                    throwApiError(ApiErrorCode.NOT_FOUND, "Timeline sequence not found");
+                }
+                return existing.toTimelineSequence();
+            }
+        }
+        const fields = {
+            user_id: ctx.userId,
+            project_id: input.projectId,
+            name: input.name,
+            fps: input.fps,
+            width: input.width,
+            height: input.height
+        };
+        // Set only when the client supplied one — the model defaults an id it
+        // does not already own as a property.
+        if (input.id) {
+            fields.id = input.id;
+        }
+        const seq = new TimelineSequence(fields);
+        await seq.save();
+        return seq.toTimelineSequence();
+    }),
+    update: protectedProcedure
+        .input(updateInput)
+        .output(updateOutput)
+        .mutation(async ({ ctx, input }) => {
+        const seq = await loadOwned(ctx.userId, input.id);
+        // The write CAS-es on this value, so the conflict check and the write are
+        // atomic (no TOCTOU window). When the client supplies baseUpdatedAt, honor
+        // it; otherwise fall back to the just-loaded updated_at.
+        const expectedUpdatedAt = input.baseUpdatedAt ?? seq.updated_at;
+        if (input.baseUpdatedAt !== undefined &&
+            input.baseUpdatedAt !== seq.updated_at) {
+            throwApiError(ApiErrorCode.ALREADY_EXISTS, "Timeline has been modified since last load");
+        }
+        let stripped = [];
+        const fields = {};
+        if (input.name !== undefined)
+            fields.name = input.name;
+        if (input.fps !== undefined)
+            fields.fps = input.fps;
+        if (input.width !== undefined)
+            fields.width = input.width;
+        if (input.height !== undefined)
+            fields.height = input.height;
+        if (input.durationMs !== undefined)
+            fields.duration_ms = input.durationMs;
+        if (input.document !== undefined) {
+            const current = seq.toDocument();
+            const merged = {
+                tracks: input.document.tracks ?? current.tracks,
+                clips: input.document.clips ??
+                    current.clips,
+                markers: input.document.markers ?? current.markers,
+                storyboardMaterializations: input.document.storyboardMaterializations ?? current.storyboardMaterializations,
+                transcript: input.document.transcript ?? current.transcript,
+                scriptEnabled: input.document.scriptEnabled ?? current.scriptEnabled,
+                tempo: input.document.tempo ?? current.tempo,
+                camera2d: input.document.camera2d === undefined ? current.camera2d : input.document.camera2d,
+                setup: input.document.setup ?? current.setup,
+                mediaTracks: input.document.mediaTracks ?? current.mediaTracks,
+                // The authoring code and its scene hashes belong to the server. An
+                // editor save never carries them, and must not remove them.
+                source: current.source
+            };
+            fields.document = JSON.stringify(merged);
+            stripped = strippedDocumentPaths(input.rawDocument, input.document);
+            if (stripped.length > 0) {
+                log.warn("Timeline document fields dropped by the schema on save", {
+                    timelineId: input.id,
+                    strippedPaths: stripped
+                });
+            }
+        }
+        const updated = await TimelineSequence.updateFieldsIfUnchanged(input.id, expectedUpdatedAt, fields);
+        if (!updated) {
+            // The row changed between load and write (or was deleted). Report a
+            // conflict rather than silently overwriting the concurrent change.
+            throwApiError(ApiErrorCode.ALREADY_EXISTS, "Timeline has been modified since last load");
+        }
+        if (input.document !== undefined) {
+            // Best-effort history: a snapshot that fails must never fail the save
+            // the user actually asked for (and the versions table may not exist on
+            // an older database).
+            try {
+                const now = Date.now();
+                const last = lastAutosaveVersionTime.get(input.id);
+                if (last === undefined ||
+                    now - last >= AUTOSAVE_VERSION_INTERVAL_MS) {
+                    recordAutosaveVersion(input.id, now);
+                    await TimelineSequenceVersion.snapshot(updated, {
+                        saveType: "autosave"
+                    });
+                    await TimelineSequenceVersion.pruneAutosaves(input.id, MAX_AUTOSAVE_VERSIONS);
+                }
+            }
+            catch {
+                // non-fatal — the document write already succeeded
+            }
+        }
+        // Reported, never refused: the write the user asked for already
+        // happened, and refusing a document because one field is unknown would
+        // lose far more than the field does.
+        return stripped.length > 0
+            ? { ...updated.toTimelineSequence(), stripped }
+            : updated.toTimelineSequence();
+    }),
+    delete: protectedProcedure
+        .input(idInput)
+        .output(okOutput)
+        .mutation(async ({ ctx, input }) => {
+        // Ownership, the row, and its version rows are one operation on the
+        // model, shared with the sandbox's `delete_timeline` capability.
+        await loadOwned(ctx.userId, input.id);
+        await TimelineSequence.deleteOwned(ctx.userId, input.id);
+        lastAutosaveVersionTime.delete(input.id);
+        return { ok: true };
+    }),
+    versions: router({
+        list: protectedProcedure
+            .input(listTimelineVersionsInput)
+            .output(z.array(timelineVersionListItem))
+            .query(async ({ ctx, input }) => {
+            await loadOwned(ctx.userId, input.id);
+            const versions = await TimelineSequenceVersion.listForTimeline(input.id, { limit: input.limit, saveType: input.saveType });
+            return versions.map(toVersionListItem);
+        }),
+        get: protectedProcedure
+            .input(getTimelineVersionInput)
+            .output(timelineVersionResponse)
+            .query(async ({ ctx, input }) => {
+            await loadOwned(ctx.userId, input.id);
+            const version = await TimelineSequenceVersion.findByVersion(input.id, input.version);
+            if (!version) {
+                throwApiError(ApiErrorCode.NOT_FOUND, "Timeline version not found");
+            }
+            return {
+                ...toVersionListItem(version),
+                document: parseVersionDocument(version.document)
+            };
+        }),
+        create: protectedProcedure
+            .input(createTimelineVersionInput)
+            .output(timelineVersionListItem)
+            .mutation(async ({ ctx, input }) => {
+            const seq = await loadOwned(ctx.userId, input.id);
+            const version = await TimelineSequenceVersion.snapshot(seq, {
+                saveType: "manual",
+                name: input.name ?? null
+            });
+            return toVersionListItem(version);
+        }),
+        restore: protectedProcedure
+            .input(restoreTimelineVersionInput)
+            .output(timelineSequenceResponse)
+            .mutation(async ({ ctx, input }) => {
+            const seq = await loadOwned(ctx.userId, input.id);
+            const version = await TimelineSequenceVersion.findByVersion(input.id, input.version);
+            if (!version) {
+                throwApiError(ApiErrorCode.NOT_FOUND, "Timeline version not found");
+            }
+            // Snapshot what is about to be overwritten first, so a restore is
+            // itself undoable.
+            await TimelineSequenceVersion.snapshot(seq, {
+                saveType: "restore",
+                name: `Before restore to v${input.version}`
+            });
+            const document = parseVersionDocument(version.document);
+            const updated = await TimelineSequence.updateFieldsIfUnchanged(input.id, seq.updated_at, {
+                document: JSON.stringify(document),
+                fps: version.fps,
+                width: version.width,
+                height: version.height,
+                duration_ms: version.duration_ms
+            });
+            if (!updated) {
+                throwApiError(ApiErrorCode.ALREADY_EXISTS, "Timeline has been modified since last load");
+            }
+            return updated.toTimelineSequence();
+        }),
+        delete: protectedProcedure
+            .input(deleteTimelineVersionInput)
+            .output(okOutput)
+            .mutation(async ({ ctx, input }) => {
+            await loadOwned(ctx.userId, input.id);
+            const version = await TimelineSequenceVersion.findByVersion(input.id, input.version);
+            if (!version) {
+                throwApiError(ApiErrorCode.NOT_FOUND, "Timeline version not found");
+            }
+            await version.delete();
+            return { ok: true };
+        })
+    }),
+    code: router({
+        get: protectedProcedure
+            .input(idInput)
+            .output(timelineCodeGetOutput)
+            .query(async ({ ctx, input }) => {
+            const result = (await timelineCodeRun(ctx.userId).invoke("get_timeline_code", { timeline_id: input.id }));
+            if (result.error !== undefined) {
+                throwTimelineCodeError(result.error);
+            }
+            return {
+                code: result.code ?? null,
+                bakedAt: result.baked_at ?? null,
+                scenes: mapTimelineCodeScenes(result.scenes)
+            };
+        }),
+        set: protectedProcedure
+            .input(timelineCodeSetInput)
+            .output(timelineCodeWriteOutput)
+            .mutation(async ({ ctx, input }) => {
+            const params = {
+                timeline_id: input.id,
+                code: input.code
+            };
+            if (input.force !== undefined)
+                params.force = input.force;
+            const result = (await timelineCodeRun(ctx.userId).invoke("set_timeline_code", params));
+            const error = timelineCodeCapabilityError(result);
+            if (error !== null)
+                throwTimelineCodeError(error);
+            return mapTimelineCodeWriteResult(result);
+        }),
+        rebake: protectedProcedure
+            .input(timelineCodeRebakeInput)
+            .output(timelineCodeWriteOutput)
+            .mutation(async ({ ctx, input }) => {
+            const params = { timeline_id: input.id };
+            if (input.force !== undefined)
+                params.force = input.force;
+            const result = (await timelineCodeRun(ctx.userId).invoke("rebake_timeline_code", params));
+            const error = timelineCodeCapabilityError(result);
+            if (error !== null)
+                throwTimelineCodeError(error);
+            return mapTimelineCodeWriteResult(result);
+        }),
+        detach: protectedProcedure
+            .input(timelineCodeDetachInput)
+            .output(timelineCodeDetachOutput)
+            .mutation(async ({ ctx, input }) => {
+            const result = (await timelineCodeRun(ctx.userId).invoke("detach_timeline_code", { timeline_id: input.id, scenes: input.scenes }));
+            if (result.error !== undefined) {
+                throwTimelineCodeError(result.error);
+            }
+            return { scenes: result.scenes ?? [] };
+        })
+    }),
+    clips: router({
+        create: protectedProcedure
+            .input(createClipInput)
+            .output(timelineClipResponse)
+            .mutation(async ({ ctx, input }) => {
+            await loadOwned(ctx.userId, input.id);
+            // Validate access to the source workflow.
+            const source = await Workflow.find(ctx.userId, input.sourceWorkflowId);
+            if (!source) {
+                throwApiError(ApiErrorCode.NOT_FOUND, "Source workflow not found or not accessible");
+            }
+            const nodes = source.graph?.nodes ?? [];
+            const outputNodes = nodes.filter((n) => isOutputNode(n.type));
+            if (outputNodes.length === 0) {
+                throwApiError(ApiErrorCode.TIMELINE_NO_MEDIA_OUTPUT, "Source workflow has no media output node (ImageOutput, VideoOutput, or AudioOutput)");
+            }
+            let selectedOutputNode;
+            if (input.selectedOutputNodeId) {
+                const found = outputNodes.find((n) => n.id === input.selectedOutputNodeId);
+                if (!found) {
+                    throwApiError(ApiErrorCode.INVALID_INPUT, `selectedOutputNodeId ${input.selectedOutputNodeId} is not a terminal output node in the source graph`);
+                }
+                selectedOutputNode = found;
+            }
+            else if (outputNodes.length === 1) {
+                selectedOutputNode = outputNodes[0];
+            }
+            else {
+                throwApiError(ApiErrorCode.INVALID_INPUT, "Source workflow has multiple terminal output nodes; provide selectedOutputNodeId");
+            }
+            const rawMediaType = mediaTypeForOutputNode(selectedOutputNode.type) ?? "image";
+            const mediaType = input.mediaTypeOverride === "overlay" && rawMediaType === "video"
+                ? "overlay"
+                : rawMediaType;
+            const paramOverrides = {};
+            for (const node of nodes) {
+                if (!isInputNode(node.type))
+                    continue;
+                const name = inputNodeName(node);
+                if (name) {
+                    paramOverrides[name] = inputNodeDefault(node);
+                }
+            }
+            const durationMsInput = nodes.find((n) => isInputNode(n.type) && inputNodeName(n) === "duration_ms");
+            const durationMs = (durationMsInput
+                ? inputNodeDefault(durationMsInput)
+                : null) ??
+                DEFAULT_DURATION_MS[mediaType] ??
+                4000;
+            const workflowUpdatedAt = source.updated_at ?? new Date().toISOString();
+            const dependencyHash = computeDependencyHash({
+                workflowId: source.id,
+                workflowUpdatedAt,
+                paramOverrides,
+                inputAssetHashes: [],
+                selectedOutputNodeId: selectedOutputNode.id
+            });
+            // Clip name inherits the source workflow's name so users can
+            // identify clip origins in the timeline before renaming.
+            const clipId = createTimeOrderedUuid();
+            const newClip = makeClip({
+                id: clipId,
+                name: source.name,
+                trackId: input.trackId,
+                startMs: input.startMs,
+                durationMs,
+                mediaType,
+                sourceType: "generated",
+                workflowId: source.id,
+                selectedOutputNodeId: selectedOutputNode.id,
+                paramOverrides,
+                dependencyHash,
+                status: "draft",
+                locked: false,
+                versions: []
+            });
+            const outcome = await mutateTimelineDocument(input.id, (doc) => {
+                doc.clips.push(newClip);
+            });
+            if (!outcome) {
+                throwApiError(ApiErrorCode.NOT_FOUND, "Timeline sequence not found");
+            }
+            return newClip;
+        })
+    })
+});
+//# sourceMappingURL=timeline.js.map