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_idconsistent 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
afterwhen you need an execution dependency, but provide the actual save data througharguments. Theaftervalue 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_jsonafter 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.lockfile 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
argumentsbefore 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.
