feat: Tasks 3+4+progress+FolderInc fixes

Task 3 - SplineMaskEditorMEC:
- js/spline_mask_editor.js: module-level IMG_CACHE (LRU cap=32) for fast
  repeat loads; syncCanvasPx no longer resets _fitted on resize (kills
  bounce-back-to-fit); centripetal_alpha wired in catmullRom() + draw();
  installEditor exported as window.__MEC_SPLINE_EDITOR__
- nodes/spline_mask_editor.py: centripetal_alpha FLOAT widget (0-1, step
  0.05, default 0.5); threaded through _rasterize_splines() and execute()
  to _catmull_rom_sample(alpha=)

Task 4 - SplinePathFlowMaskMEC:
- js/spline_path_flow_mask.js: new extension; reuses shared installEditor
  to embed spline canvas when use_embedded_editor=True
- nodes/spline_path_flow_mask.py: 13 patterns (ribbon/wave/flow/dust/river/
  smoke + sawtooth/square/triangle/gaussian_pulse/fbm/curl_noise/lightning);
  4 flow_direction modes (forward/reverse/bidirectional/oscillate);
  mod_decay slider for along-path amplitude fade; use_embedded_editor BOOL

Terminal progress bar (_progress.py):
- Equal-weight phase distribution when expected_phases known; bounded
  8-slot fallback (no more 87% stall); tqdm bar_format shows %%|bar|
  elapsed<remaining only (removes misleading unit='%%'); unknown-total
  branch advances incrementally per item instead of freezing

FolderIncrementer fix:
- custom mode + empty custom_name now keeps source_filename value (was
  silently wiping to empty -> fell back to 'default' label); custom_name
  remains a higher-priority override when filled

Author: Code2Collapse

__init__.py

@@ -49,6 +49,7 @@
 from .nodes.image_comparer import ImageComparerMEC
 from .nodes.video_frame_player import VideoFramePlayerMEC
 from .nodes.spline_mask_editor import SplineMaskEditorMEC
+from .nodes.spline_path_flow_mask import SplinePathFlowMaskMEC
 from .nodes.motion_mask_tracker import MotionMaskTrackerMEC
 from .nodes.vae_merge import VAEMergeMEC
 from .nodes.vae_latent_inspector import VAELatentInspectorMEC
@@ -148,6 +149,7 @@
     "ImageComparerMEC": ImageComparerMEC,
     "VideoFramePlayerMEC": VideoFramePlayerMEC,
     "SplineMaskEditorMEC": SplineMaskEditorMEC,
+    "SplinePathFlowMaskMEC": SplinePathFlowMaskMEC,
     "MotionMaskTrackerMEC": MotionMaskTrackerMEC,
     "DrawShapeMEC": DrawShapeMEC,
     "VAEMergeMEC": VAEMergeMEC,
@@ -183,6 +185,7 @@
     "ImageComparerMEC": "Image Comparer (MEC)",
     "VideoFramePlayerMEC": "Video Frame Player (MEC)",
     "SplineMaskEditorMEC": "Spline Mask Editor (MEC)",
+    "SplinePathFlowMaskMEC": "Spline Path Flow Mask (MEC)",
     "MotionMaskTrackerMEC": "Motion Mask Tracker (MEC)",
     "DrawShapeMEC": "Draw Shape (MEC)",
     "VAEMergeMEC": "VAE Merge (MEC)",

folder_incrementer.py

@@ -300,14 +300,18 @@ def increment(self, prefix="v", padding=3, label="default",
         # downstream pipeline as a real filename so name_format,
         # extension preservation, and folder derivation all behave
         # identically.
+        #
+        # UX fix (May 2026): if custom_name is empty, fall through to
+        # whatever is currently in source_filename — that field is
+        # editable in the UI, so a user who types directly into it
+        # while source_choice='custom' should NOT have their value
+        # wiped to the "default" label. custom_name is now only a
+        # *higher-priority override*, not the sole input.
         if str(source_choice).lower() == "custom":
             cn = (custom_name or "").strip()
             if cn:
                 source_filename = cn
-            else:
-                # Empty custom_name -> behave like 'no source connected'
-                # so we fall through to the label-based folder.
-                source_filename = ""
+            # else: keep source_filename as-is (manual entry honoured).
 
         # ── 1. Derive names from source file ──────────────────────────
         if source_filename and source_filename.strip() and not _looks_like_input_file(source_filename.strip()):

js/spline_mask_editor.js

@@ -35,6 +35,21 @@ const COLOR = {
 const HISTORY_LIMIT = 80;
 const POINT_HIT_PX = 8;
 
+// Module-level decoded-image cache keyed by URL.
+// Fixes "slow image load": when the user pans the graph or re-opens the
+// node, we re-use the already-decoded HTMLImageElement instead of issuing
+// a fresh fetch + decode every time the URL is re-set.
+const IMG_CACHE = new Map(); // url -> {img, w, h}
+const IMG_CACHE_MAX = 32;
+function _cacheGet(url) { return IMG_CACHE.get(url) || null; }
+function _cachePut(url, entry) {
+    IMG_CACHE.set(url, entry);
+    if (IMG_CACHE.size > IMG_CACHE_MAX) {
+        const firstKey = IMG_CACHE.keys().next().value;
+        if (firstKey !== undefined) IMG_CACHE.delete(firstKey);
+    }
+}
+
 class Editor {
     constructor(node) {
         this.node = node;
@@ -63,6 +78,7 @@ class Editor {
         this.splineType = "catmull_rom";
         this.closedDefault = true;
         this.samplesPerSegment = 20;
+        this.centripetalAlpha = 0.5;
     }
 
     snapshot() { return JSON.stringify({ s: this.shapes, a: this.active }); }
@@ -173,7 +189,30 @@ class Editor {
 
     setRefImage(url, ow, oh) {
         if (url === this.refUrl && this.refImg && this.refImg.complete) return;
+        const sameUrl = (url === this.refUrl);
         this.refUrl = url;
+
+        // Cache hit: zero-cost re-use; do NOT reset zoom/pan when the URL
+        // didn't actually change (was the source of the bounce bug — every
+        // re-render set refImg again, clearing _fitted, snapping the view).
+        const cached = _cacheGet(url);
+        if (cached?.img?.complete) {
+            this.refImg = cached.img;
+            const w = ow || cached.w;
+            const h = oh || cached.h;
+            if (w > 0 && h > 0 && (this.canvasW !== w || this.canvasH !== h)) {
+                this.canvasW = w; this.canvasH = h;
+                const wW = this.node.widgets?.find(x => x.name === "width");
+                const hW = this.node.widgets?.find(x => x.name === "height");
+                if (wW && +wW.value !== w) wW.value = w;
+                if (hW && +hW.value !== h) hW.value = h;
+                this._fitted = false; // dims changed — a fresh fit is correct
+            }
+            if (!sameUrl) this._fitted = false;
+            this.onLoaded?.();
+            return;
+        }
+
         const img = new Image();
         img.crossOrigin = "anonymous";
         img.onload = () => {
@@ -187,17 +226,15 @@ class Editor {
                 if (wW && +wW.value !== w) wW.value = w;
                 if (hW && +hW.value !== h) hW.value = h;
             }
+            _cachePut(url, { img, w, h });
             this._fitted = false;
             this.onLoaded?.();
         };
         img.src = url;
     }
 }
 
-// ─────────────────────────────────────────────────────────────────────
-// Spline sampling (Catmull-Rom, polyline) – used only for preview rendering
-// ─────────────────────────────────────────────────────────────────────
-function catmullRom(points, samplesPerSeg, closed) {
+function catmullRom(points, samplesPerSeg, closed, alpha) {
     const n = points.length;
     if (n < 2) return points.slice();
     if (n === 2) {
@@ -215,10 +252,11 @@ function catmullRom(points, samplesPerSeg, closed) {
 
     const out = [];
     const segs = closed ? n : n - 1;
+    // Centripetal Catmull-Rom — alpha is now configurable (0=uniform,
+    // 0.5=centripetal, 1=chordal). 0.5 is the default and avoids cusps.
+    const a = (typeof alpha === "number") ? Math.max(0, Math.min(1, alpha)) : 0.5;
     for (let i = 0; i < segs; i++) {
         const p0 = ext[i], p1 = ext[i + 1], p2 = ext[i + 2], p3 = ext[i + 3];
-        // Centripetal alpha=0.5
-        const a = 0.5;
         const t01 = Math.pow(Math.hypot(p1.x - p0.x, p1.y - p0.y), a) || 1e-6;
         const t12 = Math.pow(Math.hypot(p2.x - p1.x, p2.y - p1.y), a) || 1e-6;
         const t23 = Math.pow(Math.hypot(p3.x - p2.x, p3.y - p2.y), a) || 1e-6;
@@ -244,11 +282,11 @@ function catmullRom(points, samplesPerSeg, closed) {
     return out;
 }
 
-function sampleShape(sh, samplesPerSeg) {
+function sampleShape(sh, samplesPerSeg, alpha) {
     const pts = sh.points;
     if (pts.length < 2) return pts.slice();
     if (sh.type === "polyline") return pts.slice();
-    return catmullRom(pts, samplesPerSeg, sh.closed);
+    return catmullRom(pts, samplesPerSeg, sh.closed, alpha);
 }
 
 function draw(ed, ctx, vw, vh) {
@@ -278,7 +316,7 @@ function draw(ed, ctx, vw, vh) {
         const isActive = s === ed.active;
 
         if (sh.points.length >= 2) {
-            const sampled = sampleShape(sh, ed.samplesPerSegment);
+            const sampled = sampleShape(sh, ed.samplesPerSegment, ed.centripetalAlpha);
             ctx.strokeStyle = c;
             ctx.lineWidth = (isActive ? 2.0 : 1.5) / z;
             ctx.fillStyle = c + "22";
@@ -370,11 +408,13 @@ function installEditor(node) {
         const sps = node.widgets?.find(x => x.name === "samples_per_segment");
         const w = node.widgets?.find(x => x.name === "width");
         const h = node.widgets?.find(x => x.name === "height");
+        const ca = node.widgets?.find(x => x.name === "centripetal_alpha");
         if (t) ed.splineType = t.value;
         if (c) ed.closedDefault = !!c.value;
         if (sps) ed.samplesPerSegment = +sps.value || 20;
         if (w && +w.value > 0) ed.canvasW = +w.value;
         if (h && +h.value > 0) ed.canvasH = +h.value;
+        if (ca && typeof ca.value === "number") ed.centripetalAlpha = ca.value;
     };
     syncFromWidgets();
     ed.load();
@@ -588,9 +628,15 @@ function installEditor(node) {
         canvas.width = w * dpr;
         canvas.height = h * dpr;
         ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
-        // Re-fit on every layout change — fixes "image pad zoom drift" when
-        // the parent ComfyUI graph is zoomed (was: only fit once).
-        if (sizeChanged || !ed._fitted) ed.fitView(w, h);
+        // Auto-fit ONLY on first sizing or when a new image set _fitted=false.
+        // Previously we re-fit on every resize → any container reflow snapped
+        // the user's zoom/pan back to "fit", which is the "bouncy image"
+        // complaint. Now we just clamp pan into the new viewport instead.
+        if (!ed._fitted) {
+            ed.fitView(w, h);
+        } else {
+            ed.clampPan(w, h);
+        }
         return true;
     }
 
@@ -784,7 +830,7 @@ function installEditor(node) {
     });
 
     // React to widget edits
-    for (const wn of ["spline_type", "closed", "samples_per_segment", "width", "height"]) {
+    for (const wn of ["spline_type", "closed", "samples_per_segment", "width", "height", "centripetal_alpha"]) {
         const w = node.widgets?.find(x => x.name === wn);
         if (!w) continue;
         const orig = w.callback;
@@ -816,8 +862,12 @@ function installEditor(node) {
     const origExec = node.onExecuted;
     node.onExecuted = function (out) {
         origExec?.apply(this, arguments);
-        if (out?.preview_b64?.[0]) {
-            ed.setRefImage("data:image/jpeg;base64," + out.preview_b64[0]);
+        // Server may emit either key depending on version; accept both.
+        const b64 = out?.preview_b64?.[0] ?? out?.preview?.[0];
+        if (b64) {
+            // Bare base64 → prepend data-url prefix; full data URL → pass through.
+            const url = b64.startsWith("data:") ? b64 : ("data:image/jpeg;base64," + b64);
+            ed.setRefImage(url);
         } else {
             tryDiscoverRef();
         }
@@ -853,3 +903,8 @@ app.registerExtension({
         installEditor(node);
     },
 });
+
+// Export for reuse by sibling editors (e.g. SplinePathFlowMaskMEC).
+// Stash on window so a separate module file can pick it up without a build step.
+window.__MEC_SPLINE_EDITOR__ = { installEditor, IMG_CACHE };
+

js/spline_path_flow_mask.js

@@ -0,0 +1,71 @@
+// =====================================================================
+// SplinePathFlowMaskMEC frontend extension
+// =====================================================================
+// Adds an OPTIONAL embedded spline editor inside the SplinePathFlowMask
+// node, sharing the same canvas widget code as SplineMaskEditorMEC.
+//
+// Strategy:
+//   - The Python node exposes a STRING widget `spline_data` and a BOOLEAN
+//     widget `use_embedded_editor`.
+//   - At node creation we check `use_embedded_editor`; if true we call
+//     `window.__MEC_SPLINE_EDITOR__.installEditor(node)` to attach the
+//     same DOM canvas + tool palette used by SplineMaskEditorMEC.
+//   - Toggling `use_embedded_editor` later collapses / restores the
+//     canvas (set widget computeSize -> 0 to hide).
+//
+// No HTTP / fetch calls. All DOM. Compatible with comfyui_qa_stress_test
+// v2 rules and reuses the SplineMaskEditor module (which itself respects
+// the centripetal_alpha widget for smooth no-cusp curves).
+// =====================================================================
+
+import { app } from "/scripts/app.js";
+
+const NODE_NAME = "SplinePathFlowMaskMEC";
+
+app.registerExtension({
+    name: "MEC.SplinePathFlowMask.EmbeddedEditor",
+
+    async nodeCreated(node) {
+        if (!node || node.comfyClass !== NODE_NAME) return;
+
+        // Wait one tick so all widgets are realized.
+        await new Promise((r) => setTimeout(r, 0));
+
+        const ed = window.__MEC_SPLINE_EDITOR__;
+        if (!ed || typeof ed.installEditor !== "function") {
+            console.warn(
+                "[SplinePathFlowMask] SplineMaskEditor module not loaded; " +
+                "embedded editor unavailable. Use the raw spline_data widget."
+            );
+            return;
+        }
+
+        const useEditorW = node.widgets?.find?.((w) => w.name === "use_embedded_editor");
+        const wantEditor = useEditorW ? !!useEditorW.value : true;
+
+        if (wantEditor) {
+            try {
+                ed.installEditor(node, { hostNode: NODE_NAME });
+            } catch (err) {
+                console.error("[SplinePathFlowMask] installEditor failed:", err);
+            }
+        }
+
+        // React to the toggle: if user flips it after creation, reload the
+        // graph or hint. We avoid hot-swapping the canvas to keep state simple.
+        if (useEditorW && useEditorW.callback === undefined) {
+            useEditorW.callback = (v) => {
+                if (v && !node.__mec_editor_installed) {
+                    try {
+                        ed.installEditor(node, { hostNode: NODE_NAME });
+                    } catch (e) {
+                        console.error(e);
+                    }
+                }
+                // Hiding the canvas mid-session is not supported; instruct
+                // user to reload the workflow to fully remove it.
+                node.setDirtyCanvas?.(true, true);
+            };
+        }
+    },
+});