Release 0.1.1: Prompter Generate and measured workflow progress

CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 0.1.1 — 2026-09-28
+
+- Move Generate from the Generation Engine to the Prompter.
+- Add a softly glowing Prompter outline that fills from measured sampling and decoding progress across all requested images.
+- Wait for successful workflow completion before showing 100%; errors and cancellation retain their failure state.
+- Publish execution-specific progress events through ComfyUI's existing WebSocket, with handlers removed after every run.
+
 ## 0.1.0 — 2026-09-28
 
 Initial public DMAI NODES release, using the Slate design.

DMAI-NODES-v0.1.1.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:62652886fc8ac29d2de100d89692f57b74affd5583084da016ec826f4c6aafdd
+size 139204

DMAI-NODES-v0.1.1.zip.sha256

@@ -0,0 +1 @@
+62652886fc8ac29d2de100d89692f57b74affd5583084da016ec826f4c6aafdd  DMAI-NODES-v0.1.1.zip

README.md

@@ -14,7 +14,7 @@ tags:
 
 **A compact image workflow for ComfyUI.** Slate surfaces, clean Inter typography and English controls.
 
-**0.1.0 preview** · [GitHub releases](https://github.com/ceroomedia/DMAI-NODES/releases) · [Hugging Face download mirror](https://huggingface.co/ceroomedia/DMAI-NODES)
+**0.1.1 preview** · [GitHub releases](https://github.com/ceroomedia/DMAI-NODES/releases) · [Hugging Face download mirror](https://huggingface.co/ceroomedia/DMAI-NODES)
 
 Prompter → Generation Engine → Gallery, with an ordered LoRA Loader feeding the engine.
 
@@ -22,7 +22,7 @@ Prompter → Generation Engine → Gallery, with an ordered LoRA Loader feeding
 
 | Node | Purpose |
 | --- | --- |
-| **DMAI Prompter** | Prompt, 19 aspect ratios, 1K / 2K / Custom dimensions, image count and optional connected text. |
+| **DMAI Prompter** | Prompt, 19 aspect ratios, 1K / 2K / Custom dimensions, image count, Generate button and generation progress outline. |
 | **DMAI LoRA Loader** | Reorderable stack, enabled state, separate model/CLIP strengths and strict file checks. |
 | **DMAI Generation Engine** | Model profiles, DMAI Enhanced or Manual sampling, imported settings presets, seed sequence and execution report. |
 | **DMAI Gallery** | Persistent PNG originals, multiple selection, per-image download and selection ZIP. |
@@ -56,7 +56,7 @@ ZIP installation is also supported: extract the release so `ComfyUI/custom_nodes
 1. Import a starter from `workflows`: Krea, SDXL, Qwen or FLUX. Use the `.json` file for the UI and `.api.json` for API calls.
 2. Select installed model files in the Engine. Install any optional enhancement dependency needed by the selected preset.
 3. Enter the prompt and image count. Add LoRAs if needed.
-4. Choose **Generate**. Preview or download saved results from Gallery.
+4. Choose **Generate** in the Prompter. Its softly glowing outline follows generation across all requested images and reaches 100% when the workflow finishes. Preview or download saved results from Gallery.
 
 For Krea without the optional enhancer, choose **Krea / Clean Base** or Manual with Enhancer set to `none`. Models and LoRAs remain subject to their own licenses.
 
@@ -64,6 +64,7 @@ For Krea without the optional enhancer, choose **Krea / Clean Base** or Manual w
 
 - LoRAs are applied in their displayed order, before the Engine encodes both prompts. Disabled rows and rows with both strengths at zero are skipped; an active nonzero LoRA with zero effective patch matches raises an error. “Loaded” reports registered patches, not a completed image-quality test. See [advanced conditioning](docs/MODELS.md#advanced-connections) when encoding text upstream.
 - Image count is handled by the backend. Images use `seed`, `seed + 1`, and so on, modulo 2^64. The report stores the exact seeds as decimal strings.
+- Prompter progress follows native sampler updates, completed image decoding and workflow completion. Loading has no invented percentage; errors and cancellation never display successful completion. Optional connected text is still supported.
 - Gallery IDs are serialized in workflows. The new package uses separate storage under `output/DMAI-NODES`; existing DMAI Studio history is not deleted or automatically imported.
 - ZIP exports are limited to **100 images / 2 GiB**. Full-history selection uses a snapshot so later images are not silently added.
 - Invalid saved JSON remains visible for correction. It is not replaced by defaults.

dmai_nodes/__init__.py

@@ -1,2 +1,2 @@
 """DMAI NODES domain modules; importing these does not initialize a GPU."""
-__version__ = "0.1.0"
+__version__ = "0.1.1"

dmai_nodes/engine.py

@@ -310,7 +310,18 @@ def _prepare_input_latent(latent, model, request):
 
 
 def execute_engine(request, config, loras=None, *, sampler=None, sigmas=None,
-                   model=None, clip=None, vae=None, latent=None, positive=None, negative=None):
+                   model=None, clip=None, vae=None, latent=None, positive=None, negative=None,
+                   node_id=None):
+    from .progress import GenerationProgress
+    with GenerationProgress.from_comfy(node_id) as progress:
+        return _execute_engine(request, config, loras, sampler=sampler, sigmas=sigmas,
+                               model=model, clip=clip, vae=vae, latent=latent,
+                               positive=positive, negative=negative, progress=progress)
+
+
+def _execute_engine(request, config, loras=None, *, sampler=None, sigmas=None,
+                    model=None, clip=None, vae=None, latent=None, positive=None, negative=None,
+                    progress):
     """Render one image per seed, in order. Comfy interruptions propagate unchanged.
 
     The first public adapter uses standard EmptyLatentImage and KSampler. The
@@ -322,6 +333,7 @@ def execute_engine(request, config, loras=None, *, sampler=None, sigmas=None,
     from . import __version__ as package_version
     profile = get_profile(config["profile_id"])
     settings = config["settings"]
+    progress.configure(request["count"], settings["steps"])
     external_models = _external_model_inputs(model, clip, vae)
     if (positive is None) != (negative is None):
         raise ValueError("Connect positive and negative CONDITIONING together, or leave both disconnected.")
@@ -374,6 +386,7 @@ def execute_engine(request, config, loras=None, *, sampler=None, sigmas=None,
             from comfy_extras.nodes_custom_sampler import BasicScheduler
             sigmas = BasicScheduler.execute(model=model, scheduler=settings["scheduler"], steps=settings["steps"], denoise=settings["denoise"])[0]
             schedule = _sigma_schedule(sigmas)
+        progress.set_steps(schedule["steps"])
     # Both prompts must use the LoRA-patched encoder, in the same order as MODEL.
     if not external_conditioning:
         positive = _conditioning(nodes, profile, clip, request["prompt"], request)
@@ -389,6 +402,7 @@ def execute_engine(request, config, loras=None, *, sampler=None, sigmas=None,
             image_latent = nodes.EmptyLatentImage().generate(request["width"], request["height"], batch_size=1)[0]
         else:
             image_latent = {key: value.clone() if torch.is_tensor(value) else deepcopy(value) for key, value in prepared_latent.items()}
+        progress.begin_sampling(index)
         if not custom_sampling:
             samples = nodes.KSampler().sample(model=model, seed=image_seed, steps=settings["steps"], cfg=settings["cfg"],
                                              sampler_name=settings["sampler"], scheduler=settings["scheduler"],
@@ -400,11 +414,13 @@ def execute_engine(request, config, loras=None, *, sampler=None, sigmas=None,
                                            latent_image=image_latent)
             samples = result[0]
         interrupt()
+        progress.begin_decode()
         decoded = nodes.VAEDecode().decode(vae, samples)[0]
         if tuple(decoded.shape) != (1, request["height"], request["width"], 3):
             raise RuntimeError("The model returned unexpected image dimensions or count; generation stopped.")
         images.append(decoded.to(device="cpu"))
         image_report.append({"index": index, "seed": str(image_seed)})
+        progress.image_done()
     interrupt()
     preset_info = None
     if config["mode"] == "enhanced":

dmai_nodes/nodes.py

@@ -68,11 +68,12 @@ class DMAIGenerationEngine(io.ComfyNode):
                     io.Model.Input("model",optional=True,advanced=True),io.Clip.Input("clip",optional=True,advanced=True),io.Vae.Input("vae",optional=True,advanced=True),
                     io.Latent.Input("latent",optional=True,advanced=True),
                     io.Conditioning.Input("positive",optional=True,advanced=True),io.Conditioning.Input("negative",optional=True,advanced=True)],
-            outputs=[io.Image.Output(display_name="images"),ReportPort.Output(display_name="report")])
+            outputs=[io.Image.Output(display_name="images"),ReportPort.Output(display_name="report")],
+            hidden=[io.Hidden.unique_id])
 
     @classmethod
     def execute(cls,request,config_json,loras=None,sampler=None,sigmas=None,model=None,clip=None,vae=None,latent=None,positive=None,negative=None):
-        images,report=execute_engine(request,config_json,loras,sampler=sampler,sigmas=sigmas,model=model,clip=clip,vae=vae,latent=latent,positive=positive,negative=negative)
+        images,report=execute_engine(request,config_json,loras,sampler=sampler,sigmas=sigmas,model=model,clip=clip,vae=vae,latent=latent,positive=positive,negative=negative,node_id=getattr(cls.hidden,"unique_id",None))
         return io.NodeOutput(images,report,ui={"dmai_report":[report]})
 
     @classmethod

dmai_nodes/progress.py

@@ -0,0 +1,181 @@
+"""Scoped, execution-specific progress events without patching Comfy callbacks."""
+from __future__ import annotations
+
+import logging
+import math
+from uuid import uuid4
+
+logger = logging.getLogger(__name__)
+EVENT_NAME = "dmai_generation_progress"
+
+
+class GenerationProgress:
+    """Observe only this engine's native sampler updates while it is sampling.
+
+    Each image contributes its normalized sampler steps and one completed decode;
+    a final unit covers assembling the result. This measures completed work, not
+    elapsed time. Model loading remains indeterminate at zero. A sampler that
+    does not report native progress advances only when its call actually returns.
+    """
+
+    def __init__(self, *, registry=None, send=None, prompt_id=None, node_id=None,
+                 client_id=None, node_metadata=None):
+        self.name = f"dmai-generation-{uuid4().hex}"
+        self.enabled = registry is not None and send is not None and bool(prompt_id) and node_id is not None
+        self.registry = registry
+        self.send = send
+        self.prompt_id = str(prompt_id) if prompt_id is not None else None
+        self.node_id = str(node_id) if node_id is not None else None
+        self.client_id = client_id
+        self.node_metadata = node_metadata or {}
+        self.image_count = 1
+        self.image_index = 0
+        self.steps = 1
+        self.value = 0
+        self.maximum = 1
+        self.fraction = 0.0
+        self.phase = "preparing"
+        self._registered = False
+
+    @classmethod
+    def from_comfy(cls, node_id=None):
+        """Direct library calls without a Comfy execution context stay silent."""
+        try:
+            from comfy_execution.utils import get_executing_context
+            from comfy_execution.progress import get_progress_state
+            context = get_executing_context()
+            if context is None or not context.prompt_id:
+                return cls()
+            # Native execution IDs remain authoritative for expanded subgraphs.
+            context_node_id = str(context.node_id)
+            if node_id is not None and str(node_id) != context_node_id:
+                return cls()
+            registry = get_progress_state()
+            if str(registry.prompt_id) != str(context.prompt_id):
+                return cls()
+            from server import PromptServer
+            server = PromptServer.instance
+            if server is None:
+                return cls()
+            metadata = {}
+            for field in ("display_node_id", "parent_node_id", "real_node_id"):
+                resolver = getattr(registry.dynprompt, f"get_{field}", None)
+                if callable(resolver):
+                    metadata[field] = resolver(context_node_id)
+            return cls(registry=registry, send=server.send_sync, prompt_id=context.prompt_id,
+                       node_id=context_node_id, client_id=server.client_id, node_metadata=metadata)
+        except Exception:
+            # Progress must never change the outcome of generation.
+            logger.debug("DMAI generation progress is unavailable", exc_info=True)
+            return cls()
+
+    def __enter__(self):
+        if self.enabled:
+            try:
+                self.registry.register_handler(self)
+                self._registered = True
+            except Exception:
+                self.enabled = False
+                logger.debug("Could not register DMAI generation progress", exc_info=True)
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        try:
+            if exc_type is None:
+                self.phase = "complete"
+                self._emit(1.0)
+            else:
+                interrupted = isinstance(exc_value, InterruptedError) or any(
+                    base.__name__ == "InterruptProcessingException" for base in exc_type.__mro__)
+                self.phase = "interrupted" if interrupted else "error"
+                self._emit(self.fraction)
+        finally:
+            if self._registered:
+                try:
+                    self.registry.unregister_handler(self.name)
+                except Exception:
+                    logger.debug("Could not unregister DMAI generation progress", exc_info=True)
+                finally:
+                    self._registered = False
+            self.enabled = False
+        return False
+
+    def configure(self, image_count, steps):
+        self.image_count = image_count
+        self.steps = steps
+        self.maximum = steps
+        self._emit(0.0)
+
+    def set_steps(self, steps):
+        # Resolved external SIGMAS may replace the configured schedule.
+        self.steps = steps
+        self.maximum = steps
+
+    @property
+    def total_units(self):
+        return self.image_count * (self.steps + 1) + 1
+
+    def _image_units(self):
+        return self.image_index * (self.steps + 1)
+
+    def begin_sampling(self, index):
+        self.image_index = index
+        self.phase = "sampling"
+        self.value = 0
+        self.maximum = self.steps
+        self._emit(self._image_units() / self.total_units)
+
+    def begin_decode(self):
+        self.phase = "decoding"
+        self._emit((self._image_units() + self.steps) / self.total_units)
+
+    def image_done(self):
+        self.phase = "finalizing" if self.image_index + 1 == self.image_count else "decoding"
+        self._emit(((self.image_index + 1) * (self.steps + 1)) / self.total_units)
+
+    def _emit(self, fraction):
+        self.fraction = min(1.0, max(self.fraction, fraction))
+        if not self.enabled:
+            return
+        payload = {"prompt_id": self.prompt_id, "node_id": self.node_id,
+                   "phase": self.phase, "image_index": self.image_index,
+                   "image_count": self.image_count, "value": self.value,
+                   "max": self.maximum, "fraction": self.fraction,
+                   **self.node_metadata}
+        try:
+            self.send(EVENT_NAME, payload, self.client_id)
+        except Exception:
+            logger.debug("Could not send DMAI generation progress", exc_info=True)
+
+    def update_handler(self, node_id, value, max_value, state, prompt_id, image=None):
+        if (not self.enabled or self.phase != "sampling" or str(node_id) != self.node_id
+                or str(prompt_id) != self.prompt_id):
+            return
+        try:
+            value, maximum = float(value), float(max_value)
+        except (TypeError, ValueError, OverflowError):
+            return
+        if not math.isfinite(value) or not math.isfinite(maximum) or maximum <= 0:
+            return
+        self.value, self.maximum = max(0.0, min(value, maximum)), maximum
+        self._emit((self._image_units() + self.steps * self.value / maximum) / self.total_units)
+
+    # Implement the native ProgressHandler interface without importing Comfy at
+    # module import time, so lightweight package tooling remains usable.
+    def set_registry(self, registry):
+        self.registry = registry
+
+    def start_handler(self, node_id, state, prompt_id):
+        pass
+
+    def finish_handler(self, node_id, state, prompt_id):
+        pass
+
+    def reset(self):
+        self.enabled = False
+
+    def enable(self):
+        self.enabled = True
+
+    def disable(self):
+        self.enabled = False

docs/API.md

@@ -24,6 +24,43 @@ In a completed starter job, Gallery metadata is at `history[prompt_id]["outputs"
 
 Use seed strings for the full unsigned 64-bit range; JavaScript numbers cannot represent all of it exactly. Each image's exact seed is recorded in the Engine report. The CLI timeout only stops waiting; it does not cancel the job.
 
+## Generation progress over WebSocket
+
+Connect to ComfyUI's `/ws?clientId=<client ID>` before submitting the workflow. Use the same ID as `client_id` in `POST /prompt`. The Engine sends `dmai_generation_progress` messages to that client through ComfyUI's existing WebSocket:
+
+```json
+{
+  "type": "dmai_generation_progress",
+  "data": {
+    "prompt_id": "<queued prompt ID>",
+    "node_id": "3",
+    "phase": "sampling",
+    "image_index": 1,
+    "image_count": 2,
+    "value": 4,
+    "max": 8,
+    "fraction": 0.6842105263
+  }
+}
+```
+
+| Field | Meaning |
+| --- | --- |
+| `prompt_id` | Native ComfyUI execution ID; match it to the queued job. |
+| `node_id` | Native executing Engine ID. Expanded subgraphs may use a different ID from the visible graph. |
+| `phase` | `preparing`, `sampling`, `decoding`, `finalizing`, `complete`, `error` or `interrupted`. |
+| `image_index` / `image_count` | Zero-based current image index and total requested images. |
+| `value` / `max` | Current sampler progress counters; use them during `sampling`. |
+| `fraction` | Monotonic completed-work fraction from 0 to 1 across this Engine invocation. |
+
+When available, `display_node_id`, `real_node_id` and `parent_node_id` provide ComfyUI's native subgraph mapping. Clients must match both the job and the intended Engine; receiving an event for another node does not advance this Engine.
+
+The fraction normalizes each image's native sampler updates to its resolved step count, adds one unit after each completed decode, and reserves one final unit for assembling the Engine result. It measures completed work, not elapsed time. Model loading stays at zero. A sampler that emits no native progress advances only when its call returns; no timer simulates sampling progress. Internal VAE updates are excluded from the sampler counters.
+
+**Engine `complete` is not workflow completion.** Gallery or other downstream nodes may still be running. The Prompter caps its display at 99% until ComfyUI emits native `execution_success` for the same `prompt_id`, so saved results are available before 100% appears. Handle native `execution_error` and `execution_interrupted` as failure/cancellation, including failures after the Engine has finished. Cached Engines may emit no package progress events; use native execution events and `/history/{prompt_id}` to determine the job's final state.
+
+Progress observers exist only for the duration of Engine execution and are removed after success, failure or interruption. No additional WebSocket server is required.
+
 ## Package endpoints
 
 Routes are relative to ComfyUI's base URL. JSON responses use `{"ok": true, "data": ...}` or `{"ok": false, "error": ...}`. Downloads return file bytes.

docs/VALIDATION.md

@@ -1,4 +1,4 @@
-# Validation — 0.1.0 preview
+# Validation — 0.1.1 preview
 
 Checked on 2026-09-28. This release has working ComfyUI registration, CPU contract tests and real local API checks. GPU image generation is still pending.
 
@@ -14,8 +14,8 @@ Checked on 2026-09-28. This release has working ComfyUI registration, CPU contra
 
 | Check | Evidence |
 | --- | --- |
-| Python suite | 70 tests passed with optional real-Comfy CPU tests enabled. |
-| JavaScript suite | 19 tests passed: dimensions, exact seeds, ordered manifests, strength edits, mode persistence, sampler overrides, ZIP selection, keyboard containment and Comfy change events. |
+| Python suite | 81 tests passed with optional real-Comfy CPU tests enabled, including scoped native progress registry updates and multi-image progress. |
+| JavaScript suite | 38 tests passed: dimensions, exact seeds, ordered manifests, strength edits, mode persistence, sampler overrides, ZIP selection, keyboard containment, Comfy change events, progress presentation and job lifecycle handling. |
 | Node registration | All seven native V3 nodes appear in real `/object_info`. |
 | Runtime choices | Four model profiles, 45 native sampler names and 9 schedulers in the test installation. Extension installations can change these counts. |
 | LoRA loading | Four real CPU comparisons use tiny safetensors, Comfy's file loader, ModelPatcher and LoRA weight calculation. Results match the standard loader and expected low-rank math exactly. |
@@ -23,6 +23,9 @@ Checked on 2026-09-28. This release has working ComfyUI registration, CPU contra
 | Enhancer dependency | Both pinned upstream implementations, 1.1.0 and 1.4.2, pass source/signature checks and register the expected patch on a small test object. No model inference. |
 | Gallery | Real Comfy queue jobs save synthetic 64×64 PNGs. Two selected ZIP entries pass CRC and match original download bytes exactly. Unit tests cover history snapshots, cross-gallery rejection and missing originals. |
 | UI transport | Native Comfy merges `dmai_gallery` correctly; no second native image-preview payload is emitted. |
+| Progress transport | A real `/prompt` job and WebSocket emitted `preparing` then `error` with the correct prompt and Engine IDs when the optional enhancer was absent. No completion event was fabricated. |
+| Progress lifecycle | Automated tests cover cached jobs, subgraph identity, multiple Engine branches, queued-job removal, failure, cancellation, disconnect and cleanup. Only native workflow success reaches 100%. |
+| Progress browser check | Generate appears only in Prompter. A real Comfy execution failure re-enabled it and showed the actionable error. The production component harness displayed a 42% perimeter, disabled Generate while active, and restored it at 100% completion using explicitly labeled fixture states. |
 | Browser | Production panels render in real Comfy Canvas. Custom dimensions, image count, Manual/Enhanced round trips and native sampler/scheduler menus were exercised. Saving and reloading retained 1152×768, count 2, 22 steps, DPM++ 2M and Karras. Reordering retained LoRA model strength 0.65 and independent CLIP strength 0.4. Comfy's unsaved marker and Undo respond to edits. Two non-adjacent Gallery images could be selected. |
 
 The visual Gallery fixtures are solid-color test images, not generated model results.

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dmai-nodes"
-version = "0.1.0"
+version = "0.1.1"
 description = "Compact image workflows for ComfyUI: Prompter, ordered LoRAs, Generation Engine and Gallery."
 authors = [{name = "DMAI / ceroomedia"}]
 readme = "README.md"

release.json

@@ -1,6 +1,6 @@
 {
   "name": "DMAI NODES",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "channel": "preview",
   "license": "MIT",
   "comfyui_reference": "0.37.0",

tools/build_release.py

@@ -7,7 +7,7 @@ import shutil
 import zipfile
 
 ROOT=Path(__file__).resolve().parents[1]
-VERSION="0.1.0"
+VERSION="0.1.1"
 ROOT_FILES={"__init__.py","README.md","LICENSE","pyproject.toml","requirements.txt","THIRD_PARTY_NOTICES.md","CHANGELOG.md","release.json"}
 DIRECTORIES={"dmai_nodes","web","docs","resources","licenses","workflows"}
 FORBIDDEN={".git","__pycache__",".validation","node_modules","dist"}

web/dmai-nodes.js

@@ -4,6 +4,7 @@ import { envelope } from "./core.mjs";
 import { Prompter, LoRAStack } from "./inputs.mjs";
 import { Engine } from "./engine.mjs";
 import { Gallery } from "./gallery.mjs";
+import { GenerationProgress } from "./progress.mjs";
 
 const controllers = new WeakMap();
 const types = {
@@ -13,12 +14,32 @@ const types = {
   DMAIGallery: Gallery,
 };
 let bootstrapPromise;
+const progress = new GenerationProgress({
+  api,
+  getRootGraph: () => app.rootGraph ?? app.graph,
+});
+function* graphNodes(graph, visited = new Set()) {
+  if (!graph || visited.has(graph)) return;
+  visited.add(graph);
+  for (const node of graph._nodes ?? []) {
+    yield node;
+    if (node.subgraph) yield* graphNodes(node.subgraph, visited);
+  }
+}
 const context = {
   api,
   isConfiguring: () => Boolean(app.configuringGraph),
   beforeChange: () => app.canvas?.emitBeforeChange?.(),
   afterChange: () => app.canvas?.emitAfterChange?.(),
-  queue: () => app.queuePrompt(0, 1),
+  watchProgress: (node, callback) => progress.watch(node, callback),
+  generate: (node) => progress.generate(node, async () => {
+    for (const current of graphNodes(app.rootGraph ?? app.graph)) {
+      const controller = controllers.get(current);
+      if (controller instanceof Engine && !controller.disposed && !controller.commitControls())
+        throw new Error("Check the Generation Engine settings before generating.");
+    }
+    return app.queuePrompt(0, 1);
+  }),
   bootstrap(refresh = false) {
     if (refresh || !bootstrapPromise)
       bootstrapPromise = envelope(api, "/bootstrap").catch((error) => {
@@ -43,7 +64,7 @@ function install(node) {
   }
 }
 function refreshGraph() {
-  for (const node of app.graph?._nodes ?? []) {
+  for (const node of graphNodes(app.rootGraph ?? app.graph)) {
     install(node);
     controllers.get(node)?.hydrate();
   }
@@ -51,6 +72,7 @@ function refreshGraph() {
 app.registerExtension({
   name: "DMAI.Nodes.Slate",
   setup() {
+    progress.start();
     const href = new URL("./nodes.css", import.meta.url).href;
     if (!document.querySelector("link[data-dmai-nodes]")) {
       const link = document.createElement("link");

web/engine.mjs

@@ -400,25 +400,6 @@ export class Engine extends Controller {
         ),
       );
     this.body.append(advanced.root);
-    this.runButton = button(
-      "Generate",
-      "play",
-      () =>
-        this.guard(async () => {
-          if (!this.commitControls()) return;
-          this.runButton.disabled = true;
-          try {
-            await this.context.queue();
-            this.note("Workflow queued.");
-          } finally {
-            if (!this.disposed) this.runButton.disabled = false;
-          }
-        }),
-      true,
-    );
-    this.runButton.classList.add("dmai-primary", "dmai-generate");
-    this.runButton.disabled = !profile;
-    this.body.append(this.runButton);
     if (this.data && !profile)
       this.error(
         new Error(

web/inputs.mjs

@@ -15,12 +15,22 @@ import {
   moveEntry,
   uid,
 } from "./core.mjs";
+import { ProgressView, progressPresentation } from "./progress-view.mjs";
 
 export class Prompter extends Controller {
   constructor(node, context) {
     super(node, "config_json", "Prompter", "text", context);
-    this.size(360, 350);
+    this.root.classList.add("dmai-prompter");
+    const scroll = el("div", "dmai-prompter-scroll");
+    scroll.append(...this.root.childNodes);
+    this.root.append(scroll);
+    this.progress = { phase: "idle", percent: 0 };
+    this.progressView = new ProgressView(this.root);
+    this.size(360, 400);
     this.hydrate();
+    this.stopProgress = context.watchProgress?.(node, (state) => {
+      if (!this.disposed) this.updateProgress(state);
+    });
   }
   hydrate() {
     if (this.disposed) return;
@@ -90,7 +100,55 @@ export class Prompter extends Controller {
     });
     advanced.body.append(negative);
     this.body.append(advanced.root);
+    this.runButton = button(
+      "Generate",
+      "play",
+      () => this.generate(),
+      true,
+    );
+    this.runButton.classList.add("dmai-primary", "dmai-generate");
+    this.body.append(this.runButton, this.progressView.readout);
     this.sync();
+    this.renderProgress();
+  }
+  updateProgress(state) {
+    if (this.progress?.phase === "error" && progressPresentation(state).busy)
+      this.note();
+    this.progress = state;
+    if (state.phase === "error" && state.message)
+      this.error(new Error(state.message));
+    this.renderProgress();
+  }
+  renderProgress() {
+    const view = this.progressView.update(this.progress);
+    if (this.runButton) this.runButton.disabled = Boolean(this.queuePending || view.busy);
+  }
+  async generate() {
+    if (this.queuePending || progressPresentation(this.progress).busy || this.disposed) return;
+    return this.guard(async () => {
+      this.queuePending = true;
+      this.note();
+      this.renderProgress();
+      try {
+        await this.context.generate(this.node);
+      } catch (error) {
+        this.updateProgress({
+          phase: "error",
+          percent: this.progress?.percent ?? 0,
+          message: error?.message ?? String(error),
+        });
+        throw error;
+      } finally {
+        this.queuePending = false;
+        if (!this.disposed) this.renderProgress();
+      }
+    });
+  }
+  dispose() {
+    if (this.disposed) return;
+    this.stopProgress?.();
+    this.progressView?.dispose();
+    super.dispose();
   }
   intent() {
     const v = this.node.properties?.dmai_format;

web/nodes.css

@@ -646,3 +646,70 @@
     animation: none !important;
   }
 }
+
+/* The outline stays inside the node so real Comfy sockets remain unobstructed. */
+.dmai-panel.dmai-prompter {
+  overflow: hidden;
+}
+.dmai-nodes .dmai-prompter-scroll {
+  width: 100%;
+  height: 100%;
+  overflow: auto;
+  scrollbar-width: thin;
+  scrollbar-color: #4b584e transparent;
+  border-radius: inherit;
+}
+.dmai-nodes .dmai-progress-outline {
+  position: absolute;
+  inset: 0;
+  width: 100%;
+  height: 100%;
+  pointer-events: none;
+  z-index: 2;
+  overflow: visible;
+  fill: none;
+}
+.dmai-nodes .dmai-progress-track {
+  stroke: var(--dmai-accent);
+  stroke-width: 1;
+  opacity: 0.13;
+}
+.dmai-nodes .dmai-progress-stroke {
+  stroke: var(--dmai-accent);
+  stroke-width: 2;
+  stroke-linecap: round;
+  transition: stroke-dashoffset 350ms ease-out;
+  filter: drop-shadow(0 0 3px #c8ee9966);
+}
+.dmai-nodes[data-generating="true"] .dmai-progress-stroke {
+  animation: dmai-progress-glow 2.4s ease-in-out infinite;
+}
+.dmai-nodes[data-generation-phase="queued"] .dmai-progress-stroke {
+  transition: none;
+}
+.dmai-nodes .dmai-progress-readout {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  gap: 12px;
+  margin-top: 9px;
+  color: var(--dmai-muted);
+  font-size: 10px;
+}
+.dmai-nodes .dmai-progress-value {
+  font-variant-numeric: tabular-nums;
+  color: var(--dmai-accent);
+}
+.dmai-nodes[data-generation-phase="error"] .dmai-progress-stroke,
+.dmai-nodes[data-generation-phase="interrupted"] .dmai-progress-stroke {
+  stroke: #edb89e;
+  filter: none;
+}
+.dmai-nodes[data-generation-phase="error"] .dmai-progress-value,
+.dmai-nodes[data-generation-phase="interrupted"] .dmai-progress-value {
+  color: #edb89e;
+}
+@keyframes dmai-progress-glow {
+  0%, 100% { opacity: 0.72; }
+  50% { opacity: 1; }
+}

web/progress-view.mjs

@@ -0,0 +1,100 @@
+const PHASES = {
+  idle: "",
+  queued: "Queued",
+  loading: "Loading",
+  sampling: "Generating",
+  decoding: "Decoding",
+  saving: "Saving",
+  complete: "Complete",
+  error: "Failed",
+  interrupted: "Stopped",
+};
+const ACTIVE = new Set(["queued", "loading", "sampling", "decoding", "saving"]);
+
+export function progressPresentation(state = {}) {
+  const phase = Object.hasOwn(PHASES, state.phase) ? state.phase : "idle";
+  const busy = ACTIVE.has(phase);
+  const measured = typeof state.percent === "number" && Number.isFinite(state.percent)
+    ? Math.max(0, Math.min(100, state.percent)) : 0;
+  // A full border means the workflow completed, including decode and save.
+  const percent = phase === "complete" ? 100 : Math.min(measured, 99.9);
+  return {
+    phase,
+    percent: phase === "idle" ? 0 : percent,
+    busy,
+    label: PHASES[phase],
+    visible: phase !== "idle",
+    value: phase === "complete" ? 100 : Math.floor(percent),
+  };
+}
+
+export function perimeterPath(width, height) {
+  const w = Math.max(8, Number.isFinite(width) ? width : 8);
+  const h = Math.max(8, Number.isFinite(height) ? height : 8);
+  const inset = 2, right = w - inset, bottom = h - inset;
+  const r = Math.min(10, (w - 4) / 2, (h - 4) / 2);
+  // Start at the top centre and follow the actual, rounded panel clockwise.
+  return `M ${w / 2} ${inset} H ${right - r} Q ${right} ${inset} ${right} ${inset + r} V ${bottom - r} Q ${right} ${bottom} ${right - r} ${bottom} H ${inset + r} Q ${inset} ${bottom} ${inset} ${bottom - r} V ${inset + r} Q ${inset} ${inset} ${inset + r} ${inset} H ${w / 2}`;
+}
+
+export class ProgressView {
+  constructor(panel) {
+    this.panel = panel;
+    this.svg = document.createElementNS("http://www.w3.org/2000/svg", "svg");
+    this.svg.classList.add("dmai-progress-outline");
+    this.svg.setAttribute("aria-hidden", "true");
+    this.svg.setAttribute("focusable", "false");
+    this.track = document.createElementNS(this.svg.namespaceURI, "path");
+    this.track.classList.add("dmai-progress-track");
+    this.stroke = document.createElementNS(this.svg.namespaceURI, "path");
+    this.stroke.classList.add("dmai-progress-stroke");
+    this.stroke.setAttribute("pathLength", "100");
+    this.stroke.setAttribute("stroke-dasharray", "100");
+    this.stroke.setAttribute("stroke-dashoffset", "100");
+    this.svg.append(this.track, this.stroke);
+    panel.append(this.svg);
+    this.readout = document.createElement("div");
+    this.readout.className = "dmai-progress-readout";
+    this.readout.setAttribute("role", "progressbar");
+    this.readout.setAttribute("aria-label", "Image generation progress");
+    this.readout.setAttribute("aria-valuemin", "0");
+    this.readout.setAttribute("aria-valuemax", "100");
+    this.label = document.createElement("span");
+    this.value = document.createElement("span");
+    this.value.className = "dmai-progress-value";
+    this.readout.append(this.label, this.value);
+    this.resize = () => {
+      const width = panel.clientWidth, height = panel.clientHeight;
+      if (!width || !height) return;
+      this.svg.setAttribute("viewBox", `0 0 ${width} ${height}`);
+      const path = perimeterPath(width, height);
+      this.track.setAttribute("d", path);
+      this.stroke.setAttribute("d", path);
+    };
+    if (typeof ResizeObserver !== "undefined") {
+      this.observer = new ResizeObserver(this.resize);
+      this.observer.observe(panel);
+    }
+    this.resize();
+    this.update();
+  }
+  update(state) {
+    const view = progressPresentation(state);
+    this.panel.dataset.generationPhase = view.phase;
+    this.panel.dataset.generating = String(view.busy);
+    this.panel.setAttribute("aria-busy", String(view.busy));
+    this.svg.style.visibility = view.visible ? "visible" : "hidden";
+    this.stroke.style.strokeDashoffset = String(100 - view.percent);
+    this.readout.hidden = !view.visible;
+    this.readout.setAttribute("aria-valuenow", String(view.value));
+    this.readout.setAttribute("aria-valuetext", `${view.label}, ${view.value}%`);
+    this.label.textContent = view.label;
+    this.value.textContent = `${view.value}%`;
+    return view;
+  }
+  dispose() {
+    this.observer?.disconnect();
+    this.svg.remove();
+    this.readout.remove();
+  }
+}

web/progress.mjs

@@ -0,0 +1,361 @@
+// Job identity comes from the submitted API graph, never the current selection.
+const IDLE = Object.freeze({ phase: "idle", percent: 0 });
+const ACTIVE = new Set(["queued", "loading", "sampling", "decoding", "saving"]);
+const PHASES = { preparing: "loading", sampling: "sampling", decoding: "decoding", finalizing: "saving", complete: "saving" };
+const MAX_JOBS = 64;
+
+function resolveNode(root, executionId) {
+  const parts = String(executionId).split(":");
+  let graph = root;
+  for (let index = 0; index < parts.length; index++) {
+    const node = graph?.getNodeById?.(parts[index]);
+    if (!node) return null;
+    if (index === parts.length - 1) return node;
+    graph = node.subgraph;
+  }
+  return null;
+}
+
+function connections(entry) {
+  if (!Array.isArray(entry) || entry.length < 5) return null;
+  const [, id, prompt, extra, outputs] = entry;
+  const workflowId = extra?.extra_pnginfo?.workflow?.id;
+  if (typeof workflowId !== "string" || !workflowId || !prompt || typeof prompt !== "object" || !Array.isArray(outputs)) return null;
+  const reachable = new Set(), pending = outputs.map(String);
+  while (pending.length) {
+    const nodeId = pending.pop();
+    if (reachable.has(nodeId) || !prompt[nodeId]) continue;
+    reachable.add(nodeId);
+    for (const value of Object.values(prompt[nodeId].inputs ?? {})) {
+      if (Array.isArray(value) && value.length === 2 && prompt[String(value[0])]) pending.push(String(value[0]));
+    }
+  }
+  const sources = new Map();
+  for (const engineId of reachable) {
+    const engine = prompt[engineId], link = engine.inputs?.request;
+    if (engine.class_type !== "DMAIGenerationEngine" || !Array.isArray(link)) continue;
+    const sourceId = String(link[0]);
+    if (prompt[sourceId]?.class_type !== "DMAIPrompter") continue;
+    if (!sources.has(sourceId)) sources.set(sourceId, new Set());
+    sources.get(sourceId).add(engineId);
+  }
+  return { id: String(id), workflowId, sources, clientId: extra?.client_id };
+}
+
+export class GenerationProgress {
+  constructor({ api, getRootGraph }) {
+    this.api = api;
+    this.getRootGraph = getRootGraph;
+    this.records = new Map();
+    this.jobs = new Map();
+    this.listeners = [];
+    this.timers = new Map();
+    this.epoch = 0;
+    this.sequence = 0;
+    this.disposed = false;
+  }
+
+  start() {
+    if (this.listeners.length || this.disposed) return;
+    const listen = (name, handler) => {
+      const listener = (event) => handler(event.detail ?? {});
+      this.api.addEventListener(name, listener);
+      this.listeners.push([name, listener]);
+    };
+    listen("execution_start", (data) => {
+      const job = this.job(data.prompt_id);
+      if (!job || job.terminal) return;
+      job.started = true;
+      void this.lookup(job);
+      this.renderJob(job);
+    });
+    listen("dmai_generation_progress", (data) => {
+      const job = this.job(data.prompt_id);
+      if (!job || job.terminal || data.node_id == null) return;
+      job.started = true;
+      const engineId = String(data.node_id), previous = job.progress.get(engineId);
+      if (typeof data.fraction !== "number" || !Number.isFinite(data.fraction)) return;
+      job.progress.set(engineId, {
+        fraction: Math.max(previous?.fraction ?? 0, Math.min(1, Math.max(0, data.fraction))),
+        phase: PHASES[data.phase] ?? "loading",
+      });
+      if (data.phase === "error" || data.phase === "interrupted") job.terminal = data.phase;
+      if (!job.context) void this.lookup(job);
+      this.renderJob(job);
+    });
+    listen("execution_cached", (data) => {
+      const job = this.job(data.prompt_id);
+      if (!job || job.terminal) return;
+      for (const id of data.nodes ?? []) job.cached.add(String(id));
+      if (!job.context) void this.lookup(job);
+      this.renderJob(job);
+    });
+    listen("promptQueued", () => {
+      const epoch = this.epoch;
+      void this.read("/queue").then((queue) => {
+        if (!this.disposed && epoch === this.epoch) this.captureQueue(queue);
+      });
+    });
+    listen("status", (data) => {
+      if (Number.isFinite(data?.exec_info?.queue_remaining)) void this.reconcilePending();
+    });
+    for (const [event, phase] of [["execution_success", "complete"], ["execution_error", "error"], ["execution_interrupted", "interrupted"]]) {
+      listen(event, (data) => {
+        const job = this.job(data.prompt_id);
+        if (!job) return;
+        // A success event must never overwrite an already observed failure.
+        if (phase === "complete" && (job.terminal === "error" || job.terminal === "interrupted")) return;
+        job.terminal = phase;
+        job.message = phase === "error" ? data.exception_message || "Generation failed." : undefined;
+        void this.lookup(job, true);
+        this.renderJob(job);
+      });
+    }
+    listen("reconnecting", () => this.disconnect());
+  }
+
+  watch(node, callback) {
+    if (this.disposed) return () => {};
+    let record = this.records.get(node);
+    if (!record) {
+      record = { node, callbacks: new Set(), state: IDLE, submission: null };
+      this.records.set(node, record);
+      for (const job of this.jobs.values()) if (!job.terminal) this.bind(job);
+    }
+    record.callbacks.add(callback);
+    callback(record.state);
+    this.renderRecord(record);
+    return () => {
+      record.callbacks.delete(callback);
+      if (!record.callbacks.size) {
+        this.records.delete(node);
+        for (const job of this.jobs.values()) job.bindings.delete(record);
+      }
+    };
+  }
+
+  async generate(node, queueFn) {
+    this.start();
+    const record = this.records.get(node);
+    if (!record || this.disposed) throw new Error("The Prompter is no longer available.");
+    const token = {};
+    const submittedAfter = this.sequence;
+    record.submission = token;
+    this.publish(record, { phase: "queued", percent: 0 });
+    try {
+      const accepted = await queueFn();
+      if (accepted === false) throw new Error("ComfyUI did not accept the generation request. Check its validation messages.");
+      // Also capture jobs waiting behind another workflow, before execution_start.
+      const epoch = this.epoch;
+      const queue = await this.read("/queue");
+      if (epoch === this.epoch && !this.disposed) this.captureQueue(queue);
+      if (record.submission === token) record.submission = null;
+      const lookups = [...this.jobs.values()].map((job) => job.lookup).filter(Boolean);
+      await Promise.allSettled(lookups);
+      this.renderRecord(record);
+      // Successful queue submission need not mean this Prompter was connected.
+      if (![...this.jobs.values()].some((job) => job.order > submittedAfter && job.bindings.has(record))) {
+        throw new Error("No connected Generation Engine was queued for this Prompter.");
+      }
+      return accepted;
+    } catch (error) {
+      if (record.submission === token) record.submission = null;
+      if (this.records.get(node) === record && !this.disposed) {
+        this.publish(record, { phase: "error", percent: 0, message: error?.message ?? String(error) });
+      }
+      throw error;
+    }
+  }
+
+  job(id) {
+    if (this.disposed || typeof id !== "string" || !id) return null;
+    let job = this.jobs.get(id);
+    if (!job) {
+      job = { id, order: ++this.sequence, started: false, terminal: null, context: null, bindings: new Map(), progress: new Map(), cached: new Set(), lookup: null, queueRead: false, historyRead: false };
+      this.jobs.set(id, job);
+      while (this.jobs.size > MAX_JOBS) this.jobs.delete(this.jobs.keys().next().value);
+    }
+    return job;
+  }
+
+  async read(path) {
+    try {
+      const response = await this.api.fetchApi(path);
+      return response.ok ? await response.json() : null;
+    } catch { return null; }
+  }
+
+  async reconcilePending() {
+    if (this.reconciling || this.disposed) return;
+    const pending = [...this.jobs.values()].filter((job) => !job.started && !job.terminal && job.bindings.size);
+    if (!pending.length) return;
+    const epoch = this.epoch;
+    const current = (job) => !this.disposed && epoch === this.epoch && this.jobs.get(job.id) === job && !job.started && !job.terminal;
+    this.reconciling = true;
+    try {
+      const queue = await this.read("/queue");
+      if (!queue || this.disposed || epoch !== this.epoch) return;
+      this.captureQueue(queue);
+      const present = new Set([...(queue.queue_running ?? []), ...(queue.queue_pending ?? [])].map((entry) => String(entry[1])));
+      await Promise.all(pending.filter((job) => !present.has(job.id)).map(async (job) => {
+        // Start/success can be delivered while a cached job moves into history.
+        // Give those authoritative events a short, bounded chance to arrive.
+        let historyEntry;
+        for (const delay of [50, 150]) {
+          await this.delay(delay);
+          if (!current(job)) return;
+          const history = await this.read(`/history/${encodeURIComponent(job.id)}`);
+          if (!current(job)) return;
+          historyEntry = history?.[job.id];
+        }
+        if (!current(job)) return;
+        if (historyEntry) {
+          // History proves it left the queue, but an absent success event must
+          // not fabricate a finished border. The normal history UI has results.
+          job.terminal = "error";
+          job.message = "The job has left the queue. Check ComfyUI's history for its result.";
+        } else job.terminal = "interrupted";
+        this.renderJob(job);
+      }));
+    } finally { this.reconciling = false; }
+  }
+
+  captureQueue(queue) {
+    for (const [name, started] of [["queue_running", true], ["queue_pending", false]]) {
+      for (const entry of queue?.[name] ?? []) {
+        const context = connections(entry);
+        if (!context) continue;
+        const job = this.job(context.id);
+        if (!job) continue;
+        job.started ||= started;
+        this.setContext(job, context);
+      }
+    }
+  }
+
+  setContext(job, context) {
+    if (this.api.clientId && context.clientId && context.clientId !== this.api.clientId) return;
+    job.context = context;
+    this.bind(job);
+    this.renderJob(job);
+  }
+
+  bind(job) {
+    const root = this.getRootGraph?.(), context = job.context;
+    if (!root || !context || String(root.id) !== context.workflowId) return;
+    for (const [sourceId, engines] of context.sources) {
+      const node = resolveNode(root, sourceId), record = this.records.get(node);
+      if (record) job.bindings.set(record, { sourceId, engines, workflowId: context.workflowId });
+    }
+  }
+
+  async lookup(job, terminal = false) {
+    if (job.context || this.disposed) return;
+    if (job.lookup) {
+      await job.lookup;
+      if (terminal && !job.context) return this.lookup(job, true);
+      return;
+    }
+    if (terminal && job.historyRead) return;
+    if (!terminal && job.queueRead) return;
+    const epoch = this.epoch;
+    const current = () => !this.disposed && epoch === this.epoch && this.jobs.get(job.id) === job;
+    job.lookup = (async () => {
+      if (!job.queueRead) {
+        job.queueRead = true;
+        const queue = await this.read("/queue");
+        if (!current()) return;
+        this.captureQueue(queue);
+      }
+      if (job.context) return;
+      // A fast cached job can leave the queue before its start event is handled.
+      job.historyRead ||= terminal;
+      for (const delay of terminal ? [0, 50, 150] : [0]) {
+        if (delay) await this.delay(delay);
+        if (!current()) return;
+        const history = await this.read(`/history/${encodeURIComponent(job.id)}`);
+        if (!current()) return;
+        const context = connections(history?.[job.id]?.prompt);
+        if (context) { this.setContext(job, context); return; }
+      }
+    })();
+    try { await job.lookup; } finally { job.lookup = null; }
+  }
+
+  delay(ms) {
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => { this.timers.delete(timer); resolve(); }, ms);
+      this.timers.set(timer, resolve);
+    });
+  }
+
+  stateFor(job, binding) {
+    const engines = [...binding.engines];
+    const fractions = engines.map((id) => job.cached.has(id) ? 1 : job.progress.get(id)?.fraction ?? 0);
+    const fraction = fractions.reduce((total, value) => total + value, 0) / Math.max(1, engines.length);
+    let phase = job.started ? "loading" : "queued";
+    if (job.terminal) phase = job.terminal;
+    else if (fraction === 1) phase = "saving";
+    else {
+      for (const id of engines) {
+        const progress = job.progress.get(id);
+        if (progress && progress.fraction < 1) phase = progress.phase;
+      }
+    }
+    return { phase, percent: phase === "complete" ? 100 : Math.min(99, fraction * 100), promptId: job.id, ...(job.message ? { message: job.message } : {}) };
+  }
+
+  validBinding(record, binding) {
+    const root = this.getRootGraph?.();
+    return root && String(root.id) === binding.workflowId && resolveNode(root, binding.sourceId) === record.node;
+  }
+
+  renderRecord(record) {
+    if (this.records.get(record.node) !== record) return;
+    const matches = [...this.jobs.values()].filter((job) => job.bindings.has(record) && this.validBinding(record, job.bindings.get(record)));
+    matches.sort((a, b) => {
+      const priority = (job) => job.terminal ? 0 : job.started ? 2 : 1;
+      return priority(b) - priority(a) || b.order - a.order;
+    });
+    if (matches.length) this.publish(record, this.stateFor(matches[0], matches[0].bindings.get(record)));
+    else if (record.submission) this.publish(record, { phase: "queued", percent: 0 });
+    else if (ACTIVE.has(record.state.phase)) this.publish(record, IDLE);
+  }
+
+  renderJob(job) {
+    for (const record of job.bindings.keys()) this.renderRecord(record);
+  }
+
+  publish(record, state) {
+    if (this.disposed || !record.callbacks.size) return;
+    if (JSON.stringify(record.state) === JSON.stringify(state)) return;
+    record.state = state;
+    for (const callback of record.callbacks) callback(state);
+  }
+
+  disconnect() {
+    this.epoch++;
+    this.jobs.clear();
+    this.clearTimers();
+    for (const record of this.records.values()) {
+      record.submission = null;
+      if (ACTIVE.has(record.state.phase)) this.publish(record, { phase: "error", percent: Math.min(99, record.state.percent), message: "Connection lost. Check the ComfyUI queue before generating again." });
+    }
+  }
+
+  clearTimers() {
+    for (const [timer, resolve] of this.timers) { clearTimeout(timer); resolve(); }
+    this.timers.clear();
+  }
+
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.epoch++;
+    for (const [name, listener] of this.listeners) this.api.removeEventListener(name, listener);
+    this.listeners = [];
+    this.clearTimers();
+    this.jobs.clear();
+    this.records.clear();
+  }
+}