Save 4 hours! We auto-setup your workflow! Free!

Drop your workflow.json — we handle every dependency, custom node, and model. Just open the link and run.

Auto-Setup Workflow Json (Free) Now!
ComfyUI > Nodes > OpenKatana > OpenKatana · Save timeline

ComfyUI Node: OpenKatana · Save timeline

Class Name

OpenKatana_save_timeline

Category
OpenKatana/Tools
Author
rk0neki (Account age: 235days)
Extension
OpenKatana
Latest Updated
2026-11-05
Github Stars
0.05K

How to Install OpenKatana

Install this extension via the ComfyUI Manager by searching for OpenKatana
  • 1. Click the Manager button in the main menu
  • 2. Select Custom Nodes Manager button
  • 3. Enter OpenKatana in the search bar
After installation, click the Restart button to restart ComfyUI. Then, manually refresh your browser to clear the cache and access the updated list of nodes.

Visit ComfyUI Online for ready-to-use ComfyUI environment

  • Free trial available
  • 16GB VRAM to 80GB VRAM GPU machines
  • 400+ preloaded models/nodes
  • Freedom to upload custom models/nodes
  • 200+ ready-to-run workflows
  • 100% private workspace with up to 200GB storage
  • Dedicated Support

Run ComfyUI Online

OpenKatana · Save timeline Description

Saves edited OpenKatana timelines with revision checks, history backups, and save locking.

OpenKatana · Save timeline:

OpenKatana_save_timeline saves an edited timeline as an OpenKatana project’s current timeline, allowing you to preserve your editing work for subsequent project operations. Before saving, OpenKatana validates the timeline against the project and checks that the project has not changed since the edit was prepared. This revision check helps prevent an older edit from accidentally overwriting newer work. When an existing timeline is replaced, the save routine first writes that previous timeline to the project’s history. A temporary save lock also prevents overlapping saves from writing at the same time. This node is for preserving an edit, not rendering a finished video; it is especially useful after creating or adjusting a timeline that has been validated but not yet saved.

OpenKatana · Save timeline Input Parameters:

project_id

A required STRING identifying the OpenKatana project to which the save operation applies. Use the identifier of the project whose assets and timeline you are editing so that the edit is saved in the correct place and validated against the appropriate project. Keep this value consistent across the nodes involved in preparing and saving your edit. The supplied interface does not specify a default value, allowed identifier format, list of options, or minimum or maximum length.

arguments

A required STRING supplying the save tool’s arguments through OpenKatana’s argument-processing layer. The underlying save routine requires an edited timeline and an expected project revision: the timeline describes the edit to preserve, while the revision identifies the project version against which that edit was prepared. The routine validates the edit and rejects the save if the expected revision no longer matches the project’s current revision. The provided excerpts do not include the save tool’s argument schema or the implementation of its argument parser, so the exact JSON field names, nesting, and required serialization cannot be confirmed here; use the tool’s exposed signature or argument schema rather than inventing a payload. No default value, size limit, or selectable options are shown in the supplied interface.

after

An optional STRING that can serve as a workflow dependency when connected to an earlier node’s string output, helping you arrange for an earlier operation to execute before this node. Its default in the execution method is None. In the supplied execution code, this value is accepted but is not passed to argument construction or the tool invocation, so it does not provide the timeline, select a revision, or change the save contents. No minimum, maximum, or restricted set of values is specified.

OpenKatana · Save timeline Output Parameters:

result_json

A STRING containing the save tool’s response as serialized JSON through the node’s response wrapper. The underlying project-save routine returns a revision value calculated from the saved timeline; this identifies the saved timeline state and is important when preparing later revision-guarded edits. The response wrapper’s implementation is not provided, so the exact placement of that value and any additional response fields cannot be confirmed from these excerpts. Treat this output as the operation’s response rather than as a rendered video, preview image, or standalone timeline file, and inspect it to verify the outcome before continuing with later project operations.

OpenKatana · Save timeline Usage Tips:

  • Save after reviewing a generated or modified timeline. The provided timeline-building context explicitly distinguishes a validated timeline from one that has been saved to the project.
  • Use the current project revision when preparing your save arguments. If another operation changes the project in the meantime, reload the current state and reconcile your edits before saving again.
  • Keep project_id consistent throughout your editing workflow. A timeline prepared using one project’s assets should not be casually redirected to another project.
  • Check the save tool’s actual argument signature before filling arguments. The interface exposes a general string input rather than separate timeline and revision sockets, and the supplied code does not establish the exact payload structure.
  • Connect a preceding node’s string output to after when you need an execution dependency, but provide the actual save data through arguments. The after value is not read as save content.
  • Run saves to the same project sequentially rather than in parallel. The project uses a lock to prevent simultaneous writes, so overlapping saves can fail instead of being combined.
  • Inspect result_json after saving and retain the returned revision information for subsequent edits. Render separately when you want a finished video; saving the timeline does not perform rendering.

OpenKatana · Save timeline Common Errors and Solutions:

Project changed since it was opened. Reload before saving

  • Explanation: The expected revision supplied for the save does not match the project’s current revision. OpenKatana stops the save to protect changes made after your edit was prepared.
  • Solution: Reload the project’s latest timeline and revision, compare or reapply your intended changes, and submit the reconciled edit using that current revision. Do not simply replace the revision without checking what changed.

Timeline save is already in progress; inspect a stale lock before retrying

  • Explanation: The save routine could not create its exclusive timeline.json.lock file because that file already exists. Another save may still be running, or an interrupted operation may have left a stale lock.
  • Solution: Wait for any active save to finish and retry. If no save is running, inspect the project’s lock file and remove it only after confirming it is stale; deleting an active lock can undermine the protection against simultaneous writes.

unexpected inputs: …

  • Explanation: The node execution method received additional named fields that are not declared in the tool’s required or optional typed inputs. The actual error lists the unexpected field names.
  • Solution: Use the node’s declared interface and remove unsupported extra fields from custom integrations or modified workflows. Do not add separate save-related sockets unless the loaded node explicitly declares them.

Timeline validation failure — exact message depends on the validator

  • Explanation: The save routine validates the edited timeline against the project before writing it. An edit that does not satisfy the timeline contract cannot be saved; the provided excerpts do not include the validator’s individual error messages or complete rules.
  • Solution: Read the specific validation detail returned by your installation, correct the indicated timeline data, and retry. Prefer editing a timeline produced by OpenKatana’s validated timeline tools rather than constructing an unverified structure from scratch.

Argument parsing or argument contract failure — exact message not provided

  • Explanation: The node processes arguments before invoking the save tool. Incorrect serialization, missing required save information, or an unsupported payload structure may prevent the call from reaching the save routine. The parser and save tool schema are not included in the supplied code.
  • Solution: Check the installed tool’s signature or schema and supply the edited timeline and expected revision in the documented format. If that format is JSON, verify that it is valid JSON and avoid assuming that the underlying Python function’s parameter names necessarily match the tool’s public argument names.

Filesystem write failure — exact message depends on the operating system

  • Explanation: Saving requires filesystem access to create a lock, preserve an existing timeline in the project’s history, and write timeline.json. Insufficient permissions, unavailable storage, or missing project directories can interrupt these operations.
  • Solution: Confirm that the project location is accessible and writable by the ComfyUI process, check available disk space, and verify that the project was initialized correctly. After resolving the storage issue, inspect the project state before retrying rather than assuming the save completed.

OpenKatana · Save timeline Related Nodes

Go back to the extension to check out more related nodes.
OpenKatana
RunComfy
Copyright 2025 RunComfy. All Rights Reserved.

RunComfy is the premier ComfyUI platform, offering ComfyUI online environment and services, along with ComfyUI workflows featuring stunning visuals. RunComfy also provides AI Models, enabling artists to harness the latest AI tools to create incredible art.

OpenKatana · Save timeline