diff --git a/docs/guides/user-guide.md b/docs/guides/user-guide.md
index dedc3237..00375f00 100644
--- a/docs/guides/user-guide.md
+++ b/docs/guides/user-guide.md
@@ -193,3 +193,7 @@ Saving projects locally does not imply offline inference. Generation prompts and
 | A video cannot be rendered or exported | Check your browser's encoding support and whether the assets can be read and played correctly. Keep the page and editor open while rendering |
 | A task is interrupted, or its submission status is unknown | Check **Generation history**. Use **Continue checking the original task** for recoverable tasks. If the status is unknown, check whether the server accepted the task before submitting again |
 | Changes have not been saved | Keep the page open, check the **Saved locally** status and any error messages, and resolve the save failure before closing or switching |
+
+### Output a timeline from the canvas
+
+Select an unlocked timeline node and use **Output video** in its toolbar. **⌘Enter** on macOS or **Ctrl+Enter** on Windows/Linux performs the same action when focus is outside a text field or dialog. The saved timeline supplies the output size, frame rate, clips and audio. A pending video node appears below the timeline immediately, with rendering progress and a cancel control. Successful publication replaces that preview with the playable MP4 under the same node identity, connected to its timeline by an output-source line. Repeated output adds a version to that video node; use its version picker to preview or restore earlier outputs. The editable timeline remains available. Failed output can be retried from the pending node. Keep the page open while rendering. Cancel stops rendering; retrying a failed publication reuses the rendered video and operation identity.
diff --git a/docs/guides/user-guide.zh-CN.md b/docs/guides/user-guide.zh-CN.md
index 377ba8cf..8a64f09f 100644
--- a/docs/guides/user-guide.zh-CN.md
+++ b/docs/guides/user-guide.zh-CN.md
@@ -193,3 +193,7 @@ AI 助手可通过共用编辑命令修改同一份已保存时间线。交接
 | 视频无法合成或导出 | 检查浏览器的编码支持，以及素材是否能正常读取和播放；合成期间保持页面和编辑器打开 |
 | 任务中断或提交状态不明 | 查看“生成历史”；可恢复任务使用“继续查询原任务”，状态不明时先核对服务端是否已接收，避免重复提交 |
 | 修改没有保存 | 保持页面打开，检查“已保存到本机”状态和错误提示，处理保存失败后再关闭或切换 |
+
+### 在画布上输出时间线
+
+选中未锁定的时间线节点，点击顶部工具栏的“输出视频”。焦点不在文本输入框或对话框中时，macOS 可按 **⌘Enter**，Windows/Linux 可按 **Ctrl+Enter** 执行同一操作。输出沿用已保存时间线的画幅、帧率、片段和音轨。开始输出后，时间线下方立即显示带动画、进度和取消按钮的视频占位节点。发布成功后，同一节点显示可播放的 MP4，并以来源线连接时间线。重复输出会为该视频节点新增版本，可通过版本入口预览和恢复之前的输出。原时间线仍可继续编辑；失败时可在占位节点上重试。渲染期间请保持页面打开；可取消渲染。发布失败后重试会复用已渲染视频和原操作标识。
diff --git a/packages/core/src/opendirector/application/creation_canvas.py b/packages/core/src/opendirector/application/creation_canvas.py
index 68faf53a..1d6e9d19 100644
--- a/packages/core/src/opendirector/application/creation_canvas.py
+++ b/packages/core/src/opendirector/application/creation_canvas.py
@@ -463,13 +463,24 @@ def _publish_render(self, data, payload):
         for ref in (*sources, payload.asset):
             self._available(self.assets._reference(snapshot, ref))
         asset = self._get(data, 'asset', output.id)
-        asset['provenance'] = dict(source='rendered', editorDocumentId=str(doc.id), editorRevision=doc.revision,
+        existing = next((i for i in snapshot.canvasItems if i.id == payload.outputId), None)
+        if existing is not None:
+            if payload.expectedOutputRevision is None:
+                raise ContractError('revision_conflict', '输出节点已存在，请提供其当前版本。', payload.outputId)
+            target = self._editable(data, payload.outputId)
+            previous = current_asset(snapshot, existing)
+            if (existing.kind != 'video' or existing.binding.role != 'material' or previous is None
+                    or previous.provenance.source != 'rendered' or previous.provenance.editorDocumentId != doc.id
+                    or previous.provenance.sourceItemId not in {None, payload.itemId}):
+                raise ContractError('role_restricted', '输出节点不属于当前时间线。', payload.outputId)
+            target['binding'] = dict(role='material', objectRef=payload.asset.model_dump(mode='json'))
+        else:
+            result = VideoCanvasItem(id=payload.outputId, projectId=snapshot.project.id, kind='video', title=payload.title,
+                position=payload.position, binding=dict(role='material', objectRef=payload.asset))
+            data['canvasItems'].append(result.model_dump(mode='json'))
+        asset['provenance'] = dict(source='rendered', sourceItemId=str(payload.itemId),
+                                  editorDocumentId=str(doc.id), editorRevision=doc.revision,
                                   sources=[ref.model_dump(mode='json') for ref in sources])
-        if any(i['id'] == str(payload.outputId) for i in data['canvasItems']):
-            raise ContractError('invalid_input', '输出节点标识已存在。', payload.outputId)
-        result = VideoCanvasItem(id=payload.outputId, projectId=snapshot.project.id, kind='video', title=payload.title,
-            position=payload.position, binding=dict(role='material', objectRef=payload.asset))
-        data['canvasItems'].append(result.model_dump(mode='json'))
 
     def _mutate(self, data, kind, payload):
         value = payload.model_dump(mode='json', exclude_unset=True)
diff --git a/packages/core/src/opendirector/domain/creation/commands.py b/packages/core/src/opendirector/domain/creation/commands.py
index 2e02ff8c..87c7a9b6 100644
--- a/packages/core/src/opendirector/domain/creation/commands.py
+++ b/packages/core/src/opendirector/domain/creation/commands.py
@@ -131,6 +131,7 @@ class TimelinePublishRender(Contract):
     editorId: UUID = Field(description='Editable document ID.')
     asset: AssetRef = Field(description='Immutable asset version.')
     outputId: UUID = Field(description='Published canvas output ID.')
+    expectedOutputRevision: Revision | None = Field(default=None, exclude_if=lambda value: value is None, description='Current output node revision when appending a rendered version.')
     title: str = Field(default='合成视频', max_length=255, description='User-visible title.')
     position: Point = Field(default_factory=Point, description='Position in the owning canvas or stage.')
 
@@ -269,6 +270,8 @@ def scope_and_versions(self):
             raise ValueError('expectedVersions missing current versions for ' + ', '.join(missing))
         if self.type == 'generation.submit' and versions[('generation_spec', payload.specId)] != payload.expectedSpecRevision:
             raise ValueError('Submission version differs from expected spec version')
+        if self.type == 'timeline.publishRender' and payload.expectedOutputRevision is not None and versions[('canvas_item', payload.outputId)] != payload.expectedOutputRevision:
+            raise ValueError('Output revision differs from its expected version')
         if self.type in {'generationSpec.update', 'editor.save', 'reference.update', 'reference.restore'}:
             obj = (payload.spec if self.type == 'generationSpec.update' else
                    payload.document if self.type == 'editor.save' else payload.reference)
@@ -288,6 +291,8 @@ def required_versions(self) -> list[tuple[str, UUID]]:
                 required.append(('editor_document', payload.sourceEditorId))
         elif self.type in {'canvas.applyEdit', 'timeline.publishRender'}:
             required = [('canvas_item', payload.itemId), ('asset', payload.asset.assetId), ('editor_document', payload.editorId)]
+            if self.type == 'timeline.publishRender' and payload.expectedOutputRevision is not None:
+                required.append(('canvas_item', payload.outputId))
         elif self.type in {'canvas.update', 'canvas.hide', 'canvas.materialize', 'canvas.applyEdit', 'canvas.configure', 'canvas.attachEditor', 'canvas.detachEditor', 'canvas.applyVersion'}:
             required = [('canvas_item', payload.itemId)]
         elif self.type == 'canvas.move':
diff --git a/scripts/run-browser-suite.mjs b/scripts/run-browser-suite.mjs
index b64bb957..7762b5c9 100644
--- a/scripts/run-browser-suite.mjs
+++ b/scripts/run-browser-suite.mjs
@@ -13,6 +13,7 @@
 import { spawnSync } from "node:child_process";
 
 const workflows = [
+  { name: "timeline node output", script: "tests/browser/timeline_node_output.mjs" },
   { name: "locale", script: "tests/browser/locale.mjs" },
   { name: "creation closure", script: "scripts/verify_creation_browser.mjs" },
   { name: "assistant activity", script: "tests/browser/assistant_activity.mjs" },
diff --git a/src/backend/creationProjection.ts b/src/backend/creationProjection.ts
index 00e1b858..18eef8f9 100644
--- a/src/backend/creationProjection.ts
+++ b/src/backend/creationProjection.ts
@@ -899,7 +899,10 @@ export class CreationProjection {
     }
     for (const item of snapshot.canvasItems) {
       const asset = currentAsset(snapshot, item);
-      const sourceId = asset?.provenance.sourceItemId;
+      const timelineSources = asset?.provenance.source === "rendered" && asset.provenance.editorDocumentId
+        ? snapshot.canvasItems.filter((source) => source.kind === "timeline" && source.binding.role === "editor" && source.binding.objectRef.id === asset.provenance.editorDocumentId)
+        : [];
+      const sourceId = asset?.provenance.sourceItemId ?? (timelineSources.length === 1 ? timelineSources[0].id : undefined);
       if (sourceId && snapshot.canvasItems.some((i) => i.id === sourceId))
         document.edges.push({
           id: `publication:${item.id}:${asset!.id}`,
diff --git a/src/backend/timelinePublication.ts b/src/backend/timelinePublication.ts
index d12a2439..5b2a7a59 100644
--- a/src/backend/timelinePublication.ts
+++ b/src/backend/timelinePublication.ts
@@ -4,20 +4,37 @@ import { CreationClient, objectVersion } from "./creationClient.ts";
 import { CreationProjection } from "./creationProjection.ts";
 import { tNow } from "../i18n/messages.ts";
 
+export function timelineOutputItem(snapshot: ProjectSnapshot, itemId: string) {
+  const source = snapshot.canvasItems.find((item) => item.id === itemId);
+  if (source?.binding.role !== "editor") return undefined;
+  const editorId = source.binding.objectRef.id;
+  return [...snapshot.canvasItems].reverse().find((item) => {
+    if (item.kind !== "video" || item.binding.role !== "material" || !item.visible) return false;
+    const assetId = item.binding.objectRef.assetId;
+    const origin = snapshot.assets.find((asset) => asset.id === assetId)?.provenance;
+    return origin?.source === "rendered" && origin.editorDocumentId === editorId &&
+      (!origin.sourceItemId || origin.sourceItemId === itemId);
+  });
+}
+
 /** Captured when rendering starts, independent of subsequent editor changes. */
 export function timelinePublication(
   client: CreationClient,
   snapshot: ProjectSnapshot,
   itemId: string,
+  position?: { x: number; y: number },
+  outputId?: string,
 ) {
   const item = snapshot.canvasItems.find((item) => item.id === itemId)!;
   if (item.binding.role !== "editor")
     throw new Error(tNow("errors.backend.timelineSourceMissing"));
   const editorId = item.binding.objectRef.id;
   const editor = snapshot.editorDocuments.find((doc) => doc.id === editorId)!;
+  const existing = timelineOutputItem(snapshot, itemId);
+  outputId ??= existing?.id ?? crypto.randomUUID();
+  const target = snapshot.canvasItems.find((item) => item.id === outputId);
   const projection = new CreationProjection(client);
-  const commandId = crypto.randomUUID(),
-    outputId = crypto.randomUUID();
+  const commandId = crypto.randomUUID();
   let delivery:
     | {
         payload: {
@@ -25,6 +42,7 @@ export function timelinePublication(
           editorId: string;
           asset: Awaited<ReturnType<CreationProjection["importResource"]>>;
           outputId: string;
+          expectedOutputRevision?: number;
           title: string;
           position: { x: number; y: number };
         };
@@ -33,21 +51,23 @@ export function timelinePublication(
     | undefined;
   return async (result: LinkedMediaResult) => {
     if (!delivery) {
-      const asset = await projection.importResource(result);
+      const asset = await projection.importResource({ ...result, fresh: true, identity: commandId });
       delivery = {
         payload: {
           itemId,
           editorId,
           asset,
           outputId,
+          ...(target ? { expectedOutputRevision: target.revision } : {}),
           title: result.title,
-          position: {
+          position: position ?? {
             x: item.position.x + item.width + 80,
             y: item.position.y,
           },
         },
         versions: [
           objectVersion("canvas_item", item),
+          ...(target ? [objectVersion("canvas_item", target)] : []),
           objectVersion("editor_document", editor),
           objectVersion("asset", {
             id: asset.assetId,
diff --git a/src/canvas/CanvasNodeView.tsx b/src/canvas/CanvasNodeView.tsx
index 5a22474f..7c8684b9 100644
--- a/src/canvas/CanvasNodeView.tsx
+++ b/src/canvas/CanvasNodeView.tsx
@@ -9,6 +9,7 @@ import { SubjectNodeCard } from "./SubjectNodeCard";
 import { CanvasIcon } from "./CanvasIcon";
 import { TooltipButton } from "./TooltipButton";
 import { GeneratingOverlay } from "./GeneratingOverlay";
+import { TimelinePendingVideo } from "./TimelineOutput";
 import { CanvasVideoPreview } from "./CanvasMediaPreview";
 import "./nodes.css";
 import {
@@ -18,7 +19,7 @@ import {
 import { useI18n } from "../i18n/I18nProvider.tsx";
 import type { MessageKey } from "../i18n/types.ts";
 
-export type CanvasFlowNode = Node<CanvasNodeData, CanvasNodeKind>;
+export type CanvasFlowNode = Node<CanvasNodeData & { timelineOutput?: Parameters<typeof TimelinePendingVideo>[0]["output"] }, CanvasNodeKind>;
 
 const kindNameKeys: Record<CanvasNodeKind, MessageKey> = {
   image: "canvasNodes.kind.image",
@@ -58,6 +59,8 @@ function CanvasNodeContents({ id, data, selected }: NodeProps<CanvasFlowNode>) {
     else actions?.select(id, event);
   };
 
+  if (data.timelineOutput) return <TimelinePendingVideo id={id} selected={selected} output={data.timelineOutput} />;
+
   return (
     <NodeFrame
       id={id}
diff --git a/src/canvas/GeneratingOverlay.tsx b/src/canvas/GeneratingOverlay.tsx
index b83b4caf..db12d7ee 100644
--- a/src/canvas/GeneratingOverlay.tsx
+++ b/src/canvas/GeneratingOverlay.tsx
@@ -86,12 +86,17 @@ function ProgressRing({ progress }: { progress: number }) {
 export function GeneratingOverlay({
   activity,
   hasAsset,
+  progress: actualProgress,
+  label,
 }: {
   activity: NodeGenerationActivity;
   hasAsset: boolean;
+  progress?: number;
+  label?: string;
 }) {
   const t = useT();
-  const progress = useProgress(activity);
+  const estimate = useProgress(activity);
+  const progress = actualProgress ?? estimate;
   return (
     <div
       className={`cw-generating${hasAsset ? " cw-generating-with-asset" : ""}`}
@@ -110,7 +115,7 @@ export function GeneratingOverlay({
       {progress !== null && <ProgressRing progress={progress} />}
       <div className="cw-generating-caption" role="status" aria-atomic="true">
         <span className="cw-generating-indicator" aria-hidden="true" />
-        <span>{t(GENERATION_LABELS[activity.phase])}</span>
+        <span>{label ?? t(GENERATION_LABELS[activity.phase])}</span>
         {activity.count > 1 && (
           <span className="cw-generating-count">
             {t("generation.overlay.tasks", { count: activity.count })}
diff --git a/src/canvas/NodeSelectionToolbar.tsx b/src/canvas/NodeSelectionToolbar.tsx
index 84cb0b87..cb352bd3 100644
--- a/src/canvas/NodeSelectionToolbar.tsx
+++ b/src/canvas/NodeSelectionToolbar.tsx
@@ -34,6 +34,8 @@ export interface NodeSelectionToolbarProps {
   presets?: readonly { value: string | number; label: string }[];
   onPreset?: (preset: string) => void;
   onEdit?: (mode: SelectionEditorMode) => void;
+  onOutput?: () => void;
+  outputBusy?: boolean;
   onCaptureFrame?: (position: "first" | "last") => void;
   onGridSplit?: (rows: number, columns: number) => void;
   onPreview?: () => void;
@@ -109,6 +111,8 @@ export function NodeSelectionToolbar({
   presets = [],
   onPreset,
   onEdit,
+  onOutput,
+  outputBusy = false,
   onCaptureFrame,
   onGridSplit,
   onPreview,
@@ -129,6 +133,9 @@ export function NodeSelectionToolbar({
   if (mediaKind && !hasMedia) return null;
 
   const editing: Action[] = [];
+  if (node.type === "timeline" && onOutput) {
+    editing.push({ id: "output", label: t("timeline.output.title"), icon: "arrowUp", run: onOutput, disabled: locked || outputBusy });
+  }
   const toolOption = (
     tool: CanvasToolId,
     label: string,
@@ -486,6 +493,7 @@ export function NodeSelectionToolbar({
                 aria-controls={
                   menuAction?.id === action.id ? menuId : undefined
                 }
+                shortcut={action.id === "output" ? (navigator.platform.includes("Mac") ? "⌘ Enter" : "Ctrl Enter") : undefined}
                 label={
                   action.disabled
                     ? t("canvas.selection.locked", { label: action.label })
diff --git a/src/canvas/TimelineOutput.tsx b/src/canvas/TimelineOutput.tsx
new file mode 100644
index 00000000..efc851d0
--- /dev/null
+++ b/src/canvas/TimelineOutput.tsx
@@ -0,0 +1,315 @@
+import { useEffect, useRef, useState } from "react";
+import { creationClient, CreationCommandError } from "../backend/creationClient.ts";
+import { CreationProjection } from "../backend/creationProjection.ts";
+import { timelinePublication, timelineOutputItem } from "../backend/timelinePublication.ts";
+import { errorMessage } from "../backend/api.ts";
+import { useT } from "../i18n/I18nProvider.tsx";
+import { NodeFrame } from "./NodeFrame";
+import { GeneratingOverlay } from "./GeneratingOverlay";
+import { timelineDuration } from "./timeline.ts";
+import { mediaBlobDataUrl } from "./localMediaRuntime.ts";
+import type { CanvasNode } from "./model.ts";
+import type { LinkedMediaResult } from "./linkedResults.ts";
+import "./timeline-output.css";
+
+export type TimelineOutputPreview = {
+  id: string;
+  title: string;
+  position: { x: number; y: number };
+};
+
+type OutputState = {
+  output: TimelineOutputPreview;
+  itemId: string;
+  phase: "rendering" | "publishing" | "failed" | "done";
+  progress: number;
+  error?: string;
+};
+
+/** Rendering stays in this browser; publication uses the existing versioned command. */
+export function useTimelineOutput(projectId: string, nodes: readonly CanvasNode[]) {
+  const t = useT();
+  const [state, setState] = useState<OutputState | null>(null);
+  const active = useRef<AbortController | null>(null);
+  const pending = useRef<{
+    itemId: string;
+    output: TimelineOutputPreview;
+    publish: (result: LinkedMediaResult) => Promise<boolean>;
+    result: LinkedMediaResult;
+  } | null>(null);
+  useEffect(
+    () => () => {
+      active.current?.abort();
+      active.current = null;
+      pending.current = null;
+    },
+    [projectId],
+  );
+  useEffect(() => {
+    setState(null);
+  }, [projectId]);
+
+  useEffect(() => {
+    if (!state || nodes.some((node) => node.id === state.itemId)) return;
+    active.current?.abort();
+    active.current = null;
+    pending.current = null;
+    setState(null);
+  }, [nodes, state?.itemId]);
+
+  const run = async (source: CanvasNode, save: () => Promise<boolean>) => {
+    const itemId = source.id;
+    if (
+      active.current ||
+      (pending.current && pending.current.itemId !== itemId)
+    )
+      return;
+    const existing = timelineOutputItem(creationClient(projectId).snapshot, itemId);
+    const output = pending.current?.output ?? {
+      id: existing?.id ?? crypto.randomUUID(),
+      title: t("timeline.action.renderTitle", { title: source.data.title }),
+      position: existing?.position ?? {
+        x: source.position.x,
+        y: source.position.y + source.height + 160,
+      },
+    };
+    const controller = new AbortController();
+    active.current = controller;
+    const owns = () => active.current === controller;
+    setState({
+      itemId,
+      output,
+      phase: pending.current ? "publishing" : "rendering",
+      progress: 0,
+    });
+    try {
+      const client = creationClient(projectId);
+      if (!pending.current) {
+        if (!(await save()))
+          throw new Error(t("canvas.workspace.error.timelineUnsaved"));
+        controller.signal.throwIfAborted();
+        const snapshot = await client.refresh();
+        const item = snapshot.canvasItems.find((entry) => entry.id === itemId);
+        if (!item || item.binding.role !== "editor")
+          throw new Error(t("errors.backend.timelineSourceMissing"));
+        const editorId = item.binding.objectRef.id;
+        const editor = snapshot.editorDocuments.find(
+          (entry) => entry.id === editorId,
+        );
+        if (!editor || editor.kind !== "timeline")
+          throw new Error(t("errors.backend.timelineSourceMissing"));
+        const publish = timelinePublication(
+          client,
+          snapshot,
+          itemId,
+          output.position,
+          output.id,
+        );
+        const { timeline } = await new CreationProjection(client).editorData(
+          editor,
+        );
+        controller.signal.throwIfAborted();
+        if (!timeline)
+          throw new Error(t("errors.backend.timelineSourceMissing"));
+        const { renderTimelineMp4 } = await import("./timelineRender.ts");
+        const blob = await renderTimelineMp4(
+          timeline,
+          controller.signal,
+          (progress) => {
+            if (owns())
+              setState({ itemId, output, phase: "rendering", progress });
+          },
+        );
+        const src = await mediaBlobDataUrl(blob, controller.signal);
+        controller.signal.throwIfAborted();
+        pending.current = {
+          itemId,
+          output,
+          publish,
+          result: {
+            kind: "video",
+            src,
+            mimeType: "video/mp4",
+            title: t("timeline.action.renderTitle", { title: item.title }),
+            media: {
+              width: timeline.width,
+              height: timeline.height,
+              durationSeconds: timelineDuration(timeline),
+            },
+          },
+        };
+      }
+      if (!owns()) return;
+      setState({ itemId, output, phase: "publishing", progress: 1 });
+      await pending.current.publish(pending.current.result);
+      if (!owns()) return;
+      pending.current = null;
+      setState({ itemId, output, phase: "done", progress: 1 });
+    } catch (reason) {
+      if (owns() && reason instanceof CreationCommandError) pending.current = null;
+      if (owns() && !controller.signal.aborted)
+        setState({
+          itemId,
+          output,
+          phase: "failed",
+          progress: 0,
+          error: errorMessage(reason),
+        });
+    } finally {
+      if (owns()) {
+        active.current = null;
+        if (controller.signal.aborted) setState(null);
+      }
+    }
+  };
+  return {
+    state,
+    busy: state?.phase === "rendering" || state?.phase === "publishing",
+    blockedItemId: pending.current?.itemId,
+    run,
+    cancel: () => {
+      if (state?.phase === "rendering") active.current?.abort();
+    },
+  };
+}
+
+export function TimelineOutputShortcut({
+  node,
+  state,
+  blocked,
+  onRun,
+}: {
+  node: CanvasNode;
+  state: OutputState | null;
+  blocked: boolean;
+  onRun: () => void;
+}) {
+  const timeline = node.data.timeline;
+  const current = state?.itemId === node.id ? state : null;
+  const running =
+    current?.phase === "rendering" || current?.phase === "publishing";
+  const disabled = blocked || !timeline || timelineDuration(timeline) <= 0;
+  useEffect(() => {
+    const keydown = (event: KeyboardEvent) => {
+      const target = event.target;
+      if (
+        event.defaultPrevented ||
+        event.isComposing ||
+        event.repeat ||
+        event.altKey ||
+        event.shiftKey ||
+        !(event.metaKey || event.ctrlKey) ||
+        event.key !== "Enter" ||
+        (target instanceof HTMLElement &&
+          target.closest(
+            'input,textarea,select,[contenteditable="true"],.cw-assistant-panel,.cw-settings-dialog',
+          ))
+      )
+        return;
+      if (
+        target instanceof HTMLElement &&
+        target.closest('[role="dialog"]')
+      )
+        return;
+      event.preventDefault();
+      event.stopPropagation();
+      if (!disabled && !running) onRun();
+    };
+    window.addEventListener("keydown", keydown, true);
+    return () => window.removeEventListener("keydown", keydown, true);
+  }, [disabled, running, onRun]);
+  return null;
+}
+
+export function TimelinePendingVideo({
+  id,
+  output,
+  selected,
+}: {
+  id: string;
+  selected: boolean;
+  output: {
+    title: string;
+    phase: OutputState["phase"];
+    progress: number;
+    error?: string;
+    onCancel: () => void;
+    onRetry: () => void;
+  };
+}) {
+  const t = useT();
+  const failed = output.phase === "failed";
+  return (
+    <div
+      className="cw-timeline-pending"
+      onDoubleClickCapture={(event) => {
+        event.preventDefault();
+        event.stopPropagation();
+      }}
+      onKeyDownCapture={(event) => {
+        if (
+          event.key === "F2" ||
+          (event.key === "Enter" &&
+            !(
+              event.target instanceof HTMLElement &&
+              event.target.closest("button")
+            ))
+        ) {
+          event.preventDefault();
+          event.stopPropagation();
+        }
+      }}
+      onContextMenuCapture={(event) => {
+        event.preventDefault();
+        event.stopPropagation();
+      }}
+    >
+      <NodeFrame
+        id={id}
+        kind="video"
+        title={output.title}
+        selected={selected}
+        empty
+        busy={!failed}
+      >
+        {!failed && (
+          <GeneratingOverlay
+            hasAsset={false}
+            activity={{
+              phase: output.phase === "publishing" ? "finishing" : "generating",
+              count: 1,
+            }}
+            progress={output.progress}
+            label={
+              output.phase === "publishing"
+                ? t("timeline.output.publishing")
+                : t("timeline.render.progress", {
+                    percent: Math.round(output.progress * 100),
+                  })
+            }
+          />
+        )}
+        {failed && (
+          <div className="cw-timeline-pending-error" role="alert">
+            {output.error}
+          </div>
+        )}
+        <button
+          type="button"
+          className="cw-timeline-pending-action nodrag nopan"
+          disabled={output.phase === "publishing"}
+          onPointerDown={(event) => event.stopPropagation()}
+          onClick={(event) => {
+            event.stopPropagation();
+            if (failed) output.onRetry();
+            else output.onCancel();
+          }}
+        >
+          {failed
+            ? t("timeline.output.retry")
+            : t("timeline.action.cancelRender")}
+        </button>
+      </NodeFrame>
+    </div>
+  );
+}
diff --git a/src/canvas/timeline-output.css b/src/canvas/timeline-output.css
new file mode 100644
index 00000000..0ea919a1
--- /dev/null
+++ b/src/canvas/timeline-output.css
@@ -0,0 +1,3 @@
+.cw-timeline-pending { width: 100%; height: 100%; }
+.cw-timeline-pending-action { position: absolute; z-index: 4; top: 12px; right: 12px; border: 1px solid #ffffff24; border-radius: 8px; background: #19191dcc; color: #eee; padding: 5px 10px; font: inherit; font-size: 11px; cursor: pointer; }
+.cw-timeline-pending-error { padding: 44px 18px 16px; color: #ffb1b1; font-size: 12px; overflow: auto; height: 100%; }
diff --git a/src/canvas/workspace/WorkspaceView.tsx b/src/canvas/workspace/WorkspaceView.tsx
index 1905161b..22abb12f 100644
--- a/src/canvas/workspace/WorkspaceView.tsx
+++ b/src/canvas/workspace/WorkspaceView.tsx
@@ -1,7 +1,8 @@
 import { Background, BackgroundVariant, MiniMap, SelectionMode, ViewportPortal } from "@xyflow/react";
 
 import "@xyflow/react/dist/style.css";
-import { Suspense, type CSSProperties } from "react";
+import { Suspense, useEffect, type CSSProperties } from "react";
+import { createNode } from "../model.ts";
 import { NodeVersionHistory } from "../NodeVersionHistory";
 
 import openDirectorLogoAnimation from "../../assets/open_director_logo_anim.gif";
@@ -80,6 +81,7 @@ import { subjectImportSelection, subjectTargetIdentity } from "../subjectLibrary
 import { TextNodeComposer } from "../TextNodeComposer";
 import "../themes.css";
 import { TimelineEditor } from "../TimelineEditor";
+import { TimelineOutputShortcut, useTimelineOutput } from "../TimelineOutput";
 import { CANVAS_TOOLS, createCanvasToolTask, initialToolParameters } from "../toolCatalog";
 
 import { translateToolText } from "../toolText.ts";
@@ -94,6 +96,7 @@ import { DirectorStage, IconButton, helpShortcuts, nodeTypes, edgeTypes, referen
 
 
 export function WorkspaceView({ rt }: { rt: WorkspaceRuntime }) {
+  const timelineOutput = useTimelineOutput(rt.doc.id, rt.doc.nodes);
   const {
     actionMedia,
     actionNode,
@@ -298,6 +301,39 @@ export function WorkspaceView({ rt }: { rt: WorkspaceRuntime }) {
   } = rt;
 
 
+  const outputState = timelineOutput.state;
+  const outputSource = outputState ? doc.nodes.find((node) => node.id === outputState.itemId) : undefined;
+  const existingOutput = outputState ? projected.nodes.find((node: { id: string }) => node.id === outputState.output.id) : undefined;
+  const pendingOutput = outputSource && outputState && outputState.phase !== "done"
+    ? {
+        id: outputState.output.id,
+        type: "video" as const,
+        position: outputState.output.position,
+        width: existingOutput?.width ?? 352, height: existingOutput?.height ?? 198,
+        style: { width: existingOutput?.width ?? 352, height: existingOutput?.height ?? 198 },
+        selectable: false, draggable: false, connectable: false, deletable: false, focusable: false,
+        data: {
+          kind: "video" as const, title: outputState.output.title,
+          timelineOutput: {
+            title: outputState.output.title, phase: outputState.phase,
+            progress: outputState.progress, error: outputState.error,
+            onCancel: timelineOutput.cancel,
+            onRetry: () => {
+              const source = doc.nodes.find((node) => node.id === outputState.itemId);
+              if (source) void timelineOutput.run(source, () => persist(doc, false));
+            },
+          },
+        },
+      }
+    : null;
+
+  useEffect(() => {
+    if (!outputSource || !outputState || outputState.phase === "done") return;
+    const output = createNode("video", outputState.output.position, { title: outputState.output.title });
+    output.id = outputState.output.id;
+    rt.revealCreatedNodes.current([output], doc.nodes.some((node) => node.id === output.id) ? doc.nodes : [...doc.nodes, output]);
+  }, [outputState?.output.id]);
+
   const workspace = (
     <div
       inert={!ready || switching}
@@ -443,11 +479,20 @@ export function WorkspaceView({ rt }: { rt: WorkspaceRuntime }) {
             gesture={pointerGesture}
             bypassSnapping={bypassSnapping}
             proOptions={{ hideAttribution: true }}
-            nodes={projected.nodes}
-            edges={projected.edges}
+            nodes={pendingOutput ? existingOutput ? projected.nodes.map((node: { id: string }) => node.id === pendingOutput.id ? pendingOutput : node) : [...projected.nodes, pendingOutput] : projected.nodes}
+            edges={pendingOutput && outputSource && outputState && !projected.edges.some((edge: { source: string; target: string }) => edge.source === outputState.itemId && edge.target === pendingOutput.id)
+              ? [...projected.edges, {
+                  id: `timeline-pending:${pendingOutput.id}`, source: outputState.itemId, target: pendingOutput.id,
+                  type: "reference", hidden: !showEdges, selectable: false, deletable: false,
+                  data: { state: "provenance", description: t("errors.refEvidence.editSource"),
+                    sourceBounds: { ...outputSource.position, width: outputSource.width, height: outputSource.height },
+                    targetBounds: { ...pendingOutput.position, width: pendingOutput.width, height: pendingOutput.height },
+                  },
+                }]
+              : projected.edges}
             nodeTypes={nodeTypes}
             edgeTypes={edgeTypes}
-            onNodesChange={onNodesChange}
+            onNodesChange={(changes) => onNodesChange(changes.filter((change) => !(pendingOutput && "id" in change && change.id === pendingOutput.id)))}
             onEdgesChange={(changes) => {
               for (const c of changes)
                 if (c.type === "select")
@@ -1249,6 +1294,8 @@ export function WorkspaceView({ rt }: { rt: WorkspaceRuntime }) {
             node={single}
             locked={lockedIds.has(single.id)}
             style={{ maxWidth: selectionPresentation.toolbarMaxWidth }}
+            onOutput={single.type === "timeline" ? () => void timelineOutput.run(single, () => persist(doc, false)) : undefined}
+            outputBusy={timelineOutput.busy || !!(timelineOutput.blockedItemId && timelineOutput.blockedItemId !== single.id)}
             onTool={openNodeAction}
             presets={toolCatalog.capabilities["image-presets"]?.fields
               ?.find((field) => field.key === "preset")?.options
@@ -1479,7 +1526,12 @@ export function WorkspaceView({ rt }: { rt: WorkspaceRuntime }) {
           </div>
         </>
       )}
-      {hasComposer && composerNode && (
+      {hasToolbar && single?.type === "timeline" && !lockedIds.has(single.id) && (
+        <TimelineOutputShortcut node={single} state={timelineOutput.state}
+          blocked={timelineOutput.busy && timelineOutput.state?.itemId !== single.id || !!(timelineOutput.blockedItemId && timelineOutput.blockedItemId !== single.id)}
+          onRun={() => void timelineOutput.run(single, () => persist(doc, false))} />
+      )}
+      {hasComposer && composerNode && composerNode.type !== "timeline" && (
         <>
           {composerExpanded && (
             <div
diff --git a/src/canvas/workspace/useWorkspaceInteraction.tsx b/src/canvas/workspace/useWorkspaceInteraction.tsx
index 157ce47a..ff61d7f4 100644
--- a/src/canvas/workspace/useWorkspaceInteraction.tsx
+++ b/src/canvas/workspace/useWorkspaceInteraction.tsx
@@ -672,6 +672,7 @@ export function useWorkspaceInteraction(rt: WorkspaceRuntime) {
           selected: selectedEdges.includes(e.id),
           hidden: !showEdges,
           selectable: !e.id.startsWith("tool-"),
+          deletable: e.intent !== "post_edit_result",
           data: {
             ...referencePresentation(doc, e),
             sourceBounds: (() => {
diff --git a/src/contracts/creation.schema.json b/src/contracts/creation.schema.json
index 5eb93551..a1e49831 100644
--- a/src/contracts/creation.schema.json
+++ b/src/contracts/creation.schema.json
@@ -12842,6 +12842,20 @@
             "title": "Outputid",
             "type": "string"
           },
+          "expectedOutputRevision": {
+            "anyOf": [
+              {
+                "minimum": 1,
+                "type": "integer"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "default": null,
+            "description": "Current output node revision when appending a rendered version.",
+            "title": "Expectedoutputrevision"
+          },
           "title": {
             "default": "合成视频",
             "description": "User-visible title.",
@@ -28439,6 +28453,20 @@
             "title": "Outputid",
             "type": "string"
           },
+          "expectedOutputRevision": {
+            "anyOf": [
+              {
+                "minimum": 1,
+                "type": "integer"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "default": null,
+            "description": "Current output node revision when appending a rendered version.",
+            "title": "Expectedoutputrevision"
+          },
           "title": {
             "default": "合成视频",
             "description": "User-visible title.",
diff --git a/src/contracts/generated.ts b/src/contracts/generated.ts
index 3e5a3096..2da40cb7 100644
--- a/src/contracts/generated.ts
+++ b/src/contracts/generated.ts
@@ -1351,6 +1351,7 @@ export interface TimelinePublishRenderInput extends ContractInput {
   readonly editorId: string;
   readonly asset: AssetRefInput;
   readonly outputId: string;
+  readonly expectedOutputRevision?: number | null;
   readonly title?: string;
   readonly position?: PointInput;
 }
@@ -2925,6 +2926,7 @@ export interface TimelinePublishRender extends Contract {
   readonly editorId: string;
   readonly asset: AssetRef;
   readonly outputId: string;
+  readonly expectedOutputRevision?: number | null;
   readonly title: string;
   readonly position: Point;
 }
diff --git a/src/i18n/messages/en-US/timeline.ts b/src/i18n/messages/en-US/timeline.ts
index e60da2f0..ac450eac 100644
--- a/src/i18n/messages/en-US/timeline.ts
+++ b/src/i18n/messages/en-US/timeline.ts
@@ -1,5 +1,11 @@
 /** Timeline editor, rendering, export and track labels. */
 export const timeline = {
+  "timeline.output.retry": "Retry output",
+  "timeline.output.title": "Output video",
+  "timeline.output.shortcut": "Output video · ⌘Enter / Ctrl+Enter",
+  "timeline.output.keepOpen": "Uses the saved timeline size and frame rate. Keep this page open while rendering.",
+  "timeline.output.publishing": "Adding video to canvas…",
+  "timeline.output.otherPending": "Finish or retry the other timeline output first.",
   "timeline.text.unsupportedExchange": "FCPXML and XML + media ZIP cannot retain text or fonts. Use an editable package to continue editing, or MP4 for the rendered video.",
   "timeline.player.sourceUnavailable": "The current media source is unavailable. Restore the source file and retry.",
   "timeline.package.export": "Export editable package",
diff --git a/src/i18n/messages/zh-CN/timeline.ts b/src/i18n/messages/zh-CN/timeline.ts
index 1528b1ef..a8ff7e70 100644
--- a/src/i18n/messages/zh-CN/timeline.ts
+++ b/src/i18n/messages/zh-CN/timeline.ts
@@ -1,5 +1,11 @@
 /** Timeline editor, rendering, export and track labels. */
 export const timeline = {
+  "timeline.output.retry": "重试输出",
+  "timeline.output.title": "输出视频",
+  "timeline.output.shortcut": "输出视频 · ⌘Enter / Ctrl+Enter",
+  "timeline.output.keepOpen": "沿用已保存时间线的画幅和帧率。输出期间请保持页面打开。",
+  "timeline.output.publishing": "正在将视频加入画布…",
+  "timeline.output.otherPending": "请先完成或重试另一条时间线的输出。",
   "timeline.text.unsupportedExchange": "FCPXML 和 XML + 素材 ZIP 无法保留文字或字体。请使用可编辑包继续编辑，或使用 MP4 导出渲染视频。",
   "timeline.player.sourceUnavailable": "当前媒体来源不可用，请恢复素材文件后重试。",
   "timeline.package.export": "导出可编辑包",
diff --git a/tests/browser/manifest.json b/tests/browser/manifest.json
index 19d52300..1cfd1f52 100644
--- a/tests/browser/manifest.json
+++ b/tests/browser/manifest.json
@@ -168,10 +168,7 @@
     {
       "file": "creation_history.mjs",
       "previewSafe": true,
-      "lanes": [
-        "extended",
-        "production"
-      ]
+      "lanes": ["extended", "production"]
     },
     {
       "file": "creation_journey.mjs",
@@ -190,10 +187,7 @@
     {
       "file": "default_entry.mjs",
       "previewSafe": true,
-      "lanes": [
-        "extended",
-        "production"
-      ]
+      "lanes": ["extended", "production"]
     },
     {
       "file": "double_shift_chat.mjs",
@@ -221,10 +215,7 @@
     {
       "file": "first_last_frame_connections.mjs",
       "previewSafe": true,
-      "lanes": [
-        "extended",
-        "production"
-      ]
+      "lanes": ["extended", "production"]
     },
     {
       "file": "generation_feedback.mjs",
@@ -343,10 +334,7 @@
     {
       "file": "paste_undo.mjs",
       "previewSafe": true,
-      "lanes": [
-        "extended",
-        "production"
-      ]
+      "lanes": ["extended", "production"]
     },
     {
       "file": "project_list_overflow.mjs",
@@ -503,6 +491,14 @@
       "file": "zhipu_real.mjs",
       "helper": true,
       "note": "Manual acceptance against the real Zhipu BigModel service; needs ZHIPU_API_KEY and incurs charges, so no lane runs it."
+    },
+    {
+      "file": "timeline_node_output.mjs",
+      "lanes": [
+        "gate"
+      ],
+      "previewSafe": false,
+      "note": "Canvas timeline output button and shortcut publish real MP4 results in both locales without opening the editor."
     }
   ]
 }
diff --git a/tests/browser/timeline_node_output.mjs b/tests/browser/timeline_node_output.mjs
new file mode 100644
index 00000000..8e669621
--- /dev/null
+++ b/tests/browser/timeline_node_output.mjs
@@ -0,0 +1,245 @@
+/** Direct canvas timeline output uses real browser MP4 rendering and versioned publication. */
+import assert from "node:assert/strict";
+import { launchBrowser } from "./engine.mjs";
+const base = process.env.CREATION_WEB_URL ?? "http://127.0.0.1:5179";
+const api = process.env.CREATION_API_URL ?? base;
+const headers = { "X-OpenDirector-Request": "1" };
+const health = await fetch(api + "/api/creation-test-health", { headers }).then((r) => r.json());
+assert.equal(health.isolated, true);
+const browser = await launchBrowser();
+try {
+  const page = await browser.newPage({ viewport: { width: 1500, height: 1000 } });
+  page.setDefaultTimeout(20000);
+  const errors = [];
+  page.on("pageerror", (error) => { errors.push(error.message); console.error(error.message); });
+  await page.addInitScript(() => {
+    localStorage.setItem("opendirector.modelSetup.v1", "dismissed");
+    localStorage.setItem("opendirector.locale.v1", "en-US");
+  });
+  const bootstrap = (url) => url.origin === new URL(base).origin && url.pathname === "/";
+  await page.route(bootstrap, (route) => route.fulfill({ contentType: "text/html", body: "<html></html>" }));
+  await page.goto(base + "/");
+  const fixture = await page.evaluate(async () => {
+    const { createDocument, createNode } = await import("/src/canvas/model.ts");
+    const { addTimelineClip } = await import("/src/canvas/timeline.ts");
+    const { importWorkspaceDocument } = await import("/src/backend/workspace.ts");
+    const canvas = document.createElement("canvas");
+    canvas.width = 160; canvas.height = 96;
+    const ctx = canvas.getContext("2d");
+    ctx.fillStyle = "#318175"; ctx.fillRect(0, 0, 160, 96);
+    const node = createNode("timeline", { x: 150, y: 150 }, { title: "Direct timeline output" });
+    node.data.timeline.width = 160; node.data.timeline.height = 96; node.data.timeline.fps = 24;
+    node.data.timeline = addTimelineClip(node.data.timeline, {
+      id: crypto.randomUUID(), kind: "image", title: "Green frame", src: canvas.toDataURL(), width: 160, height: 96,
+    });
+    node.data.timeline.tracks[0].clips[0].outPoint = 0.5;
+    const saved = await importWorkspaceDocument({ ...createDocument("Timeline output " + crypto.randomUUID().slice(0, 8)), nodes: [node] });
+    (await import("/src/backend/creationClient.ts")).creationClient(saved.id).close();
+    await (await import("/src/backend/projects.ts")).releaseBackendProject();
+    return { id: saved.id, item: node.id };
+  });
+  await page.unroute(bootstrap);
+  const snapshot = () => fetch(`${api}/api/creation/projects/${fixture.id}`, { headers }).then((r) => r.json());
+  await page.goto(`${base}/ai-tool/ai-canvas/${fixture.id}`);
+  await page.getByText("Saved on this device", { exact: true }).waitFor();
+  const select = async () => {
+    await page.locator(".cw-workspace").focus();
+    await page.keyboard.press("Shift+1");
+    await page.locator(`.react-flow__node[data-id="${fixture.item}"]`).click();
+  };
+  await select();
+  const panel = page.locator(".cw-selection-toolbar");
+  await panel.waitFor();
+  assert.equal(await page.locator(".cw-composer-dock").count(), 0);
+  let releaseFirst;
+  const firstGate = new Promise((resolve) => { releaseFirst = resolve; });
+  let firstPublish = true;
+  await page.route("**/commands", async (route) => {
+    if (route.request().postDataJSON().type === "timeline.publishRender" && firstPublish) {
+      firstPublish = false;
+      await firstGate;
+    }
+    return route.continue();
+  });
+  await panel.getByRole("button", { name: "Output video", exact: true }).dblclick();
+  const pending = page.locator('.react-flow__node-video').filter({ has: page.locator('.cw-node-generating') });
+  await pending.waitFor();
+  const pendingId = await pending.getAttribute("data-id");
+  assert.equal(await pending.locator('.cw-generating').count(), 1);
+  await page.locator(`.react-flow__edge[data-id="timeline-pending:${pendingId}"]`).waitFor();
+  assert.equal(await panel.locator('progress').count(), 0);
+  await page.waitForTimeout(400);
+  await page.screenshot({ path: "/tmp/opendirector-timeline-pending.png" });
+  releaseFirst();
+  await page.unrouteAll({ behavior: "wait" });
+  await page.locator(`.react-flow__node[data-id="${pendingId}"] video`).waitFor();
+  let saved = await snapshot();
+  const videos = saved.canvasItems.filter((item) => item.kind === "video");
+  await page.locator(`.react-flow__edge[data-id^="publication:${pendingId}:"]`).waitFor();
+  assert.equal(videos[0].id, pendingId, "pending identity is published in place");
+  assert.equal(videos.length, 1, "double-click submits one output");
+  const asset = saved.assets.find((asset) => asset.id === videos[0].binding.objectRef.assetId);
+  assert.equal(asset.provenance.source, "rendered");
+  assert.equal(asset.metadata.width, 160);
+  assert.equal(asset.metadata.height, 96);
+  assert.ok(Math.abs(asset.metadata.durationSeconds - 0.5) < 0.1);
+  assert.ok(videos[0].position.y > saved.canvasItems.find((item) => item.id === fixture.item).position.y);
+  assert.equal(await page.locator(".cw-timeline-dialog").count(), 0);
+  await page.getByRole("button", { name: "中文", exact: true }).click();
+  await select();
+  const chinese = page.locator(".cw-selection-toolbar");
+  await chinese.waitFor();
+  // Cancel before rendering completes; no output should be published.
+  await chinese.getByRole("button", { name: "输出视频", exact: true }).click();
+  await page.locator(".cw-timeline-pending").getByRole("button", { name: "取消合成", exact: true }).click();
+  await page.locator(".cw-timeline-pending").waitFor({ state: "hidden" });
+  assert.equal((await snapshot()).canvasItems.filter((item) => item.kind === "video").length, 1);
+  const publicationIds = [];
+  let loseReply = true;
+  await page.route("**/commands", async (route) => {
+    const value = route.request().postDataJSON();
+    if (value.type !== "timeline.publishRender") return route.continue();
+    publicationIds.push(value.commandId);
+    if (loseReply) {
+      loseReply = false;
+      return route.abort();
+    }
+    return route.continue();
+  });
+  await page.locator(`.react-flow__node[data-id="${fixture.item}"]`).focus();
+  await page.keyboard.press("Meta+Enter");
+  await page.locator(".cw-timeline-pending").getByRole("alert").waitFor().catch(async (error) => { console.error(await page.locator("body").innerText()); throw error; });
+  const assetsBeforeRetry = (await snapshot()).assets.length;
+  const retryId = await page.locator('.react-flow__node-video').filter({ has: page.locator('.cw-timeline-pending') }).getAttribute('data-id');
+  await page.getByRole("button", { name: "重试输出", exact: true }).click();
+  await page.locator(`.react-flow__node[data-id="${retryId}"] video`).waitFor();
+  saved = await snapshot();
+  assert.equal(saved.canvasItems.filter((item) => item.kind === "video").length, 1);
+  assert.equal(saved.editorDocuments.length, 1);
+  assert.equal(saved.assets.length, assetsBeforeRetry, "retry reuses the rendered asset");
+  assert.ok(publicationIds.length >= 2);
+  assert.equal(new Set(publicationIds).size, 1, "retry replays the same publication");
+  assert.equal(await page.locator(".cw-timeline-dialog").count(), 0);
+  await select();
+  // The focused output control must support the Windows/Linux modifier too.
+  await chinese.getByRole("button", { name: "输出视频", exact: true }).focus();
+  const published = page.waitForResponse((response) => response.request().method() === "POST" && response.request().url().endsWith("/commands") && response.request().postDataJSON().type === "timeline.publishRender");
+  await page.keyboard.press("Control+Enter");
+  const publishedReceipt = await (await published).json();
+  assert.equal(publishedReceipt.status, "applied", JSON.stringify(publishedReceipt));
+  await page.locator(".cw-timeline-pending").waitFor({ state: "hidden" });
+  await page.locator(".cw-workspace").focus();
+  await page.keyboard.press("Shift+1");
+  assert.equal((await snapshot()).canvasItems.filter((item) => item.kind === "video").length, 1);
+  await page.locator(`.react-flow__node[data-id="${pendingId}"] video`).waitFor();
+  await page.locator(`.react-flow__node[data-id="${pendingId}"] .cw-node-version-button`).click();
+  await page.getByRole("radio").nth(2).waitFor();
+  assert.equal(await page.getByRole("radio").count(), 3);
+  await page.locator(`[data-version-asset-id="${asset.id}"]`).click();
+  const applied = page.waitForResponse((response) => response.request().method() === "POST" && response.request().url().endsWith("/commands") && response.request().postDataJSON().type === "canvas.applyVersion");
+  await page.getByRole("button", { name: "应用到画布", exact: true }).click();
+  assert.equal((await applied).status(), 200);
+  const restored = (await snapshot()).canvasItems.find((item) => item.id === pendingId);
+  assert.equal(restored.binding.objectRef.assetId, asset.id);
+  assert.deepEqual(errors, []);
+  await page.evaluate(async (id) => {
+    (await import("/src/backend/creationClient.ts")).creationClient(id).close();
+    await (await import("/src/backend/projects.ts")).releaseBackendProject();
+  }, fixture.id);
+  await page.reload();
+  await page.getByText("Saved on this device", { exact: true }).waitFor();
+  await page.locator(`.react-flow__edge[data-id^="publication:${pendingId}:"]`).waitFor();
+  assert.equal((await snapshot()).canvasItems.filter((item) => item.kind === "video").length, 1);
+  await page.screenshot({ path: process.env.TIMELINE_OUTPUT_SCREENSHOT ?? "/tmp/opendirector-timeline-output.png" });
+  // Removing a source during publication must clear its transient output.
+  const disappearingSource = await page.evaluate(async ({ id, item }) => {
+    const { creationClient } = await import("/src/backend/creationClient.ts");
+    const client = creationClient(id);
+    const source = client.snapshot.canvasItems.find((entry) => entry.id === item);
+    const copy = { ...source, id: crypto.randomUUID(), position: { x: 700, y: 150 } };
+    await client.command("canvas.show", { item: copy }, []);
+    return copy.id;
+  }, fixture);
+  await page.locator(".cw-workspace").focus();
+  await page.keyboard.press("Shift+1");
+  await page.locator(`.react-flow__node[data-id="${disappearingSource}"]`).click();
+  let releaseRemoved;
+  const removedGate = new Promise((resolve) => { releaseRemoved = resolve; });
+  const removedSubmitted = page.waitForRequest((request) => request.method() === "POST" &&
+    request.url().endsWith("/commands") && request.postDataJSON().type === "timeline.publishRender" &&
+    request.postDataJSON().payload.itemId === disappearingSource);
+  await page.unrouteAll({ behavior: "wait" });
+  await page.route("**/commands", async (route) => {
+    const command = route.request().postDataJSON();
+    if (command.type === "timeline.publishRender" && command.payload.itemId === disappearingSource) {
+      await removedGate;
+    }
+    return route.continue();
+  });
+  await page.locator(".cw-selection-toolbar").getByRole("button", { name: "Output video", exact: true }).click();
+  await removedSubmitted;
+  await page.locator(".cw-timeline-pending").waitFor();
+  const hideSource = async (visible) => page.evaluate(async ({ id, itemId, visible }) => {
+    const { creationClient, objectVersion } = await import("/src/backend/creationClient.ts");
+    const client = creationClient(id);
+    const source = client.snapshot.canvasItems.find((entry) => entry.id === itemId);
+    // Simulate another writer while this browser waits for publication.
+    const { storageRequest, json } = await import("/src/backend/api.ts");
+    const receipt = await storageRequest(`/creation/projects/${id}/commands`, json("POST", {
+      commandId: crypto.randomUUID(), projectId: id,
+      type: visible ? "canvas.show" : "canvas.hide",
+      payload: visible ? { item: source } : { itemId },
+      expectedVersions: [objectVersion("canvas_item", source)],
+    }));
+    if (receipt.status !== "applied") throw new Error(JSON.stringify(receipt));
+    await client.refresh();
+  }, { id: fixture.id, itemId: disappearingSource, visible });
+  await hideSource(false);
+  await page.locator(".cw-timeline-pending").waitFor({ state: "hidden" });
+  assert.equal(await page.locator(".cw-workspace").count(), 1);
+  assert.equal(await page.locator('.react-flow__edge[data-id^="timeline-pending:"]').count(), 0);
+  const removedReply = page.waitForResponse((response) => response.request().method() === "POST" &&
+    response.request().url().endsWith("/commands") &&
+    response.request().postDataJSON().type === "timeline.publishRender");
+  releaseRemoved();
+  assert.equal((await (await removedReply).json()).status, "rejected");
+  assert.equal((await snapshot()).canvasItems.filter((item) => item.kind === "video").length, 1);
+  await page.unrouteAll({ behavior: "wait" });
+  await hideSource(true);
+  await page.locator(".cw-workspace").focus();
+  await page.keyboard.press("Shift+1");
+  await page.locator(`.react-flow__node[data-id="${disappearingSource}"]`).click();
+  const recoveredOutput = page.waitForResponse((response) => response.request().method() === "POST" &&
+    response.request().url().endsWith("/commands") && response.request().postDataJSON().type === "timeline.publishRender");
+  await page.locator(".cw-selection-toolbar").getByRole("button", { name: "Output video", exact: true }).click();
+  const recoveredReply = await recoveredOutput;
+  assert.equal((await recoveredReply.json()).status, "applied");
+  await page.locator(".cw-timeline-pending").waitFor({ state: "hidden" });
+  assert.equal((await snapshot()).canvasItems.filter((item) => item.kind === "video").length, 2);
+  assert.deepEqual(errors, []);
+  const identicalOutputs = await page.evaluate(async ({ id, item }) => {
+    const { creationClient } = await import("/src/backend/creationClient.ts");
+    const { timelinePublication, timelineOutputItem } = await import("/src/backend/timelinePublication.ts");
+    const { mediaBlobDataUrl } = await import("/src/canvas/localMediaRuntime.ts");
+    const client = creationClient(id);
+    const output = timelineOutputItem(client.snapshot, item);
+    const originalId = output.binding.objectRef.assetId;
+    const src = await mediaBlobDataUrl(await client.blob(originalId), new AbortController().signal);
+    client.rememberSource(src, originalId);
+    const result = { kind: "video", src, title: "Identical render", mimeType: "video/mp4" };
+    const assets = [];
+    for (let index = 0; index < 2; index++) {
+      await timelinePublication(client, client.snapshot, item)(result);
+      const current = timelineOutputItem(client.snapshot, item);
+      assets.push(client.snapshot.assets.find((asset) => asset.id === current.binding.objectRef.assetId));
+    }
+    return assets.map(({ id, fingerprint }) => ({ id, fingerprint }));
+  }, fixture);
+  assert.notEqual(identicalOutputs[0].id, identicalOutputs[1].id);
+  assert.equal(identicalOutputs[0].fingerprint, identicalOutputs[1].fingerprint);
+  assert.equal((await snapshot()).canvasItems.filter((item) => item.kind === "video").length, 2);
+  assert.deepEqual(errors, []);
+  console.log(JSON.stringify({ isolated: true, realMp4: true, button: true, shortcut: true, bilingual: true, oneOutputThreeVersions: true, provenanceEdge: true, versionRestored: true, removedSourceCleared: true, identicalRenderVersions: true, editorOpened: false }));
+} finally {
+  await browser.close();
+}
diff --git a/tests/test_creation_timeline_render.py b/tests/test_creation_timeline_render.py
index 27e7600f..68a32b6b 100644
--- a/tests/test_creation_timeline_render.py
+++ b/tests/test_creation_timeline_render.py
@@ -13,8 +13,8 @@
 from test_creation_canvas_service import project, send, ver
 
 
-def clip(seconds=2, size='64x64'):
-    return subprocess.run(['ffmpeg', '-v', 'error', '-f', 'lavfi', '-i', f'color=blue:s={size}:r=24',
+def clip(seconds=2, size='64x64', color='blue'):
+    return subprocess.run(['ffmpeg', '-v', 'error', '-f', 'lavfi', '-i', f'color={color}:s={size}:r=24',
         '-t', str(seconds), '-threads', '1', '-c:v', 'libx264', '-pix_fmt', 'yuv420p',
         '-movflags', 'frag_keyframe+empty_moov', '-f', 'mp4', 'pipe:1'], check=True, capture_output=True).stdout
 
@@ -295,3 +295,62 @@ def test_atomic_text_save_and_publication_is_rejected_before_it_can_change_rende
         ])
     assert store.snapshot(pid) == before
     assert next(a for a in before.assets if a.id == output.id).provenance.source == 'upload'
+
+
+@pytest.mark.parametrize('actor', ['ui', 'agent'])
+def test_repeat_render_keeps_output_identity_and_versions(project, actor):
+    from opendirector.application.creation_history import CreationHistory
+    from opendirector.domain.creation.commands import parse_command
+    store, pid, session = project
+    _, first, versions, payload = prepared(project)
+    assert send(store, pid, 'timeline.publishRender', session=session, versions=versions, **payload).status == 'applied'
+    before = store.snapshot(pid)
+    target = before.canvasItems[-1]
+    record = CreationToolAssets(store).import_file(pid, uuid4(), 'second-render.mp4', clip(color='red'), session,
+                                                  provenance=AssetProvenance(source='upload'))
+    second = CreationToolAssets(store).assets.get(pid, record['id'])
+    source, editor = before.canvasItems[0], before.editorDocuments[0]
+    command = parse_command(dict(commandId=uuid4(), projectId=pid, type='timeline.publishRender',
+        expectedVersions=[ver('canvas_item', source), ver('editor_document', editor), ver('asset', second), ver('canvas_item', target)],
+        payload={**payload, 'asset': asset_ref(second), 'expectedOutputRevision': target.revision}))
+    receipt = store.execute(command, session=session, source=actor)
+    assert receipt.status == 'applied', receipt
+    snapshot = store.snapshot(pid)
+    outputs = [item for item in snapshot.canvasItems if item.kind == 'video']
+    assert len(outputs) == 1
+    assert outputs[0].id == target.id
+    assert outputs[0].binding.objectRef.assetId == second.id
+    assert outputs[0].revision == target.revision + 1
+    assert outputs[0].position == target.position
+    assert snapshot.assets[-1].provenance.sourceItemId == source.id
+    history = CreationHistory(store)
+    listing = history.node_versions(pid, target.id)
+    assert {row['asset'].id for row in listing['versions']} == {first.id, second.id}
+    assert CreationProjects(LocalProjects(store.local.repository)).snapshot(pid) == snapshot
+    assert store.execute(command, session=session, source=actor) == receipt
+
+    restored = send(store, pid, 'canvas.applyVersion', session=session,
+                    versions=listing['expectedVersions'], itemId=target.id, asset=asset_ref(first))
+    assert restored.status == 'applied', restored
+    assert store.snapshot(pid).canvasItems[-1].binding.objectRef.assetId == first.id
+
+
+@pytest.mark.parametrize('change', ['locked', 'stale'])
+def test_repeat_render_respects_output_lock_and_revision(project, change):
+    store, pid, session = project
+    _, _, versions, payload = prepared(project)
+    assert send(store, pid, 'timeline.publishRender', session=session, versions=versions, **payload).status == 'applied'
+    target = store.snapshot(pid).canvasItems[-1]
+    record = CreationToolAssets(store).import_file(pid, uuid4(), 'next-render.mp4', clip(color='red'), session,
+                                                  provenance=AssetProvenance(source='upload'))
+    output = CreationToolAssets(store).assets.get(pid, record['id'])
+    assert send(store, pid, 'canvas.update', session=session, versions=[ver('canvas_item', target)],
+                itemId=target.id, **({'locked': True} if change == 'locked' else {'title': 'Renamed'})).status == 'applied'
+    snapshot = store.snapshot(pid)
+    expected = snapshot.canvasItems[-1] if change == 'locked' else target
+    receipt = send(store, pid, 'timeline.publishRender', session=session,
+        versions=[ver('canvas_item', snapshot.canvasItems[0]), ver('editor_document', snapshot.editorDocuments[0]),
+                  ver('asset', output), ver('canvas_item', expected)],
+        **{**payload, 'asset': asset_ref(output), 'expectedOutputRevision': expected.revision})
+    assert receipt.status == 'rejected'
+    assert store.snapshot(pid) == snapshot
diff --git a/tests/timelinePublication.test.ts b/tests/timelinePublication.test.ts
index 07f01935..61802947 100644
--- a/tests/timelinePublication.test.ts
+++ b/tests/timelinePublication.test.ts
@@ -2,6 +2,7 @@ import assert from "node:assert/strict";
 import { readFileSync } from "node:fs";
 import test from "node:test";
 import {
+  assetReference,
   CreationClient,
   CreationCommandError,
 } from "../src/backend/creationClient.ts";
@@ -33,6 +34,18 @@ for (const outcome of ["unknown", "conflict"] as const) {
     const client = new CreationClient(snapshot.project.id);
     client.install(snapshot);
     client.assetForSource = () => output;
+    const imported = { ...output, id: crypto.randomUUID() };
+    const rendered = new Blob(["rendered video"], { type: "video/mp4" });
+    let imports = 0;
+    client.blob = async (assetId) => {
+      assert.equal(assetId, output.id);
+      return rendered;
+    };
+    client.importBlob = async (blob) => {
+      assert.equal(blob, rendered);
+      imports++;
+      return assetReference(imported);
+    };
     const publish = timelinePublication(client, snapshot, item.id);
     const commands: Parameters<CreationClient["command"]>[] = [];
     client.command = async (...args) => {
@@ -87,9 +100,10 @@ for (const outcome of ["unknown", "conflict"] as const) {
       await assert.rejects(publish(result), /Source changed/);
     else assert.equal(await publish(result), true);
     assert.deepEqual(commands[1], commands[0]);
+    assert.equal(imports, 1, "publication retries reuse the fresh render import");
     const [type, payload, versions, , commandId] = commands[0]!;
     assert.equal(type, "timeline.publishRender");
-    assert.ok("asset" in payload && payload.asset.assetId === output.id);
+    assert.ok("asset" in payload && payload.asset.assetId === imported.id);
     assert.equal(
       versions!.find((entry) => entry.objectType === "editor_document")!
         .revision,