| import {app} from "/scripts/app.js"; |
| import {api} from "/scripts/api.js"; |
| import { |
| CHECKPOINT_STAGES, |
| checkpointStageVariants, |
| checkpointVariantLatentStatus, |
| checkpointBranchRows, |
| checkpointChapterBranchRows, |
| checkpointOutputBranchTip, |
| checkpointActivationMode, |
| checkpointDeletionTitle, |
| checkpointDependencyText, |
| checkpointRevisionKey, |
| checkpointRevisionLineage, |
| checkpointSelectionJson, |
| checkpointLocalSelection, |
| checkpointLocalSelectionJson, |
| checkpointDeropeSelectionJson, |
| checkpointOutputSelectionJson, |
| checkpointOutputSummary, |
| formatCheckpointBytes, |
| selectedCheckpointRevision, |
| } from "./h3_checkpoint_manager_core.mjs?v=0.6.7"; |
| import { |
| parsePlanJson, |
| planToJson, |
| promptValueToText, |
| } from "./h3_chain_plan_core.mjs?v=0.6.5"; |
| import {applyCheckpointRevisionSet} from "./h3_chain_review_core.mjs?v=0.6.5"; |
| import * as promptCompanionSync from "./h3_prompt_companion_sync.mjs?v=0.6.2"; |
| import { |
| refreshRestoredPlanEditors, |
| restoreConnectedPolicyInputs, |
| } from "./h3_plan_restore_core.mjs?v=0.6.6"; |
|
|
| const NODE_NAME = "MiniMaxH3ChainCheckpointManager"; |
| const PLAN_NAME = "MiniMaxH3ChainPlan"; |
| const PLAN_NAMES = new Set([PLAN_NAME, "MiniMaxH3ChainPlanModern"]); |
| const START_NAME = "MiniMaxH3ChainLoopStart"; |
| const RUN_PROPERTY = "h3_checkpoint_manager_run"; |
| const SCENE_PROPERTY = "h3_checkpoint_manager_scene"; |
| const REVISION_PROPERTY = "h3_checkpoint_manager_revision"; |
| const CHAPTER_PROPERTY = "h3_checkpoint_manager_chapter"; |
| const OUTPUT_SCOPE_PROPERTY = "h3_checkpoint_manager_output_scope"; |
| const STAGE_PROPERTY = "h3_checkpoint_manager_stage"; |
| const VARIANT_PROPERTY = "h3_checkpoint_manager_variant"; |
| const COLLAPSED_CHAPTERS_PROPERTY = "h3_checkpoint_manager_collapsed_chapters"; |
| const PREVIEW_HEIGHT_PROPERTY = "h3_checkpoint_manager_preview_height"; |
| const DEFAULT_PREVIEW_HEIGHT = 280; |
| const MIN_PREVIEW_HEIGHT = 120; |
| const MAX_PREVIEW_HEIGHT = 720; |
| const SHARED_COLORS = ["#6ea8ff", "#58c99d", "#bd8cff", "#e8a84f", "#f07f8c", "#55bfd0"]; |
|
|
| function previewHeight(value) { |
| const number = Number(value); |
| return Number.isFinite(number) |
| ? Math.max(MIN_PREVIEW_HEIGHT, Math.min(MAX_PREVIEW_HEIGHT, Math.round(number))) |
| : DEFAULT_PREVIEW_HEIGHT; |
| } |
|
|
| function nodeType(node) { |
| return node?.comfyClass ?? node?.type ?? ""; |
| } |
|
|
| function upstreamPlanNode(start) { |
| const queue = [start]; |
| const seen = new Set(); |
| while (queue.length) { |
| const current = queue.shift(); |
| if (!current || seen.has(current)) continue; |
| seen.add(current); |
| if (current !== start && PLAN_NAMES.has(nodeType(current))) return current; |
| for (const input of current.inputs ?? []) { |
| if (input.link == null) continue; |
| const link = graphLink(current.graph, input.link); |
| const candidate = link |
| ? current.graph?.getNodeById?.(link.origin_id) : null; |
| if (candidate) queue.push(candidate); |
| } |
| } |
| return null; |
| } |
|
|
| function widget(node, name) { |
| return node?.widgets?.find((item) => item.name === name); |
| } |
|
|
| function graphLink(graph, linkId) { |
| return graph?.links?.[linkId] ?? graph?.links?.get?.(linkId) ?? null; |
| } |
|
|
| function connectedNode(start, wantedType) { |
| const queue = [start]; |
| const seen = new Set(); |
| while (queue.length) { |
| const current = queue.shift(); |
| if (!current || seen.has(current)) continue; |
| seen.add(current); |
| if (current !== start && nodeType(current) === wantedType) return current; |
| for (const input of current.inputs ?? []) { |
| if (input.link == null) continue; |
| const link = graphLink(current.graph, input.link); |
| const candidate = link |
| ? current.graph?.getNodeById?.(link.origin_id) : null; |
| if (candidate) queue.push(candidate); |
| } |
| for (const output of current.outputs ?? []) { |
| for (const linkId of output.links ?? []) { |
| const link = graphLink(current.graph, linkId); |
| const candidate = link |
| ? current.graph?.getNodeById?.(link.target_id) : null; |
| if (candidate) queue.push(candidate); |
| } |
| } |
| } |
| return null; |
| } |
|
|
| function publishCompanionPrompt(...args) { |
| return promptCompanionSync.publishCompanionPrompt?.(...args) ?? 0; |
| } |
|
|
| function element(tag, className = "", text = undefined) { |
| const item = document.createElement(tag); |
| if (className) item.className = className; |
| if (text !== undefined) item.textContent = text; |
| return item; |
| } |
|
|
| function button(label, title, action, className = "") { |
| const item = element("button", className, label); |
| item.type = "button"; |
| item.title = title; |
| item.addEventListener("click", action); |
| return item; |
| } |
|
|
| function videoUrl(item) { |
| if (!item?.filename) return ""; |
| const query = new URLSearchParams({ |
| filename:item.filename, |
| subfolder:item.subfolder ?? "", |
| type:item.type ?? "output", |
| }); |
| return api.apiURL(`/view?${query.toString()}`); |
| } |
|
|
| function localTime(value) { |
| const date = new Date(value); |
| return Number.isNaN(date.getTime()) ? String(value || "unknown") : date.toLocaleString(); |
| } |
|
|
| function sharedColor(key) { |
| let hash = 0; |
| for (const character of String(key ?? "")) { |
| hash = ((hash * 31) + character.codePointAt(0)) >>> 0; |
| } |
| return SHARED_COLORS[hash % SHARED_COLORS.length]; |
| } |
|
|
| async function jsonRequest(path, options = {}) { |
| const response = await api.fetchApi(path, options); |
| const payload = await response.json(); |
| if (!response.ok) throw Object.assign( |
| new Error(payload.error || `HTTP ${response.status}`), {payload}); |
| return payload; |
| } |
|
|
| function injectStyles() { |
| if (document.getElementById("h3-checkpoint-manager-style")) return; |
| const style = document.createElement("style"); |
| style.id = "h3-checkpoint-manager-style"; |
| style.textContent = ` |
| .h3cm-root { --h3cm-bg:color-mix(in srgb,var(--comfy-menu-bg,#202124) 93%,#101827); |
| --h3cm-panel:var(--comfy-input-bg,#15171d); --h3cm-border:var(--border-color,#586174); |
| --h3cm-text:var(--input-text,#edf1f8); --h3cm-muted:color-mix(in srgb,var(--h3cm-text) 58%,transparent); |
| --h3cm-accent:color-mix(in srgb,var(--h3cm-text) 38%,#4f83ff); |
| --h3cm-chapter:color-mix(in srgb,var(--h3cm-text) 68%,#d99121); |
| --h3cm-danger:color-mix(in srgb,var(--h3cm-text) 40%,#d44747); |
| box-sizing:border-box; width:100%; height:100%; min-height:620px; display:flex; flex-direction:column; |
| gap:8px; overflow:hidden; padding:10px; border:1px solid var(--h3cm-border); border-radius:9px; |
| background:var(--h3cm-bg); color:var(--h3cm-text); font:12px/1.4 system-ui,sans-serif; } |
| .h3cm-root *, .h3cm-root *::before, .h3cm-root *::after { box-sizing:border-box; } |
| .h3cm-head,.h3cm-run-row,.h3cm-chapter-tabs,.h3cm-scenes,.h3cm-branch-head,.h3cm-branch-path,.h3cm-delete-actions { |
| display:flex; align-items:center; gap:6px; } |
| .h3cm-head { justify-content:space-between; } |
| .h3cm-title { font-size:15px; font-weight:760; color:var(--h3cm-accent); } |
| .h3cm-summary,.h3cm-status,.h3cm-muted { color:var(--h3cm-muted); } |
| .h3cm-root button,.h3cm-root select { min-height:30px; border:1px solid var(--h3cm-border); |
| border-radius:6px; background:var(--h3cm-panel); color:var(--h3cm-text); font:inherit; } |
| .h3cm-root button { padding:5px 8px; cursor:pointer; } |
| .h3cm-root button:hover,.h3cm-root button:focus-visible { border-color:var(--h3cm-accent); outline:none; } |
| .h3cm-root button:disabled { cursor:not-allowed; opacity:.45; } |
| .h3cm-run-select { flex:1; min-width:0; padding:5px 7px; } |
| .h3cm-run-delete { white-space:nowrap; color:var(--h3cm-danger) !important; } |
| .h3cm-output { display:flex; flex-wrap:wrap; align-items:center; gap:6px; |
| flex:0 0 auto; padding:7px; border:1px solid var(--h3cm-border); border-radius:7px; } |
| .h3cm-output-summary { flex:1 1 250px; overflow-wrap:anywhere; } |
| .h3cm-local-label { color:var(--h3cm-accent) !important; font-weight:700; } |
| .h3cm-scenes { flex:0 0 auto; overflow:auto; padding-bottom:2px; } |
| .h3cm-stage-tabs { display:flex; flex:0 0 auto; gap:6px; overflow:auto; } |
| .h3cm-stage-tab { white-space:nowrap; } |
| .h3cm-stage-tab[aria-selected="true"] { color:var(--h3cm-accent); border-color:var(--h3cm-accent); } |
| .h3cm-stage-note { flex:0 0 auto; color:var(--h3cm-muted); overflow-wrap:anywhere; } |
| .h3cm-variant-group { display:flex; flex-direction:column; gap:5px; } |
| .h3cm-chapter-tabs { flex:0 0 auto; overflow:auto; padding:2px 0; } |
| .h3cm-chapter-tab { white-space:nowrap; border-radius:999px !important; } |
| .h3cm-chapter-selected { color:var(--h3cm-chapter) !important; border-color:#d6a650 !important; |
| background:color-mix(in srgb,var(--h3cm-panel) 78%,#6d4b16) !important; } |
| .h3cm-scene { white-space:nowrap; } |
| .h3cm-scene-selected,.h3cm-revision-selected { border-color:var(--h3cm-accent) !important; |
| color:var(--h3cm-accent) !important; } |
| .h3cm-main { min-height:0; flex:1 1 auto; display:grid; grid-template-columns:minmax(310px,.9fr) minmax(390px,1.1fr); gap:8px; } |
| .h3cm-panel { min-height:0; overflow:auto; padding:8px; border:1px solid var(--h3cm-border); |
| border-radius:7px; background:color-mix(in srgb,var(--h3cm-panel) 90%,transparent); } |
| .h3cm-panel-title { display:flex; justify-content:space-between; gap:8px; margin-bottom:7px; font-weight:750; } |
| .h3cm-shared-legend { color:var(--h3cm-muted); font-size:10px; font-weight:500; } |
| .h3cm-branches { position:relative; } |
| .h3cm-branch-chapter { margin-bottom:12px; padding:7px; border:1px solid color-mix(in srgb,var(--h3cm-border) 62%,transparent); |
| border-radius:8px; background:color-mix(in srgb,var(--h3cm-panel) 70%,transparent); } |
| .h3cm-branch-chapter:last-child { margin-bottom:0; } |
| .h3cm-branch-chapter-title { width:100%; min-height:0 !important; display:flex; align-items:center; |
| justify-content:flex-start; gap:7px; margin:0 0 7px; padding:2px !important; border:0 !important; |
| background:transparent !important; color:var(--h3cm-chapter) !important; font-size:11px !important; |
| font-weight:750 !important; text-align:left; } |
| .h3cm-branch-chapter-title:hover,.h3cm-branch-chapter-title:focus-visible { |
| color:var(--h3cm-accent) !important; outline:1px solid var(--h3cm-accent) !important; } |
| .h3cm-branch-chapter-title .h3cm-muted { margin-left:auto; font-weight:500; } |
| .h3cm-branch-chapter-caret { width:11px; color:currentColor; text-align:center; } |
| .h3cm-branch-chapter-collapsed { padding-bottom:7px; } |
| .h3cm-branch-chapter-collapsed .h3cm-branch-chapter-title { margin-bottom:0; } |
| .h3cm-branch { position:relative; z-index:1; margin-bottom:8px; padding:6px; |
| border:1px solid color-mix(in srgb,var(--h3cm-border) 75%,transparent); border-radius:6px; } |
| .h3cm-branch-head { justify-content:space-between; margin-bottom:5px; } |
| .h3cm-branch-head[role="button"] { cursor:pointer; border-radius:4px; } |
| .h3cm-branch-head[role="button"]:hover,.h3cm-branch-head[role="button"]:focus-visible { |
| color:var(--h3cm-accent); outline:1px solid var(--h3cm-accent); outline-offset:2px; } |
| .h3cm-branch-selected { border-color:var(--h3cm-accent) !important; } |
| .h3cm-branch-active { color:var(--h3cm-accent); font-weight:700; } |
| .h3cm-branch-path { position:relative; z-index:3; align-items:stretch; overflow:auto; padding-bottom:2px; } |
| .h3cm-arrow { align-self:center; color:var(--h3cm-muted); } |
| .h3cm-revision { position:relative; min-width:112px; text-align:left; white-space:nowrap; } |
| .h3cm-revision small { display:block; color:var(--h3cm-muted); font-size:10px; } |
| .h3cm-alternates { display:flex; flex-direction:column; gap:3px; min-width:104px; |
| padding-left:7px; border-left:2px solid #8264bd; } |
| .h3cm-alternate { min-width:100px; min-height:24px !important; padding:3px 6px !important; |
| border-color:#7259a8 !important; color:#d9c9f7 !important; font-size:10px !important; } |
| .h3cm-alternate-used { background:color-mix(in srgb,var(--h3cm-panel) 68%,#56358b) !important; |
| box-shadow:inset 3px 0 0 #b493f0; } |
| .h3cm-revision-empty { border-style:dashed !important; color:var(--h3cm-muted) !important; |
| background:color-mix(in srgb,var(--h3cm-panel) 72%,transparent) !important; } |
| .h3cm-revision-empty-selected { border-color:var(--h3cm-accent) !important; |
| color:var(--h3cm-accent) !important; } |
| .h3cm-revision-shared { border-color:var(--h3cm-shared-color) !important; |
| box-shadow:inset 3px 0 0 var(--h3cm-shared-color); } |
| .h3cm-shared-label { display:block; width:max-content; margin:2px 0; padding:1px 5px; |
| border-radius:999px; background:color-mix(in srgb,var(--h3cm-shared-color) 23%,transparent); |
| color:color-mix(in srgb,var(--h3cm-shared-color) 72%,var(--h3cm-text)); font-size:9px; font-weight:750; } |
| .h3cm-detail { display:flex; flex-direction:column; gap:8px; } |
| .h3cm-preview-frame { width:100%; height:280px; min-height:120px; max-height:720px; |
| flex:0 0 auto; display:flex; flex-direction:column; overflow:hidden; border-radius:6px; |
| background:#08090c; } |
| .h3cm-preview { width:100%; min-height:0; flex:1 1 auto; object-fit:contain; background:#08090c; } |
| .h3cm-preview-resizer { position:relative; flex:0 0 12px; min-height:12px; |
| cursor:ns-resize; touch-action:none; background:color-mix(in srgb,var(--h3cm-panel) 88%,#000); } |
| .h3cm-preview-resizer::after { content:""; position:absolute; top:5px; left:calc(50% - 28px); |
| width:56px; height:2px; border-radius:2px; background:var(--h3cm-border); } |
| .h3cm-preview-resizer:hover::after,.h3cm-preview-resizer:focus-visible::after { |
| background:var(--h3cm-accent); } |
| .h3cm-preview-resizer:focus-visible { outline:1px solid var(--h3cm-accent); outline-offset:-1px; } |
| .h3cm-audio { width:100%; height:36px; } |
| .h3cm-inspector { display:grid; grid-template-columns:auto minmax(0,1fr); gap:3px 9px; } |
| .h3cm-inspector dt { color:var(--h3cm-muted); } |
| .h3cm-inspector dd { margin:0; overflow-wrap:anywhere; } |
| .h3cm-prompt { max-height:90px; overflow:auto; padding:6px; border-radius:5px; |
| background:var(--h3cm-panel); white-space:pre-wrap; overflow-wrap:anywhere; } |
| .h3cm-attribution { padding:7px; border:1px dashed var(--h3cm-accent); |
| border-radius:6px; background:color-mix(in srgb,var(--h3cm-accent) 8%,transparent); } |
| .h3cm-attribution-title { margin-bottom:6px; font-weight:750; color:var(--h3cm-accent); } |
| .h3cm-attribution-candidates { display:flex; flex-wrap:wrap; gap:5px; margin-bottom:7px; } |
| .h3cm-attribution-candidate-selected { border-color:var(--h3cm-accent) !important; |
| color:var(--h3cm-accent) !important; } |
| .h3cm-delete { flex:0 0 auto; max-height:210px; overflow:auto; padding:8px; |
| border:1px solid var(--h3cm-border); border-radius:7px; } |
| .h3cm-delete-blocked { border-color:var(--h3cm-danger); } |
| .h3cm-delete-title { font-weight:700; } |
| .h3cm-files,.h3cm-dependents { margin:5px 0 0; padding-left:18px; } |
| .h3cm-dependent { color:var(--h3cm-danger); cursor:pointer; } |
| .h3cm-delete-actions { margin-top:7px; } |
| .h3cm-delete-actions .h3cm-status { flex:1 1 180px; min-width:120px; } |
| .h3cm-delete-button { margin-left:auto; color:var(--h3cm-danger) !important; } |
| .h3cm-error { color:var(--h3cm-danger); } |
| @media (max-width:760px) { .h3cm-main { grid-template-columns:1fr; } |
| .h3cm-root { overflow:auto; } } |
| `; |
| document.head.append(style); |
| } |
|
|
| function mount(node) { |
| if (node._h3CheckpointManagerMounted) return; |
| node._h3CheckpointManagerMounted = true; |
| injectStyles(); |
| node.properties ??= {}; |
| let selectionWidget = widget(node, "selection_json"); |
| const state = { |
| runs:[], runName:String(node.properties[RUN_PROPERTY] ?? ""), payload:null, |
| scene:Number(node.properties[SCENE_PROPERTY]) || null, |
| revision:String(node.properties[REVISION_PROPERTY] ?? ""), |
| chapterTab:String(node.properties[CHAPTER_PROPERTY] ?? "all"), |
| stage:CHECKPOINT_STAGES.some(item => item.id === node.properties[STAGE_PROPERTY]) |
| ? node.properties[STAGE_PROPERTY] : "original", |
| variantKey:String(node.properties[VARIANT_PROPERTY] ?? ""), |
| collapsedChapters:new Set( |
| Array.isArray(node.properties[COLLAPSED_CHAPTERS_PROPERTY]) |
| ? node.properties[COLLAPSED_CHAPTERS_PROPERTY].map(String) : [], |
| ), |
| previewHeight:previewHeight(node.properties[PREVIEW_HEIGHT_PROPERTY]), |
| selected:null, outputTip:null, previewTip:null, deletion:null, busy:false, requestToken:0, |
| initialRefresh:true, attribution:null, attributionButton:null, |
| }; |
| const root = element("div", "h3cm-root"); |
| const head = element("div", "h3cm-head"); |
| const title = element("div", "h3cm-title", "Checkpoint Manager"); |
| const summary = element("div", "h3cm-summary", "Select a saved run"); |
| head.append(title, summary); |
| const runRow = element("div", "h3cm-run-row"); |
| const runSelect = element("select", "h3cm-run-select"); |
| const refresh = button("Refresh", "Rescan saved runs and checkpoint revisions", () => void refreshRuns()); |
| const open = button("Open folder", "Open the selected run folder on the ComfyUI host", () => void openFolder()); |
| const deleteRun = button( |
| "Delete run folder", |
| "Permanently delete the selected output/h3_chains run folder after a content preview and two confirmations. Original input project assets are kept.", |
| () => void deleteRunFolder(), |
| "h3cm-run-delete", |
| ); |
| deleteRun.disabled = true; |
| runRow.append(runSelect, refresh, open, deleteRun); |
| const outputRow = element("div", "h3cm-output"); |
| const outputSummary = element("div", "h3cm-output-summary"); |
| const outputScope = element("select", "h3cm-output-scope"); |
| outputScope.title = "Output scope only; never changes the project's active branch. Chapter output keeps original scene numbers."; |
| outputScope.setAttribute("aria-label", "Checkpoint output scope"); |
| for (const [value, label] of [["project", "Selected branch + earlier chapters"], ["chapter", "Selected chapter only"]]) { |
| const option = element("option", "", label); |
| option.value = value; |
| outputScope.append(option); |
| } |
| restoreOutputScope(); |
| outputScope.addEventListener("change", () => { |
| node.properties[OUTPUT_SCOPE_PROPERTY] = outputScope.value; |
| const local = checkpointLocalSelection(selectionWidget?.value); |
| if (local) { |
| |
| writeOutputSelection(JSON.stringify({...local, output_scope:outputScope.value})); |
| } else persistSelection(); |
| render(); |
| }); |
| const useLocal = button("Use branch locally", |
| "Use the entire browsed branch in this workflow. Previewing an earlier clip does not trim it. Set the processing range downstream. No project activation or Plan change.", |
| () => pinLocalOutput()); |
| const followSelection = button("Follow branch selection", |
| "Release the local pin: output follows branch selections, not clip previews. The project's active branch is unchanged.", |
| () => releaseLocalOutput()); |
| outputRow.append(outputSummary, outputScope, useLocal, followSelection); |
| const chapterTabs = element("div", "h3cm-chapter-tabs"); |
| const stageTabs = element("div", "h3cm-stage-tabs"); |
| stageTabs.setAttribute("role", "tablist"); |
| stageTabs.setAttribute("aria-label", "Saved clip processing stage"); |
| const stageNote = element("div", "h3cm-stage-note"); |
| const scenes = element("div", "h3cm-scenes"); |
| const main = element("div", "h3cm-main"); |
| const branchesPanel = element("section", "h3cm-panel"); |
| const branchesTitle = element("div", "h3cm-panel-title", "Revision branches"); |
| const branchLegend = element("span", "h3cm-shared-legend", "matching color = same saved clip"); |
| branchesTitle.append(branchLegend); |
| const branches = element("div", "h3cm-branches"); |
| branchesPanel.append(branchesTitle, branches); |
| const detail = element("section", "h3cm-panel h3cm-detail"); |
| const previewFrame = element("div", "h3cm-preview-frame"); |
| const preview = element("video", "h3cm-preview"); |
| preview.controls = true; |
| preview.preload = "metadata"; |
| const previewResizer = element("div", "h3cm-preview-resizer"); |
| previewResizer.tabIndex = 0; |
| previewResizer.setAttribute("role", "separator"); |
| previewResizer.setAttribute("aria-orientation", "horizontal"); |
| previewResizer.setAttribute("aria-label", "Resize clip preview height"); |
| previewResizer.title = "Drag to resize the clip preview. Double-click to reset."; |
| previewFrame.append(preview, previewResizer); |
| const audio = element("audio", "h3cm-audio"); |
| audio.controls = true; |
| audio.preload = "metadata"; |
| audio.hidden = true; |
| const inspector = element("dl", "h3cm-inspector"); |
| const attributionPanel = element("div", "h3cm-attribution"); |
| attributionPanel.hidden = true; |
| const prompt = element("div", "h3cm-prompt"); |
| detail.append(previewFrame, audio, attributionPanel, inspector, prompt); |
| main.append(branchesPanel, detail); |
| const deletion = element("section", "h3cm-delete"); |
| const deletionTitle = element("div", "h3cm-delete-title", "Select a checkpoint revision."); |
| const deletionBody = element("div"); |
| const deletionActions = element("div", "h3cm-delete-actions"); |
| let retireButtons = []; |
| const status = element("div", "h3cm-status"); |
| const load = button("Load selected branch", "Project-wide: activate this chapter lineage and restore the connected Plan for generation", () => void loadSelected()); |
| const activate = button("Make branch active (project)", "Project-wide: promote this chapter for all workflows using this Run", () => void activateSelected()); |
| const remove = button("Delete selected revision", "Delete an inactive leaf or roll back the active branch tip after confirmation", () => void deleteSelected(), "h3cm-delete-button"); |
| load.disabled = true; |
| activate.disabled = true; |
| remove.disabled = true; |
| deletionActions.append(load, activate, status, remove); |
| deletion.append(deletionTitle, deletionBody, deletionActions); |
| root.append(head, runRow, outputRow, stageTabs, stageNote, chapterTabs, scenes, main, deletion); |
|
|
| function setPreviewHeight(value, persist = false) { |
| state.previewHeight = previewHeight(value); |
| previewFrame.style.height = `${state.previewHeight}px`; |
| previewResizer.setAttribute("aria-valuemin", String(MIN_PREVIEW_HEIGHT)); |
| previewResizer.setAttribute("aria-valuemax", String(MAX_PREVIEW_HEIGHT)); |
| previewResizer.setAttribute("aria-valuenow", String(state.previewHeight)); |
| if (!persist) return; |
| node.properties[PREVIEW_HEIGHT_PROPERTY] = state.previewHeight; |
| node.graph?.setDirtyCanvas?.(true, true); |
| app.graph?.setDirtyCanvas?.(true, true); |
| } |
|
|
| setPreviewHeight(state.previewHeight); |
| previewResizer.addEventListener("pointerdown", (event) => { |
| if (event.button !== 0) return; |
| event.preventDefault(); |
| event.stopPropagation(); |
| const pointerId = event.pointerId; |
| const startY = event.clientY; |
| const startHeight = state.previewHeight; |
| previewResizer.setPointerCapture?.(pointerId); |
| const move = (moveEvent) => { |
| if (moveEvent.pointerId !== pointerId) return; |
| moveEvent.preventDefault(); |
| setPreviewHeight(startHeight + moveEvent.clientY - startY); |
| }; |
| const finish = (finishEvent) => { |
| if (finishEvent.pointerId !== pointerId) return; |
| previewResizer.removeEventListener("pointermove", move); |
| previewResizer.removeEventListener("pointerup", finish); |
| previewResizer.removeEventListener("pointercancel", finish); |
| if (previewResizer.hasPointerCapture?.(pointerId)) { |
| previewResizer.releasePointerCapture(pointerId); |
| } |
| setPreviewHeight(state.previewHeight, true); |
| }; |
| previewResizer.addEventListener("pointermove", move); |
| previewResizer.addEventListener("pointerup", finish); |
| previewResizer.addEventListener("pointercancel", finish); |
| }); |
| previewResizer.addEventListener("keydown", (event) => { |
| let next = state.previewHeight; |
| const step = event.shiftKey ? 48 : 16; |
| if (event.key === "ArrowUp") next -= step; |
| else if (event.key === "ArrowDown") next += step; |
| else if (event.key === "Home") next = MIN_PREVIEW_HEIGHT; |
| else if (event.key === "End") next = MAX_PREVIEW_HEIGHT; |
| else return; |
| event.preventDefault(); |
| event.stopPropagation(); |
| setPreviewHeight(next, true); |
| }); |
| previewResizer.addEventListener("dblclick", (event) => { |
| event.preventDefault(); |
| event.stopPropagation(); |
| setPreviewHeight(DEFAULT_PREVIEW_HEIGHT, true); |
| }); |
|
|
| function activePlanRun() { |
| const plan = upstreamPlanNode(node); |
| return String(widget(plan, "run_name")?.value ?? "").trim(); |
| } |
|
|
| function restoreOutputScope() { |
| let scope = node.properties[OUTPUT_SCOPE_PROPERTY]; |
| try { scope = JSON.parse(selectionWidget?.value || "{}").output_scope ?? scope; } |
| catch { } |
| outputScope.value = scope === "chapter" ? "chapter" : "project"; |
| } |
|
|
| function outputSelectionForScope(value) { |
| |
| |
| try { |
| const selection = JSON.parse(value); |
| if (!selection || typeof selection !== "object" || Array.isArray(selection)) return value; |
| if (selection.output_scope != null && !["project", "chapter"].includes(selection.output_scope)) return value; |
| if ((selection.output_scope ?? "project") === outputScope.value) return value; |
| return JSON.stringify({...selection, output_scope:outputScope.value}); |
| } catch { return value; } |
| } |
|
|
| function bindSelectionSerializer() { |
| selectionWidget = widget(node, "selection_json"); |
| if (!selectionWidget) return; |
| selectionWidget.hidden = true; |
| selectionWidget.type = "hidden"; |
| selectionWidget.computeSize = () => [0, -4]; |
| if (selectionWidget._h3ScopeSerializer) return; |
| const previous = selectionWidget.serializeValue; |
| selectionWidget.serializeValue = function (...args) { |
| const value = previous ? previous.apply(this, args) : this.value; |
| const normalize = (saved) => outputSelectionForScope(saved ?? this.value); |
| return value?.then ? value.then(normalize) : normalize(value); |
| }; |
| selectionWidget._h3ScopeSerializer = true; |
| } |
|
|
| function persistSelection() { |
| const previousRun = node.properties[RUN_PROPERTY]; |
| const previousScene = node.properties[SCENE_PROPERTY]; |
| const previousRevision = node.properties[REVISION_PROPERTY]; |
| const previousChapter = node.properties[CHAPTER_PROPERTY]; |
| const previousScope = node.properties[OUTPUT_SCOPE_PROPERTY]; |
| node.properties[RUN_PROPERTY] = state.runName; |
| node.properties[SCENE_PROPERTY] = state.scene; |
| node.properties[REVISION_PROPERTY] = state.revision; |
| node.properties[CHAPTER_PROPERTY] = state.chapterTab; |
| node.properties[OUTPUT_SCOPE_PROPERTY] = outputScope.value; |
| let changed = previousRun !== state.runName || |
| previousScene !== state.scene || |
| previousRevision !== state.revision || |
| previousChapter !== state.chapterTab || previousScope !== outputScope.value; |
| if (selectionWidget && state.stage === "original") { |
| const value = checkpointOutputSelectionJson( |
| selectionWidget.value, state.payload, state.runName, state.outputTip, |
| chapterRangeFor(state.outputTip), outputScope.value); |
| if (selectionWidget.value !== value) { |
| selectionWidget.value = value; |
| selectionWidget.callback?.(value); |
| changed = true; |
| } |
| } |
| if (changed) node.graph?.setDirtyCanvas?.(true, true); |
| } |
|
|
| function writeOutputSelection(value) { |
| if (!selectionWidget) return; |
| node.properties[OUTPUT_SCOPE_PROPERTY] = outputScope.value; |
| selectionWidget.value = value; |
| selectionWidget.callback?.(value); |
| node.graph?.setDirtyCanvas?.(true, true); |
| } |
|
|
| function pinLocalOutput() { |
| if (!["original", "derope"].includes(state.stage) || state.busy || state.attribution || !selectionWidget) return; |
| try { |
| const tip = state.previewTip; |
| if (!tip) throw new Error("Choose a branch heading first; this clip belongs to more than one branch."); |
| writeOutputSelection(state.stage === "derope" |
| ? checkpointDeropeSelectionJson(state.payload, state.runName, tip, currentVariant(), chapterRangeFor(tip), outputScope.value) |
| : checkpointLocalSelectionJson(state.payload, state.runName, tip, chapterRangeFor(tip), outputScope.value)); |
| state.outputTip = tip; |
| status.className = "h3cm-status"; |
| status.textContent = state.stage === "derope" |
| ? "DeRoPE branch selected for deferred processing. Unsaved scenes use the selected original take; missing/corrupt full latents fail explicitly. Set the range downstream. Project unchanged." |
| : "Whole original branch saved for this workflow. Set start/end on the downstream range selector. Project active branch and connected Plan unchanged."; |
| render(); |
| } catch (error) { |
| status.className = "h3cm-status h3cm-error"; |
| status.textContent = error.message; |
| } |
| } |
|
|
| function releaseLocalOutput() { |
| if (state.stage !== "original" || state.busy || !checkpointLocalSelection(selectionWidget?.value)) return; |
| if (!state.previewTip) return; |
| state.outputTip = state.previewTip; |
| writeOutputSelection(checkpointSelectionJson( |
| state.payload, state.runName, state.outputTip, chapterRangeFor(state.outputTip), outputScope.value)); |
| status.className = "h3cm-status"; |
| status.textContent = "Output follows whole-branch selections. Clip previews do not change the processing range."; |
| render(); |
| } |
|
|
| function localRevisionKeys() { |
| const local = checkpointLocalSelection(selectionWidget?.value); |
| return new Set(local?.run_name === state.runName |
| ? (local.lineage ?? []).filter((item) => local.output_scope !== "chapter" || item.scene >= local.scope_start_scene) |
| .map((item) => checkpointRevisionKey(item.scene, item.revision)) : []); |
| } |
|
|
| function renderOutputSelection() { |
| const local = checkpointLocalSelection(selectionWidget?.value); |
| outputScope.disabled = state.busy || state.stage !== "original"; |
| if (local) restoreOutputScope(); |
| useLocal.textContent = state.stage === "derope" ? "Use DeRoPE branch locally" : "Use branch locally"; |
| useLocal.disabled = state.busy || Boolean(state.attribution) || !selectionWidget || !["original", "derope"].includes(state.stage) || !state.previewTip?.ready; |
| useLocal.title = state.stage === "derope" |
| ? "Use this saved DeRoPE branch as the deferred source, with original takes for unsaved scenes. No project activation. A full recovered latent is required." |
| : state.previewTip |
| ? "Save the entire browsed branch for this workflow; set start/end on the downstream range selector. No project activation or Plan change." |
| : "Choose a branch heading first. A shared clip alone does not identify which branch to use."; |
| followSelection.disabled = state.busy || !local || state.stage !== "original" || !state.previewTip; |
| outputSummary.className = "h3cm-output-summary"; |
| const outputValue = outputSelectionForScope(selectionWidget?.value || "null"); |
| outputSummary.textContent = checkpointOutputSummary(outputValue); |
| if (local) { |
| if (state.payload && local.run_name === state.runName) { |
| const available = new Set((state.payload.revisions ?? []).filter((item) => item.ready) |
| .map((item) => checkpointRevisionKey(item.scene, item.revision))); |
| if ((local.lineage ?? []).some((item) => |
| (local.output_scope !== "chapter" || item.scene >= local.scope_start_scene) && |
| !available.has(checkpointRevisionKey(item.scene, item.revision)))) { |
| outputSummary.className += " h3cm-error"; |
| outputSummary.textContent += " · pinned checkpoint unavailable; reselect explicitly (no fallback)"; |
| } |
| } |
| } |
| let saved = null; |
| try { saved = JSON.parse(outputValue); } catch { } |
| if (saved && state.payload && saved.run_name === state.runName) { |
| const tip = saved.lineage?.at(-1); |
| const range = {start:saved.scope_start_scene, end:saved.scope_end_scene}; |
| const fullTip = checkpointOutputBranchTip(state.payload, tip, range); |
| if (!fullTip || Number(fullTip.scene) > Number(tip?.scene)) { |
| outputSummary.textContent += " · old partial selection: choose the desired branch heading" |
| + (local ? ", then Use branch locally" : "") + " to include its later clips"; |
| } |
| } |
| } |
|
|
| function setBusy(value, message = "") { |
| state.busy = Boolean(value); |
| runSelect.disabled = state.busy; |
| refresh.disabled = state.busy; |
| open.disabled = state.busy || !state.runName; |
| deleteRun.disabled = state.busy || !state.runName; |
| load.disabled = state.busy || Boolean(state.attribution) || !canLoadSelected(); |
| activate.disabled = state.busy || Boolean(state.attribution) || !canActivateSelected(); |
| remove.disabled = state.busy || Boolean(state.attribution) || !state.deletion?.allowed; |
| for (const control of retireButtons) control.disabled = state.busy || Boolean(state.attribution); |
| if (state.attributionButton) { |
| state.attributionButton.disabled = state.busy || !state.attribution?.candidate; |
| } |
| renderOutputSelection(); |
| renderStageTabs(); |
| if (message) status.textContent = message; |
| } |
|
|
| function selectedLineage() { |
| return checkpointRevisionLineage( |
| state.payload, state.selected, selectedChapterRange()); |
| } |
|
|
| function canLoadSelected() { |
| const lineage = selectedLineage(); |
| const scope = selectedChapterRange(); |
| return Boolean(state.stage === "original" && state.selected?.ready && |
| state.selected?.take_kind !== "editorial_alternate" && |
| lineage.length === Number(state.selected.scene) - scope.start + 1); |
| } |
|
|
| function canActivateSelected() { |
| return ["activate", "rollback"].includes(selectedActivationMode()); |
| } |
|
|
| function selectedActivationMode() { |
| if (state.stage !== "original") return "disabled"; |
| return checkpointActivationMode( |
| state.payload, state.selected, selectedChapterRange()); |
| } |
|
|
| function selectRevision(record, requestDeletion = true, variantKey = "", branchTip = null) { |
| state.attribution = null; |
| state.variantKey = variantKey; |
| node.properties[VARIANT_PROPERTY] = variantKey; |
| state.selected = record; |
| state.scene = record ? Number(record.scene) : null; |
| state.revision = record ? String(record.revision) : ""; |
| if (state.stage === "original") { |
| state.previewTip = branchTip ?? checkpointOutputBranchTip( |
| state.payload, record, chapterRangeFor(record), state.previewTip ?? state.outputTip); |
| } |
| state.deletion = null; |
| state.requestToken += 1; |
| persistSelection(); |
| render(); |
| if (requestDeletion) void refreshDeletionPreview(); |
| } |
|
|
| function selectOutputBranch(tip) { |
| if (state.stage !== "original") return; |
| state.outputTip = tip; |
| selectRevision(tip, true, "", tip); |
| } |
|
|
| function stageLabel() { |
| return CHECKPOINT_STAGES.find(item => item.id === state.stage)?.label ?? "Original"; |
| } |
|
|
| function currentVariant() { |
| const records = checkpointStageVariants(state.payload, state.stage); |
| const exact = records.find(item => item.key === state.variantKey); |
| if (exact) return exact; |
| |
| |
| if (state.variantKey && !(state.payload?.processing_variants ?? []).some(item => item.key === state.variantKey)) return null; |
| return state.selected ? checkpointStageVariants(state.payload, state.stage, state.selected)[0] ?? null : null; |
| } |
|
|
| function selectVariant(record, original = null, branchTip = null) { |
| original ??= (state.payload?.revisions ?? []).find(item => (record.originals ?? []).some( |
| source => checkpointRevisionKey(item.scene, item.revision) === checkpointRevisionKey(source.scene, source.revision))); |
| state.previewTip = branchTip ?? checkpointOutputBranchTip(state.payload, original, chapterRangeFor(original), state.previewTip); |
| selectRevision(original, true, record.key); |
| } |
|
|
| function selectStage(stage) { |
| if (state.busy) return; |
| state.stage = stage; |
| state.attribution = null; |
| state.deletion = null; |
| state.requestToken += 1; |
| node.properties[STAGE_PROPERTY] = stage; |
| if (stage === "original") state.previewTip = checkpointOutputBranchTip( |
| state.payload, state.selected, chapterRangeFor(state.selected)); |
| node.graph?.setDirtyCanvas?.(true, true); |
| |
| render(); |
| void refreshDeletionPreview(); |
| } |
|
|
| function renderStageTabs() { |
| stageTabs.replaceChildren(); |
| for (const stage of CHECKPOINT_STAGES) { |
| const count = stage.id === "original" ? (state.payload?.revisions ?? []).filter(item => sceneVisible(item.scene)).length |
| : checkpointStageVariants(state.payload, stage.id, null, activeChapterRange()).length; |
| if (["pixel_upscale", "other"].includes(stage.id) && !count && state.stage !== stage.id) continue; |
| const tab = button(`${stage.label} · ${count}`, `Browse saved ${stage.label} versions; does not activate a generation branch`, |
| () => selectStage(stage.id), "h3cm-stage-tab"); |
| tab.setAttribute("role", "tab"); |
| tab.setAttribute("aria-selected", String(state.stage === stage.id)); |
| tab.disabled = state.busy; |
| stageTabs.append(tab); |
| } |
| stageNote.textContent = state.stage === "original" ? "" |
| : `${stageLabel()} versions grouped by their original source branch. Browsing does not change output.` |
| + (state.stage === "derope" ? " Select a saved take, then Use DeRoPE branch locally for deferred upscaling. Unsaved scenes use their original take." : ""); |
| const warnings = state.payload?.processing_variant_warnings ?? []; |
| if (warnings.length) stageNote.textContent += ` ${warnings.length} processing metadata warning(s): ${warnings[0]}`; |
| stageNote.hidden = !stageNote.textContent; |
| branchLegend.textContent = state.stage === "original" ? "matching color = same saved clip" |
| : "saved versions per source clip"; |
| } |
|
|
| function selectAttribution(parent, slot) { |
| const candidates = slot?.candidates ?? []; |
| if (!parent || !(candidates.length || slot?.blocked_candidates?.length)) return; |
| state.selected = parent; |
| state.scene = Number(parent.scene); |
| state.revision = String(parent.revision); |
| state.attribution = { |
| parent, |
| scene:Number(slot.scene), |
| candidates, |
| blocked:slot?.blocked_candidates ?? [], |
| candidate:candidates[0] ?? null, |
| }; |
| persistSelection(); |
| render(); |
| } |
|
|
| function chapterRanges() { |
| const chapters = Array.isArray(state.payload?.editorial?.chapters) |
| ? state.payload.editorial.chapters : []; |
| const ordered = chapters.slice().sort( |
| (left, right) => Number(left.start_scene) - Number(right.start_scene), |
| ); |
| const maximum = Math.max( |
| 0, |
| ...(state.payload?.scenes ?? []).map((scene) => Number(scene.scene) || 0), |
| ...(state.payload?.editorial?.scene_order ?? []).map( |
| (scene) => Number(scene.scene) || 0, |
| ), |
| ); |
| const ranges = ordered.map((chapter, index) => ({ |
| id:String(chapter.id), |
| title:String(chapter.title || `Chapter ${index + 1}`), |
| text:String(chapter.text || ""), |
| start:Number(chapter.start_scene), |
| end:index + 1 < ordered.length |
| ? Number(ordered[index + 1].start_scene) - 1 : maximum, |
| })).filter((chapter) => Number.isFinite(chapter.start) && chapter.start > 0); |
| if (ranges.length && ranges[0].start > 1) { |
| ranges.unshift({id:"unassigned", title:"Unassigned", text:"", start:1, end:ranges[0].start - 1}); |
| } |
| return ranges; |
| } |
|
|
| function activeChapterRange() { |
| if (state.chapterTab === "all") return null; |
| return chapterRanges().find((chapter) => chapter.id === state.chapterTab) ?? null; |
| } |
|
|
| function selectedChapterRange() { |
| return chapterRangeFor(state.selected); |
| } |
|
|
| function chapterRangeFor(record) { |
| const scene = Number(record?.scene); |
| const ranges = chapterRanges(); |
| const selected = ranges.find((range) => |
| scene >= range.start && scene <= range.end); |
| if (selected) return selected; |
| const maximum = Math.max( |
| 1, |
| ...(state.payload?.scenes ?? []).map( |
| (item) => Number(item.scene) || 0), |
| ...(state.payload?.editorial?.scene_order ?? []).map( |
| (item) => Number(item.scene) || 0), |
| ); |
| return {id:"all", title:"All scenes", text:"", start:1, end:maximum}; |
| } |
|
|
| function sceneVisible(scene) { |
| const range = activeChapterRange(); |
| const number = Number(scene); |
| return !range || (number >= range.start && number <= range.end); |
| } |
|
|
| function chapterCollapseKey(range) { |
| return `${state.runName}:${String(range.id)}`; |
| } |
|
|
| function setChapterCollapsed(range, collapsed) { |
| const key = chapterCollapseKey(range); |
| if (collapsed) state.collapsedChapters.add(key); |
| else state.collapsedChapters.delete(key); |
| node.properties[COLLAPSED_CHAPTERS_PROPERTY] = [ |
| ...state.collapsedChapters, |
| ].sort(); |
| node.graph?.setDirtyCanvas?.(true, true); |
| renderBranches(); |
| } |
|
|
| function selectChapterTab(chapterId) { |
| state.chapterTab = chapterId; |
| state.variantKey = ""; |
| node.properties[VARIANT_PROPERTY] = ""; |
| const visibleScenes = (state.payload?.scenes ?? []).filter( |
| (scene) => sceneVisible(scene.scene), |
| ); |
| if (!sceneVisible(state.selected?.scene) && visibleScenes.length) { |
| const scene = visibleScenes.at(-1); |
| state.selected = selectedCheckpointRevision(state.payload, scene.scene); |
| state.scene = Number(state.selected?.scene ?? scene.scene); |
| state.revision = String(state.selected?.revision ?? ""); |
| state.deletion = null; |
| } |
| persistSelection(); |
| render(); |
| if (state.selected) void refreshDeletionPreview(); |
| } |
|
|
| function renderChapterTabs() { |
| chapterTabs.replaceChildren(); |
| const ranges = chapterRanges(); |
| chapterTabs.hidden = !ranges.length; |
| if (!ranges.length) { |
| state.chapterTab = "all"; |
| return; |
| } |
| const valid = new Set(["all", ...ranges.map((chapter) => chapter.id)]); |
| if (!valid.has(state.chapterTab)) state.chapterTab = "all"; |
| const tabs = [{id:"all", title:"All scenes", text:""}, ...ranges]; |
| for (const chapter of tabs) { |
| const item = button( |
| chapter.title, |
| chapter.text || (chapter.id === "all" |
| ? "Show every saved scene" : `Show scenes ${chapter.start}–${chapter.end}`), |
| () => selectChapterTab(chapter.id), |
| "h3cm-chapter-tab", |
| ); |
| if (chapter.id === state.chapterTab) { |
| item.classList.add("h3cm-chapter-selected"); |
| } |
| chapterTabs.append(item); |
| } |
| } |
|
|
| function renderScenes() { |
| scenes.replaceChildren(); |
| for (const scene of state.payload?.scenes ?? []) { |
| if (!sceneVisible(scene.scene)) continue; |
| const original = state.stage === "original"; |
| const count = original ? scene.revision_count : checkpointStageVariants(state.payload, state.stage) |
| .filter(item => Number(item.scene) === Number(scene.scene)).length; |
| const noun = original ? "take" : "version"; |
| const label = `${scene.scene} · ${scene.scene_id} · ${count} ${noun}${count === 1 ? "" : "s"}`; |
| const item = button(label, original ? `${formatCheckpointBytes(scene.bytes)} saved for this scene` |
| : `${count} saved ${stageLabel()} versions for this scene`, () => { |
| selectRevision(selectedCheckpointRevision(state.payload, scene.scene)); |
| }, "h3cm-scene"); |
| if (Number(scene.scene) === Number(state.scene)) item.classList.add("h3cm-scene-selected"); |
| scenes.append(item); |
| } |
| } |
|
|
| function renderBranchRows(container, rows) { |
| if (state.stage !== "original") { |
| renderVariantBranchRows(container, rows); |
| return; |
| } |
| const localKeys = localRevisionKeys(); |
| const occurrences = new Map(); |
| for (const branch of rows) { |
| for (const revision of branch.revisions) { |
| const key = checkpointRevisionKey(revision.scene, revision.revision); |
| occurrences.set(key, (occurrences.get(key) ?? 0) + 1); |
| } |
| } |
| for (const branch of rows) { |
| const row = element("div", "h3cm-branch"); |
| const header = element("div", "h3cm-branch-head"); |
| const tip = branch.revisions.at(-1) ?? null; |
| const selectedTip = Boolean(tip && |
| Number(state.previewTip?.scene) === Number(tip.scene) && |
| String(state.previewTip?.revision) === String(tip.revision)); |
| if (selectedTip) row.classList.add("h3cm-branch-selected"); |
| if (tip) { |
| header.role = "button"; |
| header.tabIndex = 0; |
| header.title = `Select this whole branch (ends at scene ${tip.scene}); set start/end downstream`; |
| header.addEventListener("click", () => selectOutputBranch(tip)); |
| header.addEventListener("keydown", (event) => { |
| if (event.key !== "Enter" && event.key !== " ") return; |
| event.preventDefault(); |
| selectOutputBranch(tip); |
| }); |
| } |
| const name = element("span", branch.active ? "h3cm-branch-active" : "", branch.active ? "Project active branch" : branch.label); |
| const count = element("span", "h3cm-muted", `${branch.revisions.length} visible scene${branch.revisions.length === 1 ? "" : "s"}`); |
| header.append(name, count); |
| const path = element("div", "h3cm-branch-path"); |
| branch.revisions.forEach((revision, index) => { |
| if (index) path.append(element("span", "h3cm-arrow", "→")); |
| const key = checkpointRevisionKey(revision.scene, revision.revision); |
| const sharedCount = occurrences.get(key) ?? 1; |
| const card = button( |
| `S${revision.scene} · ${revision.revision.slice(0, 8)}`, |
| revision.prompt_preview || revision.scene_id, |
| () => selectRevision(revision, true, "", tip), "h3cm-revision", |
| ); |
| const selected = state.selected?.scene === revision.scene && |
| state.selected?.revision === revision.revision; |
| if (sharedCount > 1) { |
| card.classList.add("h3cm-revision-shared"); |
| card.dataset.sharedKey = key; |
| card.style.setProperty("--h3cm-shared-color", sharedColor(key)); |
| card.append(element( |
| "span", "h3cm-shared-label", |
| `shared ×${sharedCount}`, |
| )); |
| } |
| card.append(element("small", "", `${selected ? "selected · " : ""}${revision.active ? "saved active" : "saved inactive"}${revision.ready ? "" : " · broken"}`)); |
| if (localKeys.has(key)) card.append(element("small", "h3cm-local-label", "local output")); |
| if (selected) { |
| card.classList.add("h3cm-revision-selected"); |
| } |
| path.append(card); |
| const alternates = (revision.alternates ?? []).filter( |
| (alternate) => alternate.ready, |
| ); |
| if (alternates.length) { |
| const group = element("span", "h3cm-alternates"); |
| for (const alternate of alternates) { |
| const alt = button( |
| `ALT · ${String(alternate.revision).slice(0, 8)}`, |
| alternate.prompt_preview || alternate.prompt || |
| "Prompt-only editorial alternate", |
| () => selectRevision(alternate), |
| "h3cm-alternate", |
| ); |
| if (alternate.used_in_final_cut) { |
| alt.classList.add("h3cm-alternate-used"); |
| alt.append(element("small", "", "used in final cut")); |
| } else { |
| alt.append(element("small", "", "available take")); |
| } |
| if (state.selected?.scene === alternate.scene |
| && state.selected?.revision === alternate.revision) { |
| alt.classList.add("h3cm-revision-selected"); |
| } |
| group.append(alt); |
| } |
| path.append(group); |
| } |
| }); |
| const slot = branch.attribution_slot; |
| if ((slot?.candidates?.length || slot?.blocked_candidates?.length) |
| && tip && sceneVisible(slot.scene)) { |
| path.append(element("span", "h3cm-arrow", "→")); |
| const count = slot.candidates.length; |
| const empty = button( |
| `S${slot.scene} · reuse saved clip`, |
| `${count} independent saved candidate${count === 1 ? "" : "s"} can be attributed here`, |
| () => selectAttribution(tip, slot), |
| "h3cm-revision h3cm-revision-empty", |
| ); |
| empty.append(element( |
| "small", "", count ? `${count} available candidate${count === 1 ? "" : "s"}` |
| : "Check saved context requirements", |
| )); |
| if (state.attribution && |
| state.attribution.parent.revision === tip.revision) { |
| empty.classList.add("h3cm-revision-empty-selected"); |
| } |
| path.append(empty); |
| } |
| row.append(header, path); |
| container.append(row); |
| } |
| } |
|
|
| function variantCard(record, original = null, branchTip = null) { |
| const card = button(`S${record.scene} · ${record.revision.slice(0, 8)}`, |
| `${record.profile_path}\n${checkpointVariantLatentStatus(record)}`, |
| () => selectVariant(record, original, branchTip), "h3cm-revision h3cm-processing-variant"); |
| card.append(element("small", "", record.profile)); |
| card.append(element("small", "", `${record.width || "?"}×${record.height || "?"} · ${record.ready ? "saved" : "missing artifacts"}`)); |
| card.append(element("small", "", record.latent_saved ? "full latent saved" : "full latent not saved")); |
| if (currentVariant()?.key === record.key) card.classList.add("h3cm-revision-selected"); |
| return card; |
| } |
|
|
| function renderVariantBranchRows(container, rows) { |
| for (const branch of rows) { |
| const row = element("div", "h3cm-branch"); |
| const header = element("div", "h3cm-branch-head"); |
| header.append(element("span", branch.active ? "h3cm-branch-active" : "", |
| `Source: ${branch.active ? "Project active branch" : branch.label}`)); |
| const path = element("div", "h3cm-branch-path"); |
| branch.revisions.forEach((original, index) => { |
| if (index) path.append(element("span", "h3cm-arrow", "→")); |
| const group = element("div", "h3cm-variant-group"); |
| group.append(element("small", "h3cm-muted", `Original S${original.scene} · ${original.revision.slice(0, 8)}`)); |
| const records = checkpointStageVariants(state.payload, state.stage, original); |
| for (const record of records) group.append(variantCard(record, original, branch.revisions.at(-1))); |
| if (!records.length) group.append(button(`S${original.scene} · not saved`, |
| `No saved ${stageLabel()} version of this source revision`, |
| () => selectRevision(original, false), "h3cm-revision h3cm-revision-empty")); |
| path.append(group); |
| }); |
| row.append(header, path); |
| container.append(row); |
| } |
| } |
|
|
| function renderUnlinkedVariants() { |
| if (state.stage === "original") return; |
| const records = checkpointStageVariants(state.payload, state.stage, null, activeChapterRange()) |
| .filter(item => !(item.originals ?? []).length); |
| if (!records.length) return; |
| branches.append(element("div", "h3cm-muted", "Saved versions with an unavailable or mismatched original (not attached to another take)")); |
| const row = element("div", "h3cm-branch-path"); |
| for (const record of records) row.append(variantCard(record)); |
| branches.append(row); |
| } |
|
|
| function renderBranches() { |
| branches.replaceChildren(); |
| const ranges = chapterRanges(); |
| if (!ranges.length) { |
| const rows = checkpointBranchRows(state.payload); |
| if (rows.length) renderBranchRows(branches, rows); |
| else branches.append(element( |
| "div", "h3cm-muted", "No versioned checkpoints were found.", |
| )); |
| return; |
| } |
| const visibleRanges = state.chapterTab === "all" |
| ? ranges : ranges.filter((range) => range.id === state.chapterTab); |
| let rendered = 0; |
| for (const range of visibleRanges) { |
| const rows = checkpointChapterBranchRows(state.payload, range); |
| if (!rows.length) continue; |
| if (state.chapterTab === "all") { |
| const section = element("section", "h3cm-branch-chapter"); |
| const collapseKey = chapterCollapseKey(range); |
| const collapsed = state.collapsedChapters.has(collapseKey); |
| section.classList.toggle( |
| "h3cm-branch-chapter-collapsed", collapsed); |
| const heading = button( |
| "", |
| `${collapsed ? "Expand" : "Collapse"} ${range.title}`, |
| () => setChapterCollapsed(range, !collapsed), |
| "h3cm-branch-chapter-title", |
| ); |
| heading.setAttribute("aria-expanded", String(!collapsed)); |
| heading.append( |
| element("span", "h3cm-branch-chapter-caret", collapsed ? "▸" : "▾"), |
| element("span", "", range.title), |
| element("span", "h3cm-muted", `Scenes ${range.start}–${range.end}`), |
| ); |
| const body = element("div", "h3cm-branch-chapter-body"); |
| body.hidden = collapsed; |
| if (!collapsed) renderBranchRows(body, rows); |
| section.append(heading, body); |
| branches.append(section); |
| } else renderBranchRows(branches, rows); |
| rendered += rows.length; |
| } |
| if (!rendered) { |
| branches.append(element( |
| "div", "h3cm-muted", "No versioned checkpoints were found in this chapter.", |
| )); |
| } |
| } |
|
|
| function addInspector(label, value) { |
| inspector.append(element("dt", "", label), element("dd", "", value)); |
| } |
|
|
| function renderDetail() { |
| inspector.replaceChildren(); |
| attributionPanel.replaceChildren(); |
| attributionPanel.hidden = !state.attribution; |
| state.attributionButton = null; |
| const processing = state.stage !== "original"; |
| const record = processing ? currentVariant() : state.attribution?.candidate ?? state.selected; |
| if (!record) { |
| preview.removeAttribute("src"); |
| delete preview.dataset.source; |
| preview.load(); |
| audio.hidden = true; |
| audio.removeAttribute("src"); |
| delete audio.dataset.source; |
| prompt.textContent = processing ? (state.variantKey |
| ? "The previously browsed processing take is unavailable. Select a saved version; no other take has been substituted." |
| : `No saved ${stageLabel()} version for this source revision. The original clip has not been substituted.`) |
| : "Select a revision from the branch graph."; |
| return; |
| } |
| if (state.attribution) { |
| const attribution = state.attribution; |
| attributionPanel.append(element( |
| "div", "h3cm-attribution-title", |
| `Attribute an existing scene ${attribution.scene} candidate to branch ${attribution.parent.revision.slice(0, 8)}`, |
| )); |
| const candidates = element("div", "h3cm-attribution-candidates"); |
| for (const candidate of attribution.candidates) { |
| const choice = button( |
| `${candidate.revision.slice(0, 8)} · seed ${candidate.seed || "?"}`, |
| candidate.prompt_preview || candidate.scene_id, |
| () => { |
| attribution.candidate = candidate; |
| renderDetail(); |
| }, |
| ); |
| if (candidate.revision === record.revision) { |
| choice.classList.add("h3cm-attribution-candidate-selected"); |
| } |
| candidates.append(choice); |
| } |
| const attach = button( |
| "Attach selected candidate", |
| "Create a metadata-only lineage link; saved media and checkpoint files remain shared", |
| () => void attributeCandidate(), |
| ); |
| attach.disabled = state.busy || !attribution.candidate; |
| state.attributionButton = attach; |
| attributionPanel.append( |
| candidates, |
| element("div", "h3cm-muted", |
| attribution.candidate |
| ? "This candidate uses no predecessor video or generated-audio context. Attribution creates a new lineage link without regeneration or media duplication." |
| : "No reusable candidate is proven independent by its saved metadata."), |
| attach, |
| ); |
| for (const blocked of attribution.blocked ?? []) { |
| attributionPanel.append(element("div", "h3cm-muted", |
| `${blocked.revision.slice(0, 8)}: ${blocked.reason}`)); |
| } |
| } |
| const media = record.preview_video ?? record.video; |
| const nextVideo = videoUrl(media); |
| if (nextVideo && preview.dataset.source !== nextVideo) { |
| preview.src = nextVideo; |
| preview.dataset.source = nextVideo; |
| preview.load(); |
| } else if (!nextVideo) { |
| preview.removeAttribute("src"); |
| delete preview.dataset.source; |
| preview.load(); |
| } |
| const audioUrl = videoUrl(record.audio); |
| audio.hidden = !audioUrl; |
| if (audioUrl && audio.dataset.source !== audioUrl) { |
| audio.src = audioUrl; |
| audio.dataset.source = audioUrl; |
| audio.load(); |
| } else if (!audioUrl) { |
| audio.removeAttribute("src"); |
| delete audio.dataset.source; |
| } |
| if (processing) { |
| addInspector("Version", `${stageLabel()} · Scene ${record.scene} · ${record.revision}`); |
| addInspector("Profile", record.profile_path); |
| addInspector("State", record.ready ? "Saved files present (integrity checked at execution)" : `Missing: ${(record.missing_files ?? []).join(", ")}`); |
| addInspector("Original", (record.originals ?? []).map(item => `Scene ${item.scene} · ${item.revision.slice(0, 8)}`).join(", ") || record.source_status); |
| addInspector("Immediate source", record.source_revision || "Unknown"); |
| addInspector("Created", localTime(record.created_at)); |
| addInspector("Canvas", `${record.width || "?"}×${record.height || "?"} @ 24 fps`); |
| addInspector("Frames", `${record.raw_frames} raw · ${record.delivered_frames} delivered`); |
| addInspector("Latent", checkpointVariantLatentStatus(record)); |
| addInspector("Audio", record.audio_route); |
| addInspector("Storage", formatCheckpointBytes(record.size_bytes)); |
| addInspector("Metadata", record.metadata_path); |
| prompt.textContent = record.prompt || "No saved scene prompt."; |
| return; |
| } |
| addInspector("Identity", `${state.attribution ? "Candidate " : ""}Scene ${record.scene} · ${record.scene_id} · ${record.revision}`); |
| addInspector("State", record.take_kind === "editorial_alternate" |
| ? `Editorial alternate · ${record.used_in_final_cut ? "used in final cut" : "available"} · ${record.ready ? "Ready" : "Broken"}` |
| : `${record.active ? "Active generation checkpoint" : "Inactive generation checkpoint"} · ${record.ready ? "Ready" : "Broken"}`); |
| if (record.take_kind === "editorial_alternate") { |
| addInspector("Original base", `Scene ${record.scene} · ${String(record.alternate_of_revision).slice(0, 8)}`); |
| addInspector("Media", "Picture only · original audio and downstream lineage stay unchanged"); |
| addInspector("Use", "Select Original or ALT for this scene in Plan Studio; ALT cannot be loaded or activated as generation lineage"); |
| } |
| addInspector("Branches", (record.branches ?? []).map((item) => item.label).join(", ") || "Unresolved lineage"); |
| addInspector("Created", localTime(record.created_at)); |
| addInspector("Frames", `${record.raw_frames} raw · ${record.delivered_frames} delivered`); |
| addInspector("Sampling", `seed ${record.seed || "unknown"} · ${record.steps || "?"} steps`); |
| addInspector("Incoming", `${record.continuation_mode} · Video ${record.context_length}f · Audio ${record.audio_context_length}f`); |
| if (record.inactive_reason) addInspector("Inactive", record.inactive_reason); |
| addInspector("Parent", state.attribution |
| ? `Will become Scene ${state.attribution.parent.scene} · ${state.attribution.parent.revision.slice(0, 8)}` |
| : record.parent ? `Scene ${record.parent.scene} · ${record.parent.revision.slice(0, 8)}` : record.lineage_status); |
| addInspector("Following", (record.children ?? []).length |
| ? record.children.map(checkpointDependencyText).join(" · ") : "No dependent revision"); |
| addInspector("Storage", `${formatCheckpointBytes(record.size_bytes)}` + |
| `${record.shared_size_bytes ? ` · ${formatCheckpointBytes(record.shared_size_bytes)} shared` : ""}` + |
| ` · ${(record.missing_files ?? []).length ? `missing ${record.missing_files.join(", ")}` : "complete"}`); |
| const compatibility = record.compatibility ?? {}; |
| addInspector("Canvas", compatibility.width && compatibility.height |
| ? `${compatibility.width}×${compatibility.height} @ ${compatibility.fps ?? 24} fps` : "Unknown"); |
| addInspector("Audio mode", compatibility.audio_mode ?? "Unknown"); |
| addInspector("Encoding", [compatibility.encode_mode, compatibility.anchor_mode, |
| compatibility.crop].filter(Boolean).join(" · ") || "Unknown"); |
| addInspector("Metadata", record.metadata_path ?? "Unknown"); |
| prompt.textContent = record.prompt || record.prompt_preview || "No saved scene prompt."; |
| } |
|
|
| function renderDeletion() { |
| deletionBody.replaceChildren(); |
| retireButtons = []; |
| const processing = state.stage !== "original"; |
| const activationMode = selectedActivationMode(); |
| const rollsBack = !processing && activationMode === "rollback"; |
| remove.textContent = processing ? "Delete processed version" : "Delete selected revision"; |
| remove.title = processing ? "Preview and permanently delete only this processed take's owned files" : "Delete an inactive leaf or roll back the active branch tip after confirmation"; |
| deletion.classList.toggle("h3cm-delete-blocked", Boolean(state.deletion && !state.deletion.allowed)); |
| if (processing) { |
| deletionTitle.textContent = !state.deletion ? "Select a processed version to inspect deletion safety." |
| : state.deletion.allowed |
| ? `Delete processed version · ${state.deletion.owned_file_count} files · ${formatCheckpointBytes(state.deletion.reclaimed_bytes)} · originals kept` |
| : state.deletion.blockers?.join(" ") || "Deletion is blocked."; |
| activate.textContent = "Make branch active (project)"; |
| load.disabled = activate.disabled = true; |
| } else { |
| activate.textContent = rollsBack |
| ? "Roll active branch back (project)" : "Make branch active (project)"; |
| activate.title = rollsBack |
| ? "Project-wide: retire later active scene pointers in this chapter without deleting saved revisions" |
| : "Project-wide: promote this chapter for all workflows using this Run"; |
| deletionTitle.textContent = checkpointDeletionTitle(state.deletion); |
| load.disabled = state.busy || !canLoadSelected(); |
| activate.disabled = state.busy || !canActivateSelected(); |
| } |
| remove.disabled = state.busy || !state.deletion?.allowed; |
| if (state.attribution) { |
| load.disabled = true; |
| activate.disabled = true; |
| remove.disabled = true; |
| } |
| if (!state.deletion) return; |
| if (!processing && state.deletion.chapter_references?.length) { |
| const snapshots = element("div", "h3cm-delete-actions"); |
| for (const reference of state.deletion.chapter_references) { |
| if (reference.error || !reference.path || !reference.snapshot) continue; |
| const control = button( |
| `Retire Chapter ${reference.number} snapshot ${reference.snapshot.slice(0, 8)}…`, |
| "Preview releasing this snapshot's recovery pins. Its JSON is archived; no clips are deleted.", |
| () => void retireChapterSnapshot(reference), |
| ); |
| control.disabled = state.busy || Boolean(state.attribution); |
| retireButtons.push(control); |
| snapshots.append(control); |
| } |
| deletionBody.append(snapshots); |
| } |
| const files = (state.deletion.files ?? []).filter((item) => item.exists); |
| if (files.length) { |
| const list = element("ul", "h3cm-files"); |
| for (const file of files) { |
| list.append(element("li", file.shared ? "h3cm-muted" : "", |
| `${file.label} · ${formatCheckpointBytes(file.size_bytes)} · ${file.path}` + |
| `${file.shared ? " · shared, kept" : ""}`)); |
| } |
| deletionBody.append(list); |
| } |
| if (processing && state.deletion.retained_independent_takes?.length) { |
| deletionBody.append(element("div", "h3cm-muted", |
| "Independent pixel takes kept: " + state.deletion.retained_independent_takes.map(item => |
| `Scene ${item.scene} · ${String(item.revision).slice(0, 8)}`).join(", ") + |
| ". Affected sequence manifests are invalidated; rebuild missing scenes before full-sequence resume.")); |
| } |
| if (state.deletion.dependents?.length) { |
| const heading = element( |
| "div", "h3cm-error", |
| "Permanent deletion is blocked by dependent revisions:", |
| ); |
| if (rollsBack) { |
| deletionBody.append(element( |
| "div", "h3cm-muted", |
| "To continue from this scene, use Roll active branch back. It clears later active pointers but keeps every saved take.", |
| )); |
| } |
| const list = element("ul", "h3cm-dependents"); |
| for (const dependent of state.deletion.dependents) { |
| if (processing) { |
| const item = element("li", "h3cm-dependent", |
| `Scene ${dependent.scene ?? "?"} · ${String(dependent.revision ?? "").slice(0, 8)} · ${dependent.reason} · ${dependent.metadata_path}`); |
| item.addEventListener("click", () => { |
| const variant = (state.payload?.processing_variants ?? []).find(v => v.key === dependent.metadata_path); |
| if (variant) { selectStage(variant.stage); selectVariant(variant); } |
| }); |
| list.append(item); |
| continue; |
| } |
| const action = dependent.leaf |
| ? (dependent.active |
| ? " · active leaf: select to delete it" |
| : " · leaf: delete this first") |
| : ""; |
| const item = element("li", "h3cm-dependent", |
| `${checkpointDependencyText(dependent)}${action}`); |
| item.title = dependent.leaf && !dependent.active |
| ? "Select this deletable leaf checkpoint" |
| : dependent.leaf |
| ? "Select this active branch tip to inspect its rollback" |
| : "Select this dependent checkpoint to inspect its own descendants"; |
| item.addEventListener("click", () => { |
| const revision = selectedCheckpointRevision( |
| state.payload, dependent.scene, dependent.revision); |
| if (revision) selectRevision(revision); |
| }); |
| list.append(item); |
| } |
| deletionBody.append(heading, list); |
| } |
| if (state.deletion.not_deleted?.length) { |
| const kept = element("details", "h3cm-muted"); |
| kept.append(element("summary", "", "Always kept by this deletion")); |
| const list = element("ul", "h3cm-files"); |
| for (const label of state.deletion.not_deleted) { |
| list.append(element("li", "", label)); |
| } |
| kept.append(list); |
| deletionBody.append(kept); |
| } |
| } |
|
|
| function render() { |
| const total = state.payload?.summary; |
| summary.textContent = total |
| ? `${total.scene_count} scenes · ${total.revision_count} revisions · ${total.branch_count} branches · ${formatCheckpointBytes(total.bytes)}` |
| : "Select a saved run"; |
| renderOutputSelection(); |
| renderChapterTabs(); |
| renderStageTabs(); |
| renderScenes(); |
| renderBranches(); |
| renderUnlinkedVariants(); |
| renderDetail(); |
| renderDeletion(); |
| } |
|
|
| async function refreshDeletionPreview() { |
| const processing = state.stage !== "original"; |
| const record = processing ? currentVariant() : state.selected; |
| const token = ++state.requestToken; |
| if (!record || !state.runName || state.attribution) return; |
| deletionTitle.textContent = "Inspecting owned files and dependencies…"; |
| remove.disabled = true; |
| try { |
| const payload = await jsonRequest( |
| processing ? "/minimax_h3_context_loop/processing-checkpoints/delete-preview" |
| : "/minimax_h3_context_loop/checkpoint-revisions/delete-preview", { |
| method:"POST", headers:{"Content-Type":"application/json"}, |
| body:JSON.stringify({run_name:state.runName, scene:record.scene, revision:record.revision, |
| ...(processing ? {metadata_path:record.key} : {})}), |
| }); |
| if (token !== state.requestToken) return; |
| state.deletion = payload; |
| } catch (error) { |
| if (token !== state.requestToken) return; |
| state.deletion = null; |
| status.className = "h3cm-status h3cm-error"; |
| status.textContent = error.message; |
| } |
| renderDeletion(); |
| } |
|
|
| async function refreshCheckpoints() { |
| if (!state.runName) { |
| state.payload = null; |
| selectRevision(null, false); |
| return; |
| } |
| setBusy(true, "Scanning checkpoint metadata…"); |
| try { |
| const query = new URLSearchParams({ |
| run_name:state.runName, |
| cache_bust:String(Date.now()), |
| }); |
| state.payload = await jsonRequest( |
| `/minimax_h3_context_loop/checkpoints?${query}`, |
| {cache:"no-store"}, |
| ); |
| |
| |
| |
| |
| let savedOutput = null; |
| try { savedOutput = JSON.parse(selectionWidget?.value || "null"); } catch { } |
| const savedTip = savedOutput?.run_name === state.runName ? savedOutput.lineage?.at(-1) : null; |
| state.outputTip = savedTip |
| ? (state.payload.revisions ?? []).find(item => checkpointRevisionKey(item.scene, item.revision) |
| === checkpointRevisionKey(savedTip.scene, savedTip.revision)) ?? savedTip |
| : selectedCheckpointRevision(state.payload); |
| let selected = selectedCheckpointRevision( |
| state.payload, state.scene, state.revision); |
| if (state.stage === "original" && state.initialRefresh && !checkpointLocalSelection(selectionWidget?.value)) { |
| const activeTip = selectedCheckpointRevision(state.payload); |
| if (checkpointRevisionLineage( |
| state.payload, activeTip).length > |
| checkpointRevisionLineage( |
| state.payload, selected).length) { |
| selected = activeTip; |
| } |
| } |
| state.initialRefresh = false; |
| status.className = "h3cm-status"; |
| status.textContent = state.payload.summary?.broken_count |
| ? `${state.payload.summary.broken_count} broken revision${state.payload.summary.broken_count === 1 ? "" : "s"} found` |
| : "Checkpoint graph is current"; |
| selectRevision(selected, false, state.variantKey); |
| void refreshDeletionPreview(); |
| } catch (error) { |
| state.payload = null; |
| state.selected = null; |
| state.deletion = null; |
| status.className = "h3cm-status h3cm-error"; |
| status.textContent = error.message; |
| render(); |
| } finally { |
| setBusy(false); |
| } |
| } |
|
|
| async function refreshRuns() { |
| setBusy(true, "Scanning output/h3_chains…"); |
| try { |
| const payload = await jsonRequest("/minimax_h3_context_loop/runs"); |
| state.runs = payload.runs ?? []; |
| const connected = activePlanRun(); |
| const local = checkpointLocalSelection(selectionWidget?.value); |
| const preferred = local?.run_name || state.runName || connected; |
| if (local && state.initialRefresh) { |
| state.scene = local.lineage?.at(-1)?.scene ?? null; |
| state.revision = local.lineage?.at(-1)?.revision ?? ""; |
| } |
| state.runName = local ? preferred : state.runs.some((item) => item.run_name === preferred) |
| ? preferred : state.runs[0]?.run_name ?? ""; |
| runSelect.replaceChildren(); |
| for (const run of state.runs) { |
| const option = element("option", "", `${run.run_name} · ${run.checkpoint_count} active checkpoints`); |
| option.value = run.run_name; |
| runSelect.append(option); |
| } |
| if (local && !state.runs.some((item) => item.run_name === preferred)) { |
| const option = element("option", "", `${preferred} · pinned run unavailable`); |
| option.value = preferred; |
| runSelect.append(option); |
| } |
| runSelect.value = state.runName; |
| } catch (error) { |
| state.runs = []; |
| state.runName = ""; |
| runSelect.replaceChildren(); |
| status.className = "h3cm-status h3cm-error"; |
| status.textContent = error.message; |
| } finally { |
| setBusy(false); |
| } |
| await refreshCheckpoints(); |
| } |
|
|
| async function openFolder() { |
| if (!state.runName) return; |
| setBusy(true, "Opening run folder…"); |
| try { |
| const payload = await jsonRequest("/minimax_h3_context_loop/open-run-folder", { |
| method:"POST", headers:{"Content-Type":"application/json"}, |
| body:JSON.stringify({run_name:state.runName}), |
| }); |
| status.textContent = payload.opened ? "Opened on ComfyUI host" : payload.path; |
| } catch (error) { |
| status.className = "h3cm-status h3cm-error"; |
| status.textContent = error.message; |
| } finally { |
| setBusy(false); |
| } |
| } |
|
|
| async function deleteRunFolder() { |
| const runName = state.runName; |
| if (!runName || state.busy) return; |
| let plan; |
| setBusy(true, "Inspecting the complete run folder…"); |
| try { |
| plan = await jsonRequest( |
| "/minimax_h3_context_loop/run-folder/delete-preview", { |
| method:"POST", headers:{"Content-Type":"application/json"}, |
| body:JSON.stringify({run_name:runName}), |
| }); |
| } catch (error) { |
| status.className = "h3cm-status h3cm-error"; |
| status.textContent = error.message; |
| return; |
| } finally { |
| setBusy(false); |
| } |
| if (state.runName !== runName) return; |
| const confirmed = window.confirm( |
| `Delete the complete run folder "${runName}"?\n\n` + |
| `${plan.file_count} files · ${plan.directory_count} folders · ${formatCheckpointBytes(plan.reclaimed_bytes)}\n\n` + |
| `This permanently removes ${plan.folder}, including checkpoints, revisions, generated segments and audio, prompt history, archived workflows, reference backups, previews, and assembled exports.\n\n` + |
| "Original input project assets are kept. A second validation follows. This cannot be undone.", |
| ); |
| if (!confirmed) return; |
| const typed = window.prompt( |
| `Second validation: type the exact Run name to delete ${plan.folder}:\n\n${runName}`, |
| "", |
| ); |
| if (typed === null) return; |
| if (typed !== runName) { |
| status.className = "h3cm-status h3cm-error"; |
| status.textContent = "Run folder not deleted: the second validation did not exactly match the Run name."; |
| return; |
| } |
| setBusy(true, "Deleting the complete run folder…"); |
| try { |
| const payload = await jsonRequest( |
| "/minimax_h3_context_loop/run-folder/delete", { |
| method:"POST", headers:{"Content-Type":"application/json"}, |
| body:JSON.stringify({run_name:runName, |
| snapshot:plan.snapshot, confirmation:typed}), |
| }); |
| state.runName = ""; |
| state.scene = null; |
| state.revision = ""; |
| state.selected = null; |
| state.deletion = null; |
| state.payload = null; |
| persistSelection(); |
| await refreshRuns(); |
| status.className = "h3cm-status"; |
| status.textContent = `${payload.message} Reclaimed ${formatCheckpointBytes(payload.reclaimed_bytes)}. Original input project assets were kept.`; |
| } catch (error) { |
| status.className = "h3cm-status h3cm-error"; |
| status.textContent = error.payload?.preview |
| ? `${error.message} Click Delete run folder to review it again.` |
| : error.message; |
| } finally { |
| setBusy(false); |
| } |
| } |
|
|
| function restoreSavedPlanInputs(inputs, policyInputs = {}) { |
| const planNode = upstreamPlanNode(node); |
| if (!planNode || !inputs || typeof inputs !== "object") { |
| throw new Error("The saved run has no Plan inputs to restore."); |
| } |
| const names = Object.keys(inputs).sort((left, right) => |
| Number(left === "plan_json") - Number(right === "plan_json")); |
| const graph = planNode.graph ?? app.graph; |
| const applied = []; |
| graph?.beforeChange?.(); |
| try { |
| for (const name of names) { |
| const target = widget(planNode, name); |
| if (!target) continue; |
| target.value = inputs[name]; |
| target.callback?.(inputs[name]); |
| applied.push(name); |
| } |
| } finally { |
| graph?.afterChange?.(); |
| } |
| if (!applied.includes("plan_json")) { |
| throw new Error("The connected Plan does not expose an editable plan_json widget."); |
| } |
| restoreConnectedPolicyInputs(planNode, policyInputs); |
| refreshRestoredPlanEditors(planNode); |
| app.graph?.setDirtyCanvas?.(true, true); |
| return planNode; |
| } |
|
|
| function applyLoadedRevisions(planNode, revisions) { |
| const target = widget(planNode, "plan_json"); |
| if (!target) throw new Error("The connected Plan has no plan_json control."); |
| const plan = applyCheckpointRevisionSet( |
| parsePlanJson(String(target.value ?? "")), revisions, |
| ); |
| const value = planToJson(plan); |
| target.value = value; |
| target.callback?.(value); |
| refreshRestoredPlanEditors(planNode); |
| planNode.graph?.setDirtyCanvas?.(true, true); |
| for (const revision of revisions ?? []) { |
| const sceneIndex = Number(revision.scene) - 1; |
| if (sceneIndex < 0 || sceneIndex >= plan.shots.length) continue; |
| publishCompanionPrompt( |
| node, planNode, sceneIndex, |
| promptValueToText(plan.shots[sceneIndex]?.prompt), |
| ); |
| } |
| return plan; |
| } |
|
|
| function applyActivatedRevisions(planNode, revisions) { |
| const target = widget(planNode, "plan_json"); |
| if (!target) return false; |
| const plan = applyCheckpointRevisionSet( |
| parsePlanJson(String(target.value ?? "")), revisions, { |
| useEffectivePrompts: true, |
| useTipSharedPrompt: true, |
| }, |
| ); |
| const value = planToJson(plan); |
| target.value = value; |
| target.callback?.(value); |
| refreshRestoredPlanEditors(planNode); |
| planNode.graph?.setDirtyCanvas?.(true, true); |
| for (const revision of revisions ?? []) { |
| const sceneIndex = Number(revision.scene) - 1; |
| if (sceneIndex < 0 || sceneIndex >= plan.shots.length) continue; |
| publishCompanionPrompt( |
| node, planNode, sceneIndex, |
| promptValueToText(plan.shots[sceneIndex]?.prompt), |
| ); |
| } |
| return true; |
| } |
|
|
| function prepareResume(scene) { |
| const start = connectedNode(node, START_NAME); |
| const startClip = widget(start, "start_clip"); |
| if (!startClip) return false; |
| startClip.value = scene; |
| startClip.callback?.(scene); |
| const range = widget(start, "scene_range"); |
| if (range) { |
| range.value = ""; |
| range.callback?.(""); |
| } |
| start.graph?.setDirtyCanvas?.(true, true); |
| return true; |
| } |
|
|
| async function attributeCandidate() { |
| const attribution = state.attribution; |
| const candidate = attribution?.candidate; |
| const parent = attribution?.parent; |
| if (!candidate || !parent || state.busy) return; |
| const confirmed = window.confirm( |
| `Attribute scene ${candidate.scene} candidate ${candidate.revision.slice(0, 8)} after scene ${parent.scene} revision ${parent.revision.slice(0, 8)}?\n\n` + |
| "The candidate has no predecessor video or generated-audio dependency. A new immutable lineage record will be created; its existing video, audio, prompt, and checkpoint files remain shared. Nothing is regenerated or copied.", |
| ); |
| if (!confirmed) return; |
| setBusy(true, "Attributing saved candidate to branch…"); |
| try { |
| const payload = await jsonRequest( |
| "/minimax_h3_context_loop/checkpoint-revisions/attribute", { |
| method:"POST", headers:{"Content-Type":"application/json"}, |
| body:JSON.stringify({ |
| run_name:state.runName, |
| parent_scene:parent.scene, |
| parent_revision:parent.revision, |
| candidate_scene:candidate.scene, |
| candidate_revision:candidate.revision, |
| }), |
| }); |
| state.attribution = null; |
| state.scene = Number(payload.scene); |
| state.revision = String(payload.revision); |
| await refreshCheckpoints(); |
| |
| const attached = (state.payload?.revisions ?? []).find(item => |
| Number(item.scene) === Number(payload.scene) && item.revision === payload.revision); |
| if (attached) selectOutputBranch(checkpointOutputBranchTip( |
| state.payload, attached, chapterRangeFor(attached)) ?? attached); |
| status.className = "h3cm-status"; |
| status.textContent = payload.message; |
| } catch (error) { |
| status.className = "h3cm-status h3cm-error"; |
| status.textContent = error.message; |
| } finally { |
| setBusy(false); |
| } |
| } |
|
|
| async function loadSelected() { |
| const record = state.selected; |
| const lineage = selectedLineage(); |
| const scope = selectedChapterRange(); |
| if (!record || !canLoadSelected() || state.busy) return; |
| const planNode = upstreamPlanNode(node); |
| if (!planNode || !widget(planNode, "plan_json")) { |
| status.className = "h3cm-status h3cm-error"; |
| status.textContent = "Connect the Checkpoint Manager to an editable H3 Chain Plan first."; |
| return; |
| } |
| const confirmed = window.confirm( |
| `Load ${state.runName} through scene ${record.scene} revision ${record.revision.slice(0, 8)}?\n\n` + |
| "This activates the branch project-wide and restores the connected Plan. For output only, cancel and choose Use branch locally.\n\n" + |
| `${scope.title} scenes ${scope.start}–${scope.end} will use this branch. Other chapters keep their active checkpoint branches. Saved revision files are kept.`, |
| ); |
| if (!confirmed) return; |
| setBusy(true, "Loading saved Plan and checkpoint lineage…"); |
| try { |
| const runQuery = new URLSearchParams({ |
| run_name: state.runName, |
| include_assets: "false", |
| }); |
| const runBody = await jsonRequest( |
| `/minimax_h3_context_loop/run?${runQuery.toString()}`, |
| ); |
| const sameConnectedRun = activePlanRun() === state.runName; |
| const savedPlan = parsePlanJson(String(sameConnectedRun |
| ? widget(planNode, "plan_json")?.value ?? "" |
| : runBody.plan_inputs?.plan_json ?? "")); |
| const chapters = state.payload?.editorial?.chapters ?? []; |
| if (chapters.length) { |
| savedPlan.chapters = chapters.map((chapter) => ({ |
| id:chapter.id, |
| title:chapter.title, |
| start_scene_id:chapter.start_scene_id, |
| text:chapter.text ?? "", |
| })); |
| } |
| if (savedPlan.shots.length < Number(record.scene)) { |
| throw new Error( |
| `The saved Plan has only ${savedPlan.shots.length} scenes.`, |
| ); |
| } |
| const resumeScene = Number(record.scene) + 1; |
| if (resumeScene <= savedPlan.shots.length && |
| !widget(connectedNode(node, START_NAME), "start_clip")) { |
| throw new Error("Could not find the connected H3 Chain Loop Start node."); |
| } |
| const restored = await jsonRequest( |
| "/minimax_h3_context_loop/checkpoint-revisions/restore", { |
| method:"POST", headers:{"Content-Type":"application/json"}, |
| body:JSON.stringify({ |
| run_name:state.runName, |
| resume_scene:resumeScene, |
| revisions:lineage, |
| scope_start_scene:scope.start, |
| scope_end_scene:scope.end, |
| }), |
| }); |
| const activePlan = sameConnectedRun ? planNode |
| : restoreSavedPlanInputs( |
| {...runBody.plan_inputs, plan_json:planToJson(savedPlan)}, |
| restored.policy_inputs ?? runBody.policy_inputs, |
| ); |
| const plan = applyLoadedRevisions(activePlan, restored.restored ?? []); |
| const canResume = resumeScene <= plan.shots.length && |
| resumeScene <= scope.end; |
| if (canResume && !prepareResume(resumeScene)) { |
| throw new Error("Loaded the branch, but could not arm H3 Chain Loop Start."); |
| } |
| await refreshCheckpoints(); |
| status.className = "h3cm-status"; |
| status.textContent = canResume |
| ? `Loaded ${scope.title} scenes ${scope.start}–${record.scene}; Loop Start is armed for scene ${resumeScene}.` |
| : `Loaded ${scope.title} through scene ${record.scene}; other chapters were preserved.`; |
| } catch (error) { |
| status.className = "h3cm-status h3cm-error"; |
| status.textContent = error.message; |
| } finally { |
| setBusy(false); |
| } |
| } |
|
|
| async function activateSelected() { |
| const record = state.selected; |
| const lineage = selectedLineage(); |
| const scope = selectedChapterRange(); |
| const activationMode = selectedActivationMode(); |
| const rollsBack = activationMode === "rollback"; |
| if (!record || !canActivateSelected() || state.busy) return; |
| const confirmed = window.confirm( |
| `${rollsBack ? "Roll" : "Make"} ${scope.title} ${rollsBack ? "back" : "active"} through scene ${record.scene} revision ${record.revision.slice(0, 8)}?\n\n` + |
| "This changes the project-wide active branch for all workflows using this Run. Use branch locally changes only this manager's output.\n\n" + |
| `${rollsBack ? `Active pointers after scene ${record.scene} will be cleared. ` : ""}` + |
| `Only scenes ${scope.start}–${scope.end} are affected. Other chapters keep their active branches. If a Plan is connected, the selected chapter's saved scene settings are restored. No saved revision, workflow, reference, or assembled video is deleted.`, |
| ); |
| if (!confirmed) return; |
| setBusy(true, rollsBack |
| ? "Rolling active checkpoint branch back…" |
| : "Promoting selected checkpoint lineage…"); |
| try { |
| const payload = await jsonRequest( |
| "/minimax_h3_context_loop/checkpoint-revisions/restore", { |
| method:"POST", headers:{"Content-Type":"application/json"}, |
| body:JSON.stringify({ |
| run_name:state.runName, |
| resume_scene:Number(record.scene) + 1, |
| revisions:lineage, |
| activate_only:true, |
| scope_start_scene:scope.start, |
| scope_end_scene:scope.end, |
| }), |
| }); |
| const planNode = upstreamPlanNode(node); |
| const planUpdated = Boolean(planNode && |
| applyActivatedRevisions(planNode, payload.restored ?? [])); |
| await refreshCheckpoints(); |
| status.className = "h3cm-status"; |
| status.textContent = `${scope.title} ${rollsBack ? "rolled back" : "is now active"} through scene ${record.scene} revision ${record.revision.slice(0, 8)}. ` + |
| `${payload.retired_scope_pointers || 0} later pointer${payload.retired_scope_pointers === 1 ? " was" : "s were"} cleared inside this chapter; other chapters were preserved; all immutable revisions were kept` + |
| `${planUpdated ? "; connected Plan scene settings were restored." : "."}`; |
| } catch (error) { |
| status.className = "h3cm-status h3cm-error"; |
| status.textContent = error.message; |
| } finally { |
| setBusy(false); |
| } |
| } |
|
|
| async function retireChapterSnapshot(reference) { |
| const runName = state.runName, record = state.selected; |
| if (state.busy || state.stage !== "original" || state.attribution || !record) return; |
| setBusy(true, "Inspecting chapter snapshot retirement…"); |
| try { |
| const plan = await jsonRequest( |
| "/minimax_h3_context_loop/chapter-snapshots/retire-preview", { |
| method:"POST", headers:{"Content-Type":"application/json"}, |
| body:JSON.stringify({run_name:runName, path:reference.path}), |
| }); |
| |
| if (state.runName !== runName || state.selected !== record || state.stage !== "original") return; |
| const scenes = (plan.scenes ?? []).map(item => |
| `Scene ${item.scene} · ${String(item.revision).slice(0, 8)}${item.active ? " · currently active" : ""}`).join("\n"); |
| if (!window.confirm( |
| `Retire Chapter ${plan.chapter_number} snapshot ${plan.chapter_manifest_id.slice(0, 8)}?\n\n` + |
| `${scenes}\n\n${plan.message}\n\n` + |
| `Archive: ${plan.retired_path}\n\n` + |
| "This snapshot will no longer load in Chapter Loader or protect its old takes from cleanup. " + |
| "Workflows pinned to it need a new source. Deleting its inputs later makes full recovery unavailable. " + |
| "Other snapshots and branch dependencies remain protected.")) { |
| status.textContent = "Snapshot retirement cancelled; nothing changed."; |
| return; |
| } |
| const result = await jsonRequest( |
| "/minimax_h3_context_loop/chapter-snapshots/retire", { |
| method:"POST", headers:{"Content-Type":"application/json"}, |
| body:JSON.stringify({run_name:runName, path:plan.path, snapshot:plan.snapshot}), |
| }); |
| await refreshDeletionPreview(); |
| status.className = "h3cm-status"; |
| status.textContent = result.message; |
| } catch (error) { |
| await refreshDeletionPreview(); |
| status.className = "h3cm-status h3cm-error"; |
| status.textContent = error.message; |
| } finally { |
| setBusy(false); |
| } |
| } |
|
|
| async function deleteSelected() { |
| if (state.stage !== "original") return deleteProcessedVersion(); |
| const record = state.selected; |
| const plan = state.deletion; |
| if (!record || !plan?.allowed || state.busy) return; |
| const confirmed = window.confirm( |
| `${plan.rollback ? "Roll back and permanently delete" : "Permanently delete"} scene ${record.scene} revision ${record.revision.slice(0, 8)}?\n\n` + |
| `${plan.owned_file_count} owned files · ${formatCheckpointBytes(plan.reclaimed_bytes)}\n` + |
| `${plan.rollback ? (plan.rollback_to_scene > 0 |
| ? `The active chain will roll back through scene ${plan.rollback_to_scene}. ` |
| : "The run will have no active checkpoint scenes. ") : ""}` + |
| "Run archives, references, prompt history, and assembled exports are kept. This cannot be undone.", |
| ); |
| if (!confirmed) return; |
| setBusy(true, "Deleting staged revision files…"); |
| try { |
| const payload = await jsonRequest( |
| "/minimax_h3_context_loop/checkpoint-revisions/delete", { |
| method:"POST", headers:{"Content-Type":"application/json"}, |
| body:JSON.stringify({run_name:state.runName, scene:record.scene, |
| revision:record.revision, snapshot:plan.snapshot}), |
| }); |
| state.scene = payload.rollback ? payload.rollback_to_scene : state.scene; |
| state.revision = ""; |
| await refreshCheckpoints(); |
| status.className = "h3cm-status"; |
| status.textContent = `${payload.message} Reclaimed ${formatCheckpointBytes(payload.reclaimed_bytes)}.`; |
| } catch (error) { |
| state.deletion = error.payload?.preview ?? state.deletion; |
| status.className = "h3cm-status h3cm-error"; |
| status.textContent = error.message; |
| renderDeletion(); |
| } finally { |
| setBusy(false); |
| } |
| } |
|
|
| async function deleteProcessedVersion() { |
| const record = currentVariant(), plan = state.deletion, runName = state.runName; |
| if (state.busy || !record || !plan?.allowed || plan.metadata_path !== record.key) return; |
| const confirmed = window.confirm( |
| `Permanently delete ${stageLabel()} scene ${record.scene} take ${record.revision.slice(0, 8)} (${record.profile})?\n\n` + |
| `${plan.owned_file_count} files · ${formatCheckpointBytes(plan.reclaimed_bytes)}\n` + |
| "Its current processed pointer and affected branch manifests will be cleared. Original clips, shared references, other takes and assembled videos are kept. " + |
| (plan.retained_independent_takes?.length |
| ? "Later independent pixel clips are kept; rebuild missing scenes before full-sequence resume. " : "") + |
| "This cannot be undone."); |
| if (!confirmed) return; |
| setBusy(true, "Deleting processed version…"); |
| try { |
| const payload = await jsonRequest( |
| "/minimax_h3_context_loop/processing-checkpoints/delete", { |
| method:"POST", headers:{"Content-Type":"application/json"}, |
| body:JSON.stringify({run_name:runName, metadata_path:record.key, snapshot:plan.snapshot}), |
| }); |
| |
| await refreshCheckpoints(); |
| status.className = "h3cm-status"; |
| status.textContent = `${payload.message} Reclaimed ${formatCheckpointBytes(payload.reclaimed_bytes)}.`; |
| let selection; |
| try { selection = JSON.parse(selectionWidget?.value || "null"); } catch { } |
| if (selection?.processing_source?.branch?.lineage?.some(item => item.metadata_path === record.key)) { |
| status.textContent += " This workflow's output pin referenced the deleted take; explicitly select another source branch before running."; |
| } |
| if (payload.cleanup_pending?.length) status.textContent += ` Cleanup pending: ${payload.cleanup_pending.join(", ")}`; |
| } catch (error) { |
| state.deletion = error.payload?.preview ?? null; |
| status.className = "h3cm-status h3cm-error"; |
| status.textContent = error.message; |
| renderDeletion(); |
| } finally { |
| setBusy(false); |
| } |
| } |
|
|
| runSelect.addEventListener("change", () => { |
| if (checkpointLocalSelection(selectionWidget?.value)) { |
| if (!window.confirm("Switch runs and release this workflow's local output pin? The project active branches will not change.")) { |
| runSelect.value = state.runName; |
| return; |
| } |
| writeOutputSelection(""); |
| } |
| state.runName = runSelect.value; |
| state.payload = null; |
| state.selected = null; |
| state.outputTip = state.previewTip = null; |
| state.scene = null; |
| state.revision = ""; |
| persistSelection(); |
| void refreshCheckpoints(); |
| }); |
|
|
| const domWidget = node.addDOMWidget("h3_checkpoint_manager", "h3-checkpoint-manager", root, { |
| serialize:false, hideOnZoom:false, getMinHeight:() => 620, |
| }); |
| domWidget.serialize = false; |
| node.setSize?.([ |
| Math.max(Number(node.size?.[0]) || 0, 900), |
| Math.max(Number(node.size?.[1]) || 0, 760), |
| ]); |
| const connectionsChanged = node.onConnectionsChange; |
| node.onConnectionsChange = function () { |
| const result = connectionsChanged?.apply(this, arguments); |
| window.setTimeout(() => { |
| const connected = activePlanRun(); |
| if (connected && connected !== state.runName && !checkpointLocalSelection(selectionWidget?.value)) { |
| state.runName = connected; |
| void refreshRuns(); |
| } |
| }, 0); |
| return result; |
| }; |
| node._h3CheckpointManagerRefresh = () => void refreshRuns(); |
| node._h3CheckpointManagerConfigured = () => { |
| |
| |
| bindSelectionSerializer(); |
| restoreOutputScope(); |
| state.runName = String(node.properties[RUN_PROPERTY] ?? ""); |
| state.scene = Number(node.properties[SCENE_PROPERTY]) || null; |
| state.revision = String(node.properties[REVISION_PROPERTY] ?? ""); |
| state.chapterTab = String(node.properties[CHAPTER_PROPERTY] ?? "all"); |
| state.stage = CHECKPOINT_STAGES.some(item => item.id === node.properties[STAGE_PROPERTY]) |
| ? node.properties[STAGE_PROPERTY] : "original"; |
| state.variantKey = String(node.properties[VARIANT_PROPERTY] ?? ""); |
| state.initialRefresh = !state.scene || !state.revision; |
| }; |
| bindSelectionSerializer(); |
| const serialized = node.onSerialize; |
| node.onSerialize = function (saved) { |
| if (selectionWidget) selectionWidget.value = outputSelectionForScope(selectionWidget.value); |
| node.properties[OUTPUT_SCOPE_PROPERTY] = outputScope.value; |
| const result = serialized?.apply(this, arguments); |
| if (saved) { |
| saved.properties ??= {}; |
| saved.properties[OUTPUT_SCOPE_PROPERTY] = outputScope.value; |
| const index = node.widgets?.indexOf(selectionWidget) ?? -1; |
| if (index >= 0 && Array.isArray(saved.widgets_values)) saved.widgets_values[index] = selectionWidget.value; |
| if (selectionWidget && saved.widgets_values_named) saved.widgets_values_named.selection_json = selectionWidget.value; |
| } |
| return result; |
| }; |
| const removed = node.onRemoved; |
| node.onRemoved = function () { |
| return removed?.apply(this, arguments); |
| }; |
| void refreshRuns(); |
| } |
|
|
| app.registerExtension({ |
| name:"minimax_h3_context_loop.checkpoint_manager", |
| async beforeRegisterNodeDef(nodeTypeClass, nodeData) { |
| if (nodeData.name !== NODE_NAME) return; |
| const created = nodeTypeClass.prototype.onNodeCreated; |
| nodeTypeClass.prototype.onNodeCreated = function () { |
| const result = created?.apply(this, arguments); |
| window.setTimeout(() => mount(this), 0); |
| return result; |
| }; |
| const configured = nodeTypeClass.prototype.onConfigure; |
| nodeTypeClass.prototype.onConfigure = function () { |
| const result = configured?.apply(this, arguments); |
| this._h3CheckpointManagerConfigured?.(); |
| window.setTimeout(() => this._h3CheckpointManagerRefresh?.(), 0); |
| return result; |
| }; |
| }, |
| async nodeCreated(node) { |
| if (nodeType(node) === NODE_NAME) mount(node); |
| }, |
| }); |
|
|
