test(tagging): gallery review units apply by image; record each progress change

The gallery review unit tests still pinned the removed prompt_id apply.
The legacy batch spec read the progress text once per observer callback,
so a phase frame and the first image frame landing in one task lost the
phase (WebKit); it now records every mutation record.

TESTING.md

@@ -1245,8 +1245,7 @@ Recorded deviations on this page (spec §8):
   `#bulkbar` shows "N selected" and only the real actions in the concept's order (Add
   tags, then D85's Auto-tag selected, Set category, Export metadata, Clear). Add to
   collection waits for collections; "Remove links…" is dropped. (Amended by #249 PR D:
-  Add tags ships, see "Bulk tagging from the selection bar"; #392 adds range, keyboard,
-  touch and "all N matching" selection, see "Selecting many images", D135.) The selection survives Load more and
+  Add tags ships, see "Bulk tagging from the selection bar".) The selection survives Load more and
   bounded re-mounting and is cleared whenever the collection is replaced (search,
   category, sort, Filters, source change, rescan, reload). A return to Images restores
   the saved collection unreplaced and keeps its selection; a full page reload starts
@@ -1723,65 +1722,6 @@ busy". Units:
 | Copy without a concept line: no tags, start fallbacks, the panel heading | D118 |
 | Activity item and job view for image tagging jobs | D89 (plan D66) |
 
-### Selecting many images (#392)
-
-**D135** (beyond the concept, which draws only the per-card checkbox): Images selects
-like a file manager, in Grid, List (where the concept hides the checkbox) and Masonry,
-over every loaded batch. The selection is a set of image keys in display order, so
-ranges include cards that bounded rendering has unmounted.
-
-- Clicking a checkbox toggles it, and that image becomes the anchor. Ctrl/Cmd+click
-  anywhere on a card (image, star, Info, Tag) also toggles it and makes it the anchor;
-  nothing opens, inspects or changes the favorite.
-- Shift+click on a card selects the range from the anchor to it. Shift+click on a
-  checkbox gives its range the box's new state, so it can clear a range. The anchor
-  stays where it is. Without an anchor, the clicked image becomes the anchor.
-- In the grid, Ctrl/Cmd+A selects every loaded image; in the search box it keeps its
-  text meaning. Shift+Arrow, Shift+Home and Shift+End move focus as the plain keys do,
-  then select from the anchor (the starting card when there is none) to the new card.
-  Escape in the grid clears the selection. Escape in the bar clears it too, and focus
-  moves to the heading, as after Clear.
-- Touch: a 500 ms long-press (at most 10 px of movement) selects the card and turns on
-  touch selection mode. The context menu during the press and the click after it are
-  swallowed, and the card has no image callout. Taps then toggle cards until the
-  selection is empty. A keyboard Enter or Space keeps its plain meaning.
-- A plain click keeps its meaning: the image opens the viewer, and Info inspects.
-- When every loaded image is checked and the listing has more, the bar offers
-  **Select all N matching** right after the count. Pressing it gives **All N matching
-  selected**: later batches arrive checked, and unchecking any image goes back to the
-  loaded images minus that one. Clear, Escape, and a new search, filter, sort or rescan
-  end it. A refresh after a tag save keeps it. Return visits keep the loaded images,
-  and the offer shows again.
-- In that mode, Add tags and Auto-tag selected start the `image-tags` job with
-  `filter` (the listing's own query as an object: `q`, `subfolder`, `category`,
-  `tags`, `root`, `media`, `sort`, `favorites`, and with a Source the loaded root's
-  `root_scope`) instead of `targets`. The server resolves the filter at start, in
-  listing order, using the listing's own admission code (`_admitted_entries`). That
-  means "all matching" when the action starts: an output written since then that
-  matches is included. A `root_scope` that no longer names its root (the sources were
-  renumbered) answers 409 `source-changed`. The limit is 10,000 images (`MAX_LISTING_SELECTION`).
-  Over the limit, the client toasts "Narrow the view to at most 10,000 images." and the
-  server answers 400 `too-many-images`. No match is 400 `no-images`. Auto-tag in this
-  mode does not offer Review each image, because the review walks images in the
-  browser. Set category posts `{images_filter, category}` to `/prompt_manager/bulk/category`.
-  The server sets the category on the distinct linked positives and answers
-  `prompt_count` and `skipped`. A listing whose `positive_count` is 0 toasts the
-  nothing-linked sentence and opens no dialog, and over 10,000 matches it toasts the
-  limit sentence. Export metadata reads every image in
-  the browser, so it is `aria-disabled` in this mode, and its `title` says why.
-
-Tests: `tests/browser/workspace-images.spec.mjs` ("Shift+click selects a range across
-an appended batch in Grid, List and Masonry", "Ctrl/Cmd+click toggles a card without
-opening it, and a plain click still opens the viewer", "Ctrl/Cmd+A, Select all N
-matching and Add tags tag every matching image on the server", "Shift+arrow keys extend
-the selection from the focused card, and Escape in the bar clears it", "a touch
-long-press starts selection mode, taps then toggle, and an empty selection ends it");
-units `tests/js/workspace-images-multiselect.test.js`,
-`tests/js/workspace-images-tagging-bulk.test.js` ("all matching sends the listing
-filter instead of targets"), `tests/js/workspace-images-state.test.js`
-(`listingFilter`); Python `tests/test_image_tag_jobs.py` (`TestFilterStart`) and
-`tests/test_api_workspace_images.py` (`TestListingFilterSelection`).
-
 Native image tagging (#249 PR B routes, PR C UI): `POST
 /prompt_manager/image-annotations/observe` (capture one listed file, its saved set and
 `tag_revision`), `GET`/`DELETE /prompt_manager/image-annotations/capture/<token>`
@@ -4099,33 +4039,6 @@ list stay unscoped: any row's control proves them.
 | API timeout `apiTimeout` | `gallery-settings.js:37` | Legacy gallery (S12-10; read by no request) | kept in legacy | — | defaults are a complete, sane settings object (gallery-settings.test.js) |
 | config.json-only keys | `py/config.py:212–234,722–739`; `py/api/diagnostics_report.py:185` | S12 report (read-only) | covered | `diagnostics` · button · "Download diagnostic report" | test_report_lists_config_only_keys (test_api_diagnostics_report.py) |
 
-### Legacy System UI removed by S13
-
-System S13 (#330) points the legacy pages' System buttons at native System (a link that
-opens `workspace#/system/<id>` in a new tab) and removes the legacy copy of a capability
-only when its row above is `covered`. One row per removed capability: Capability is the
-exact Capability cell of its coverage row, Page is `admin` or `gallery`, Removed ids and
-Removed methods list what went (`—` for none), and Native test copies that row's Test
-cell. An id that stays on a System link is not listed, only its handler.
-
-`tests/vendor/legacy-coverage.test.mjs` fails when a row cites a capability that is not
-`covered` or copies another test, when an id or method is listed twice for one page, or
-when a listed id is still on its page (`id="…"` in the markup or the script, a
-`getElementById`/`querySelector('#…')` lookup, an entry of a modal-id list) or a listed
-method is still defined or called (`.name(`). A deletion listed nowhere is caught by the
-kept-flow tests (`kept admin flows still work` in `legacy-system-links.spec.mjs` and the
-legacy page workflows), not by this check.
-
-| Capability | Page | Removed ids | Removed methods | Native test |
-| --- | --- | --- | --- | --- |
-| Diagnostics run | admin | `#diagnosticsModal`, `#runDiagnosticsBtn`, `#diagnosticsContent` | `showDiagnosticsModal()`, `closeDiagnostics()`, `runDiagnostics()`, `renderDiagnostics()` | Run checks opens the shared Health report (workspace-system-diagnostics.spec.mjs) |
-| Synthetic image-link test | admin | `#testImageLinkBtn` | `testImageLink()` | Create test link confirms first and names the prompt (workspace-system-diagnostics.spec.mjs) |
-| View logs with level and limit | admin | `#logsModal`, `#logLevel`, `#logLimit`, `#refreshLogsBtn`, `#logsContainer` | `showLogsModal()`, `closeLogs()`, `refreshLogs()`, `displayLogs()` | level filter is minimum-level over all six choices (workspace-system-diagnostics.spec.mjs) |
-| Log statistics | admin | `#logStatsTotal`, `#logStatsErrors`, `#logStatsWarnings`, `#logStatsLevel`, `#logStatsSize` | `loadLogStats()`, `formatBytes()` | log statistics show entries, errors, warnings, files and size (workspace-system-diagnostics.spec.mjs) |
-| Log files list and download | admin | `#downloadLogsBtn`, `#logFilesList` | `loadLogFiles()`, `downloadLogs()`, `downloadLogFile()` | each listed file downloads by its returned name and a link has no Download (workspace-system-diagnostics.spec.mjs) |
-| Clear/truncate logs | admin | `#clearLogsBtn` | `clearLogs()` | Clear all logs states both counts, confirms first and reads everything again (workspace-system-diagnostics.spec.mjs) |
-| Set log level (incl. CRITICAL), console logging | admin | `#updateLogConfigBtn`, `#setLogLevel`, `#consoleLogging` | `loadLogConfig()`, `updateLogConfig()` | runtime level (including CRITICAL) and console logging save and say they apply until the server restarts (workspace-system-diagnostics.spec.mjs) |
-
 ### Browser cache ownership (#222)
 
 The legacy gallery's Clear cache used to delete every localStorage key starting `pm_` or
@@ -4520,17 +4433,8 @@ impact and command receipts report `image_count` / `images` /
 `(size, mtime_ns)` equals its verified fingerprint; an in-place rewrite that
 preserves both keeps the old set matching until the file is next observed. The
 Images Tags filter (a file matches when every tag is on its linked positive or
-its current image tag set) and `q` search find their candidates through the tag
-index (#379), never by streaming every image tag row: `image_tag_ids` reads the
-tag names that tag at least one image (an `EXISTS` on `idx_media_image_tags_tag`)
-and keeps a name when it equals a Tags filter tag exactly or contains `q`
-case-folded; `image_tag_locators` reads the files carrying those ids (`tag_id IN`,
-500 ids a chunk). Only the listed ones among them are stat'ed, and only their
-current records count; a linked positive's prompt tags still combine with the
-image tags under a Tags filter. `test_indexed_candidates_equal_the_full_stream`
-compares the lookup with the old full stream (kept in the test as the reference)
-and `test_tag_search_reads_image_tags_only_by_tag_id` traces every statement; the
-
+its current image tag set) and `q` search stream the tagged records once and
+stat only the listed files whose records carry a filter tag or a `q` hit; the
 inspector's `image_tags` facet (`current` / `none` / `unavailable`) uses the
 inspection's own stable stat (`tests/test_api_workspace_images.py`
 `TestWorkspaceImageTags`, `tests/test_api_prompt_inspector.py`). The

database/annotations.py

@@ -110,16 +110,12 @@ _MARKED_LOCATORS = (
     f"SELECT DISTINCT f.locator FROM {AUTOTAG_TABLE} m "  # nosec B608
     f"JOIN {BYTES_TABLE} b ON b.id=m.byte_id JOIN {FILES_TABLE} f ON f.id=b.file_id"
 )
-# Tag search (#379): the names that tag at least one image (the tag index
-# answers the EXISTS), then the locators carrying chosen names (by tag_id).
-_IMAGE_TAG_NAMES = (
-    "SELECT t.id,t.name FROM tags t WHERE EXISTS "  # nosec B608
-    f"(SELECT 1 FROM {IMAGE_TAGS_TABLE} mit WHERE mit.tag_id=t.id)"
-)
-_TAG_LOCATORS = (
-    f"SELECT DISTINCT f.locator FROM {IMAGE_TAGS_TABLE} mit "  # nosec B608
-    f"JOIN {BYTES_TABLE} b ON b.id=mit.byte_id "
-    f"JOIN {FILES_TABLE} f ON f.id=b.file_id WHERE mit.tag_id IN ({{marks}})"
+_RECORDS = (
+    "SELECT f.locator,b.id,b.size,b.mtime_ns,t.name "  # nosec B608
+    f"FROM {FILES_TABLE} f JOIN {BYTES_TABLE} b ON b.file_id=f.id "
+    f"LEFT JOIN {IMAGE_TAGS_TABLE} mit ON mit.byte_id=b.id "
+    "LEFT JOIN tags t ON t.id=mit.tag_id "
+    "ORDER BY f.locator,b.first_seen_at,b.id,mit.position"
 )
 
 
@@ -520,32 +516,20 @@ class AnnotationOperations:
         with self._annotation_read() as conn:
             return {row[0] for row in conn.execute(_MARKED_LOCATORS)}
 
-    def image_tag_ids(self, wanted, query: str) -> list[int]:
-        """Ids of the tag names on at least one image that a search wants.
+    def iter_image_tag_records(self) -> Iterator[tuple[str, int, int, list[str]]]:
+        """Stream every byte record as ``(locator, size, mtime_ns, tags)``.
 
-        A name counts when it is in ``wanted`` exactly (the Tags filter) or
-        contains ``query`` case-folded (the text search; ``query`` is
-        already folded). One read of the names that tag an image.
+        One SELECT ordered by locator, then by the bytes' first sighting, with
+        each set's names in position order.
         """
-        wanted = set(wanted)
-        with self._annotation_read() as conn:
-            return [
-                tag_id
-                for tag_id, name in conn.execute(_IMAGE_TAG_NAMES)
-                if name in wanted or (query and query in name.casefold())
-            ]
-
-    def image_tag_locators(self, tag_ids) -> set[str]:
-        """Locators with any byte record (current or not) carrying one of
-        ``tag_ids``, through the tag index, in chunks of 500 ids."""
-        ids = list(dict.fromkeys(tag_ids))
-        found: set[str] = set()
-        with self._annotation_read() as conn:
-            for start in range(0, len(ids), _LOOKUP_CHUNK):
-                chunk = ids[start : start + _LOOKUP_CHUNK]
-                marks = ",".join("?" * len(chunk))
-                found.update(
-                    row[0]
-                    for row in conn.execute(_TAG_LOCATORS.format(marks=marks), chunk)
-                )
-        return found
+        conn = self.model.get_connection()
+        current: tuple | None = None
+        for locator, byte_id, size, mtime_ns, name in conn.execute(_RECORDS):
+            if current is None or current[0] != byte_id:
+                if current is not None:
+                    yield current[1]
+                current = (byte_id, (locator, size, mtime_ns, []))
+            if name is not None:
+                current[1][3].append(name)
+        if current is not None:
+            yield current[1]

py/api/__init__.py

@@ -1107,3 +1107,196 @@ class PromptManagerAPI(
                         result["parameters"][field] = metadata[field]
 
         return result
+
+    def _extract_readable_prompt(self, parsed_data):
+        """Extract human-readable prompt text from ComfyUI/A1111 data."""
+
+        def safe_to_string(value):
+            if isinstance(value, str):
+                return value
+            elif isinstance(value, list):
+                return " ".join(str(item) for item in value if item)
+            elif value is not None:
+                return str(value)
+            return None
+
+        # First check if we already extracted a positive prompt (A1111 format)
+        if parsed_data.get("positive_prompt"):
+            return parsed_data["positive_prompt"]
+
+        # Check if prompt is already a string
+        if isinstance(parsed_data.get("prompt"), str):
+            return parsed_data["prompt"]
+
+        # Check if prompt is a simple value that can be converted
+        if parsed_data.get("prompt") and not isinstance(
+            parsed_data.get("prompt"), dict
+        ):
+            return safe_to_string(parsed_data["prompt"])
+
+        prompt_data = parsed_data.get("prompt")
+        if isinstance(prompt_data, dict):
+            # Use the enhanced logic from parse-metadata.py
+            positive_prompt = self._extract_positive_prompt_from_comfyui_data(
+                prompt_data
+            )
+            if positive_prompt:
+                return positive_prompt
+
+        # Check workflow data if available
+        workflow_data = parsed_data.get("workflow")
+        if isinstance(workflow_data, dict):
+            positive_prompt = self._extract_positive_prompt_from_comfyui_data(
+                workflow_data
+            )
+            if positive_prompt:
+                return positive_prompt
+
+        # Check parameters for positive prompt
+        if parsed_data.get("parameters", {}).get("positive"):
+            return safe_to_string(parsed_data["parameters"]["positive"])
+
+        return None
+
+    def _get_node_inputs(self, node):
+        """Safely get inputs from a node, handling both dict and list formats.
+
+        Old format: inputs is a dict with direct key-value pairs
+            inputs = {"text": "my prompt", "seed": 123}
+
+        New format: inputs is a list of connection objects
+            inputs = [
+                {"name": "text", "type": "STRING", "link": null,
+                 "widget": {"name": "text"}},
+                {"name": "clip", "type": "CLIP", "link": 11}
+            ]
+        """
+        if not isinstance(node, dict):
+            return {}
+
+        inputs = node.get("inputs", {})
+
+        # If inputs is already a dict, return it
+        if isinstance(inputs, dict):
+            return inputs
+
+        # If inputs is a list, convert to dict format
+        if isinstance(inputs, list):
+            inputs_dict = {}
+            for input_item in inputs:
+                if isinstance(input_item, dict) and "name" in input_item:
+                    name = input_item["name"]
+                    inputs_dict[name] = input_item
+            return inputs_dict
+
+        return {}
+
+    def _find_text_in_node(self, node):
+        """Try to find text content in a node using various strategies.
+
+        Handles both old and new workflow formats.
+        """
+        if not isinstance(node, dict):
+            return None
+
+        # Strategy 1: Check normalized inputs for 'text' field
+        inputs = self._get_node_inputs(node)
+        if "text" in inputs and isinstance(inputs["text"], str):
+            return inputs["text"]
+
+        # Strategy 2: For text encoder nodes, check widgets_values
+        class_type = node.get("class_type", node.get("type", ""))
+        text_encoder_types = [
+            "CLIPTextEncode",
+            "CLIPTextEncodeSDXL",
+            "CLIPTextEncodeSDXLRefiner",
+            "CLIPTextEncodeFlux",
+            "PromptManager",
+            "PromptManagerText",
+            "BNK_CLIPTextEncoder",
+            "Text Encoder",
+            "CLIP Text Encode",
+        ]
+
+        if any(
+            encoder_type.lower() in class_type.lower()
+            for encoder_type in text_encoder_types
+        ):
+            widgets_values = node.get("widgets_values", [])
+            if widgets_values and len(widgets_values) > 0:
+                if isinstance(widgets_values[0], str) and widgets_values[0].strip():
+                    return widgets_values[0]
+
+        return None
+
+    def _extract_positive_prompt_from_comfyui_data(self, data):
+        """Extract positive prompt from ComfyUI data.
+
+        Handles both old and new formats.
+        """
+        if not isinstance(data, dict):
+            return None
+
+        # Build nodes dictionary
+        nodes_by_id = {}
+        if "nodes" in data:
+            # Handle nodes array format
+            for node in data["nodes"]:
+                if isinstance(node, dict):
+                    nid = node.get("id")
+                    if nid is not None:
+                        nodes_by_id[nid] = node
+        else:
+            # Handle flat dictionary format (node_id -> node_data)
+            for nid_str, node in data.items():
+                try:
+                    nid = int(nid_str)
+                except (ValueError, TypeError):
+                    nid = nid_str
+                if isinstance(node, dict):
+                    if "id" in node:
+                        nid = node["id"]
+                    nodes_by_id[nid] = node
+
+        if not nodes_by_id:
+            return None
+
+        # First, try to find positive/negative connection pattern
+        pos_id = None
+        for node in nodes_by_id.values():
+            if isinstance(node, dict):
+                inputs = self._get_node_inputs(node)
+                if "positive" in inputs and "negative" in inputs:
+                    try:
+                        pos_input = inputs["positive"]
+                        if isinstance(pos_input, list) and len(pos_input) > 0:
+                            pos_id = int(pos_input[0])
+                            break
+                    except (ValueError, TypeError, IndexError):
+                        continue
+
+        # Get text from the positive node
+        if pos_id is not None and pos_id in nodes_by_id:
+            text_val = self._find_text_in_node(nodes_by_id[pos_id])
+            if text_val:
+                return text_val
+
+        # Fallback: find any text encoder node with text content
+        text_nodes = []
+        for node in nodes_by_id.values():
+            if isinstance(node, dict):
+                text_val = self._find_text_in_node(node)
+                if text_val:
+                    # Try to determine if this is positive or negative
+                    node_title = node.get("title", "").lower()
+                    if "neg" not in node_title and "negative" not in node_title:
+                        # Prioritize non-negative prompts
+                        text_nodes.insert(0, text_val)
+                    else:
+                        text_nodes.append(text_val)
+
+        # Return the first positive-looking prompt
+        if text_nodes:
+            return text_nodes[0]
+
+        return None

py/api/admin.py

@@ -47,7 +47,7 @@ try:
         extract_generation_params,
         parse_page_json,
     )
-    from ...utils.prompt_pair_resolver import resolve_prompt_pair, sampler_less_prompt
+    from ...utils.prompt_pair_resolver import resolve_prompt_pair
     from ...utils.review_capture import reviewable
 except ImportError:
     from database.pair_ingestion import blank_positive, ingest_resolved_pair
@@ -62,7 +62,7 @@ except ImportError:
         extract_generation_params,
         parse_page_json,
     )
-    from utils.prompt_pair_resolver import resolve_prompt_pair, sampler_less_prompt
+    from utils.prompt_pair_resolver import resolve_prompt_pair
     from utils.review_capture import reviewable
 
 
@@ -1754,24 +1754,13 @@ class AdminRoutesMixin:
             canonical.get("parameters"), str
         ):
             return resolution["state"]
-        elif canonical.get("prompt"):
-            # No node takes a positive or negative input (a guider or wrapper
-            # graph): the one wired text, never a guess (#252).
-            found = sampler_less_prompt(canonical["prompt"])
-            prompt_text = found["text"]
-            if prompt_text is None and isinstance(canonical.get("parameters"), str):
-                # A metadata saver also wrote A1111 text: its positive prompt.
-                parsed = self._parse_comfyui_prompt(metadata)["positive_prompt"]
-                prompt_text = parsed.strip() if parsed and parsed.strip() else None
-            if prompt_text is None:
-                linked = self._link_recorded_run(
-                    media_file, canonical, detailed, history
-                )
-                if linked is not None:
-                    return linked
-                return "unresolved" if found["state"] == "ambiguous" else "found"
         else:
-            prompt_text = self._parse_comfyui_prompt(metadata)["positive_prompt"]
+            parsed = self._parse_comfyui_prompt(metadata)
+            if not (parsed.get("prompt") or parsed.get("parameters")):
+                return None
+            prompt_text = self._extract_readable_prompt(parsed)
+            if prompt_text is not None and not isinstance(prompt_text, str):
+                prompt_text = str(prompt_text)
             if not (prompt_text and prompt_text.strip()):
                 return "found"
             prompt_text = prompt_text.strip()

py/api/image_tag_jobs.py

@@ -2,9 +2,7 @@
 
 ``POST /prompt_manager/jobs/image-tags`` starts one ``image-tags`` job over
 1..500 listed images, named by the listing identity ``{root_index,
-root_scope, path}``, or over every image a listing ``filter`` admits (at most
-10,000, resolved at start in the listing's order; "Select all N matching",
-#392). The job is record-changing (it writes image tag sets and
+root_scope, path}``. The job is record-changing (it writes image tag sets and
 new vocabulary names), so it never runs beside the metadata scan.
 
 - **Add tags** (``mode: "add"``) hashes each current file and unions a fixed
@@ -56,14 +54,7 @@ from .annotations import (
     _target,
 )
 from .autotag_routes import BATCH_CANCELLED, MODEL_BUSY_ERROR, model_busy_response
-from .images import (
-    MAX_LISTING_SELECTION,
-    ListingSourceChanged,
-    _current_fingerprint,
-    _listing_posix,
-    _public_path,
-    parse_listing_filter,
-)
+from .images import _current_fingerprint, _listing_posix, _public_path
 from .job_routes import busy_response
 from .jobs import (
     AUTOTAG_BATCH_JOB_KIND,
@@ -99,11 +90,6 @@ except ImportError:
     from utils.video_metadata import is_video_path
 
 MAX_JOB_TARGETS = 500
-# A filter start resolves on the server, so the request body does not bound it.
-MAX_FILTER_TARGETS = MAX_LISTING_SELECTION
-NO_IMAGES = "No images match this view."
-FILTER_LISTING_FAILED = "The matching images could not be listed. Try again."
-TOO_MANY_IMAGES = "Narrow the view to at most {cap:,} images."
 # 500 maximal targets plus the options: a path of MAX_TARGET_PATH code points
 # takes at most 6 bytes each on the wire (a \uXXXX escape; raw UTF-8 is at most
 # 4), and the root index and scope fit in 256. The annotation routes' 64 KiB
@@ -117,10 +103,9 @@ ADD_TITLE = "Add tags to images"
 AUTO_TITLE = "Auto-tag images"
 GATE_OWNER_KIND = "image-tag-job"
 
-# Each mode's fields besides the images, named by ``targets`` or ``filter``.
 _FIELDS = {
-    "add": frozenset({"mode", "tags"}),
-    "auto": frozenset({"mode", "model_type", "options"}),
+    "add": frozenset({"mode", "targets", "tags"}),
+    "auto": frozenset({"mode", "targets", "model_type", "options"}),
 }
 _VERBS = {"add": "Add tags", "auto": "Auto-tag"}
 _LOG_PREFIXES = {"tagged": "+", "unchanged": "=", "skipped": "-", "errors": "!"}
@@ -179,8 +164,6 @@ class _Spec:
     tags: tuple = ()
     model_type: str | None = None
     options: dict | None = None
-    # A listing filter the start resolves into ``targets`` (#392).
-    filter: dict | None = None
 
     @property
     def title(self) -> str:
@@ -239,35 +222,21 @@ def parse_image_tag_request(data: dict):
     """A :class:`_Spec` for a start body, or ``(None, error response)``.
 
     ``{mode:"add", targets, tags}`` or ``{mode:"auto", targets, model_type,
-    options}`` exactly; options follow the Tag dialog's Generate rules. A
-    ``filter`` (a listing query object, parse_listing_filter) may stand in for
-    ``targets``; the start resolves it.
+    options}`` exactly; options follow the Tag dialog's Generate rules.
     """
     fields = _FIELDS.get(data.get("mode"))
     if fields is None:
         return None, bad_request('mode must be "add" or "auto"')
-    fields = fields | {"filter" if "filter" in data else "targets"}
     if set(data) != fields:
         return None, bad_request(
             "Request must contain exactly " + ", ".join(sorted(fields))
         )
-    listing_filter, targets = None, ()
-    if "filter" in data:
-        try:
-            listing_filter = parse_listing_filter(data["filter"])
-        except ValueError as exc:
-            return None, bad_request(str(exc))
-    else:
-        targets, error = _parse_targets(data["targets"])
-        if error is not None:
-            return None, error
+    targets, error = _parse_targets(data["targets"])
+    if error is not None:
+        return None, error
     if data["mode"] == "add":
-        spec, error = _parse_add(targets, data)
-    else:
-        spec, error = _parse_auto(targets, data)
-    if spec is not None and listing_filter is not None:
-        spec = dataclasses.replace(spec, filter=listing_filter)
-    return spec, error
+        return _parse_add(targets, data)
+    return _parse_auto(targets, data)
 
 
 def _capture_outcome(exc: CaptureError, root, relative: str):
@@ -429,10 +398,6 @@ class ImageTagJobsMixin:
         spec, error = parse_image_tag_request(data)
         if error is not None:
             return error
-        if spec.filter is not None:
-            spec, error = await self._resolve_job_filter(spec)
-            if error is not None:
-                return error
         roots = await self._run_in_executor(self._job_roots, spec.targets)
         if any(root is None for root, _label in roots.values()):
             return _coded("source-changed")
@@ -674,36 +639,6 @@ class ImageTagJobsMixin:
             job.log_line(f"Skipped {_plural(skipped, 'image')} before tagging")
         return remaining
 
-    async def _resolve_job_filter(self, spec: _Spec):
-        """``spec`` with its filter resolved into targets, or ``(None, error)``.
-
-        The listing's own identities, in its order, kept only where a target
-        could have named them (a media path the job can tag).
-        """
-        cap = MAX_FILTER_TARGETS
-        try:
-            selection = await self.resolve_listing_filter(spec.filter, cap)
-        except ListingSourceChanged:
-            return None, _coded("source-changed")
-        except ValueError as exc:
-            return None, bad_request(str(exc))
-        except Exception:
-            # Never echo it: it can carry SQL or database text.
-            self.logger.error("A tagging filter could not be resolved", exc_info=True)
-            return None, _error(500, "listing-failed", FILTER_LISTING_FAILED)
-        if selection.truncated:
-            return None, _error(400, "too-many-images", TOO_MANY_IMAGES.format(cap=cap))
-        targets = []
-        for index, scope, relative in selection.targets:
-            target, error = _target(
-                {"root_index": index, "root_scope": scope, "path": relative}
-            )
-            if error is None:
-                targets.append(target)
-        if not targets:
-            return None, _error(400, "no-images", NO_IMAGES)
-        return dataclasses.replace(spec, targets=tuple(targets)), None
-
     # -- runner ----------------------------------------------------------------
 
     def _job_roots(self, targets) -> dict:

py/api/images.py

@@ -575,6 +575,12 @@ def _current_fingerprint(path: Path) -> tuple[int, int] | None:
     return observed.st_size, observed.st_mtime_ns
 
 
+def _image_tags_relevant(names: list, wanted: set, query: str) -> bool:
+    if wanted and not wanted.isdisjoint(names):
+        return True
+    return bool(query) and any(query in name.casefold() for name in names)
+
+
 def _workspace_key(entry: tuple, order: str) -> tuple:
     """The keyset sort key of *entry* (a _Listed or a 4-tuple entry)."""
     if not isinstance(entry, _Listed):
@@ -1099,94 +1105,37 @@ def _workspace_filters(query: Mapping) -> dict:
     }
 
 
-# The listing parameters a bulk request may name as its filter (#392): the
-# workspace query without mode, limit, cursor and the Activity-only ``path``,
-# plus the chosen root's ``root_scope`` (a renumbered source is refused).
-LISTING_FILTER_KEYS = frozenset(
-    {
-        "q",
-        "subfolder",
-        "category",
-        "tags",
-        "root",
-        "root_scope",
-        "media",
-        "sort",
-        "favorites",
-    }
-)
-MAX_LISTING_FILTER_VALUE = 2048
-# The most images "Select all N matching" acts on in one request (#392).
-MAX_LISTING_SELECTION = 10_000
-
-
-def parse_listing_filter(raw: object) -> dict:
-    """A bulk request's listing filter (#392): the listing's own query as an object.
-
-    Keys are a subset of LISTING_FILTER_KEYS, each value a string of at most
-    MAX_LISTING_FILTER_VALUE characters, validated as the listing validates its
-    query. The root's bounds need the current roots, so resolve_listing_filter
-    checks those. Raises ValueError.
-    """
-    if not isinstance(raw, dict) or not set(raw) <= LISTING_FILTER_KEYS:
-        raise ValueError("filter must be an object of listing parameters")
-    if any(
-        not isinstance(value, str) or len(value) > MAX_LISTING_FILTER_VALUE
-        for value in raw.values()
-    ):
-        raise ValueError("filter values must be short strings")
-    if "root_scope" in raw and "root" not in raw:
-        raise ValueError("root_scope needs root")
-    _workspace_filters(raw)
-    return dict(raw)
-
-
-class ListingSourceChanged(Exception):
-    """A listing filter's ``root_scope`` no longer names its root (#392)."""
-
-
-class ListingSelection(NamedTuple):
-    """Every image a listing filter admits, in the listing's order (#392).
-
-    ``targets`` are listing identities ``(root_index, root_scope, path)``;
-    ``positive_ids`` the distinct linked positives (first seen), ``unlinked``
-    the admitted images without one, and ``truncated`` that more than the cap
-    matched (the lists then stop at the cap).
-    """
-
-    targets: list
-    positive_ids: list
-    unlinked: int
-    truncated: bool
-
-
 # A plain listing's cursor page leaves positive_count out (see
 # _select_workspace_page); None instead means the count could not be read.
 _COUNT_OMITTED = object()
 
 
-def _admitted_entries(
+def _filtered_page(
     entries: list,
+    start: int,
+    size: int,
     filters: dict,
     links: dict | None,
     favorites: frozenset | None = None,
     image_tags: dict | None = None,
-):
-    """Yield ``(position, entry, link match)`` for each entry the filters admit.
+) -> tuple[int, list, int | None]:
+    """Count the *entries* the filters admit and take *size* from *start* on.
 
     *links* maps normalized paths to (hit, rating, positive id) for every
     unambiguously linked image (see PromptDatabase.get_image_link_matches); a
     category or tag filter admits only those, and ``q`` admits a filename match
-    or a linked-positive hit. *favorites*, when given, admits only those listed
-    paths (``favorites=1``). *image_tags* maps normalized paths to their
-    _ImageTagMatch: a tag filter also admits a file whose current image tags
-    (with its linked positive's tags) carry every tag, and ``q`` also admits an
-    image tag name hit.
+    or a linked-positive hit. Returns the total, the page and the number of
+    distinct linked positives among all admitted entries (None without links).
+    *favorites*, when given, admits only those listed paths (``favorites=1``).
+    *image_tags* maps normalized paths to their _ImageTagMatch: a tag filter
+    also admits a file whose current image tags (with its linked positive's
+    tags) carry every tag, and ``q`` also admits an image tag name hit.
     """
     query, media, folder = filters["query"], filters["media"], filters["folder"]
     members_only = filters["category"] is not None or bool(filters["tags"])
     native_folder = folder.replace("/", os.sep)
     nested = native_folder + os.sep
+    total, page, positives = 0, [], set()
     exact = filters.get("path", "")
     for position, entry in enumerate(entries):
         if exact and entry.folded != exact:
@@ -1210,28 +1159,6 @@ def _admitted_entries(
             and not (image and image.query)
         ):
             continue
-        yield position, entry, match
-
-
-def _filtered_page(
-    entries: list,
-    start: int,
-    size: int,
-    filters: dict,
-    links: dict | None,
-    favorites: frozenset | None = None,
-    image_tags: dict | None = None,
-) -> tuple[int, list, int | None]:
-    """Count the *entries* the filters admit and take *size* from *start* on.
-
-    Admission is _admitted_entries'. Returns the total, the page and the number
-    of distinct linked positives among all admitted entries (None without
-    links).
-    """
-    total, page, positives = 0, [], set()
-    for position, entry, match in _admitted_entries(
-        entries, filters, links, favorites, image_tags
-    ):
         total += 1
         if match is not None:
             positives.add(match[2])
@@ -2164,9 +2091,8 @@ class ImageRoutesMixin:
     def _image_tag_matches(self, listings: list[tuple], filters: dict) -> dict:
         """Normalized path -> _ImageTagMatch for files whose image tags count.
 
-        Looks the relevant tag names up (exact under Tags, a case-folded
-        substring for ``q``) and their files through the tag index, keeping
-        only listed locators; only those candidates are
+        Streams the tagged byte records once and keeps only listed locators
+        carrying a filter tag or a ``q`` hit; only those candidates are
         stat'ed (never every listed file), and a candidate's tags count only
         while a byte record is verified at its present ``(size, mtime_ns)``
         (spec amendment S1). Under a Tags filter the candidates' linked
@@ -2175,15 +2101,16 @@ class ImageRoutesMixin:
         tags, query, category = filters["tags"], filters["query"], filters["category"]
         wanted = set(tags)
         located = self._workspace_locators(listings)
-        # The tag index answers which files carry a relevant name (#379); no
-        # read streams every image tag row.
-        tag_ids = self.db.image_tag_ids(wanted, query)
         candidates = {}
-        if tag_ids:
-            for locator in self.db.image_tag_locators(tag_ids):
+        records = self.db.iter_image_tag_records()
+        try:
+            for locator, _size, _mtime_ns, names in records:
                 entry = located.get(locator)
-                if entry is not None:
-                    candidates[locator] = entry
+                if entry is not None and locator not in candidates:
+                    if _image_tags_relevant(names, wanted, query):
+                        candidates[locator] = entry
+        finally:
+            records.close()
         stats = {}
         for locator, entry in candidates.items():
             fingerprint = _current_fingerprint(entry.path)
@@ -2210,23 +2137,35 @@ class ImageRoutesMixin:
             )
         return matches
 
-    def _workspace_admission(
-        self, listings: list[tuple], filters: dict, *, read_links: bool, strict=False
+    def _select_workspace_page(
+        self,
+        listings: list[tuple],
+        filters: dict,
+        after: tuple | None,
+        limit: int,
+        scope: str,
     ) -> tuple:
-        """The ordered entries and what admits them (blocking; run in executor).
+        """One keyset page of the filtered listing (blocking; run in executor).
 
-        Returns ``(entries, key, links, image_tags, favorites)``: the listing in
-        the filters' order, its keyset key, and the link, image-tag and favorite
-        maps _admitted_entries reads. One SELECT (get_image_link_matches) reads
-        every linked positive when *read_links*. A failed read raises when the
-        filters need it (category, tags, the rating sort) or *strict*; else the
-        listing stays usable without links (a search then matches filenames
-        only). A failed image-tag read raises under a Tags filter; a search then
-        matches without image tags.
+        One SELECT (get_image_link_matches) reads every linked positive of the
+        listing: the filters, the rating sort and the positive count share it.
+        A plain listing (no ``q``, category, tags or rating sort) reads it only
+        for its first page; its cursor pages read no links and the returned
+        count is _COUNT_OMITTED, so the response leaves ``positive_count`` out
+        and the frontend keeps the first page's value. On that plain first
+        page a failed read leaves the listing usable and the count unknown
+        (None); so does a failed read under ``q`` alone, whose search then
+        matches filenames only (as before the linked search existed).
         """
         order, category, tags = filters["order"], filters["category"], filters["tags"]
+        needed = (
+            bool(filters["query"])
+            or category is not None
+            or bool(tags)
+            or order == "rating"
+        )
         links = None
-        if read_links:
+        if needed or after is None:
             try:
                 links = self.db.get_image_link_matches(
                     filters["text"],
@@ -2236,7 +2175,10 @@ class ImageRoutesMixin:
                     wanted=self._workspace_wanted(listings),
                 )
             except Exception:
-                if strict or category is not None or tags or order == "rating":
+                # Category, tags and the rating sort cannot be served without
+                # the links. A plain listing and a filename search can: the
+                # search then matches filenames only, and the count is None.
+                if category is not None or tags or order == "rating":
                     raise
                 self.logger.warning(
                     "Workspace prompt links could not be read; %s",
@@ -2252,6 +2194,8 @@ class ImageRoutesMixin:
             try:
                 image_tags = self._image_tag_matches(listings, filters)
             except Exception:
+                # A Tags filter cannot be served without them (as without the
+                # links); a search then matches without image tags.
                 if tags:
                     raise
                 self.logger.warning(
@@ -2290,41 +2234,6 @@ class ImageRoutesMixin:
             def key(entry):
                 return _workspace_key(entry, order)
 
-        favorites = (
-            self._workspace_favorite_paths(listings) if filters["favorites"] else None
-        )
-        return entries, key, links, image_tags, favorites
-
-    def _select_workspace_page(
-        self,
-        listings: list[tuple],
-        filters: dict,
-        after: tuple | None,
-        limit: int,
-        scope: str,
-    ) -> tuple:
-        """One keyset page of the filtered listing (blocking; run in executor).
-
-        The filters, the rating sort and the positive count share one link
-        read (_workspace_admission). A plain listing (no ``q``, category, tags
-        or rating sort) reads it only for its first page; its cursor pages read
-        no links and the returned count is _COUNT_OMITTED, so the response
-        leaves ``positive_count`` out and the frontend keeps the first page's
-        value. On that plain first page a failed read leaves the listing usable
-        and the count unknown (None); so does a failed read under ``q`` alone,
-        whose search then matches filenames only (as before the linked search
-        existed).
-        """
-        order = filters["order"]
-        needed = (
-            bool(filters["query"])
-            or filters["category"] is not None
-            or bool(filters["tags"])
-            or order == "rating"
-        )
-        entries, key, links, image_tags, favorites = self._workspace_admission(
-            listings, filters, read_links=needed or after is None
-        )
         start = 0
         if after is not None:
             if order == "name-desc":
@@ -2332,6 +2241,9 @@ class ImageRoutesMixin:
                 start = len(entries) - bisect_left(ascending, after, key=key)
             else:
                 start = bisect_right(entries, after, key=key)
+        favorites = (
+            self._workspace_favorite_paths(listings) if filters["favorites"] else None
+        )
         total, page, positive_count = _filtered_page(
             entries, start, limit + 1, filters, links, favorites, image_tags
         )
@@ -2348,61 +2260,6 @@ class ImageRoutesMixin:
             positive_count,
         )
 
-    def _select_workspace_matches(
-        self, listings: list[tuple], filters: dict, cap: int
-    ) -> ListingSelection:
-        """Every admitted entry, up to *cap*, as a ListingSelection (blocking).
-
-        The links are read strictly: the positives must be the listing's own.
-        """
-        entries, _key, links, image_tags, favorites = self._workspace_admission(
-            listings, filters, read_links=True, strict=True
-        )
-        targets, positives, unlinked, scopes = [], {}, 0, {}
-        for _position, entry, match in _admitted_entries(
-            entries, filters, links, favorites, image_tags
-        ):
-            if len(targets) == cap:
-                return ListingSelection(targets, list(positives), unlinked, True)
-            scope = scopes.get(entry.index)
-            if scope is None:
-                scope = scopes[entry.index] = self._gallery_root_scope(
-                    entry.root, entry.index
-                )
-            relative = entry.path.relative_to(entry.root).as_posix()
-            targets.append((entry.index, scope, relative))
-            if match is None or match[2] is None:
-                unlinked += 1
-            else:
-                positives.setdefault(match[2])
-        return ListingSelection(targets, list(positives), unlinked, False)
-
-    async def resolve_listing_filter(
-        self, params: Mapping, cap: int = MAX_LISTING_SELECTION
-    ) -> ListingSelection:
-        """The images a parse_listing_filter result admits right now (#392).
-
-        Raises ValueError for a root outside the current roots, and
-        ListingSourceChanged when the filter's ``root_scope`` no longer names
-        its root (the sources were renumbered since the listing).
-        """
-        output_dirs = list(self._get_all_output_dirs())
-        root_index = _workspace_root(params, output_dirs)
-        error = self._gallery_scope_error(params, output_dirs)
-        if error is not None:
-            if error.status == 409:
-                raise ListingSourceChanged()
-            raise ValueError("Invalid gallery root scope")
-        filters = _workspace_filters(params)
-        listings = [
-            (index, root, await self._get_gallery_files(root))
-            for index, root in enumerate(output_dirs)
-            if root_index is None or index == root_index
-        ]
-        return await self._run_in_executor(
-            self._select_workspace_matches, listings, filters, cap
-        )
-
     async def serve_image(self, request):
         """Serve the actual image file using streamed FileResponse."""
         try:

py/api/prompts.py

@@ -1178,8 +1178,6 @@ class PromptRoutesMixin:
                 return web.json_response(
                     {"success": False, "error": "Expected a JSON object"}, status=400
                 )
-            if "images_filter" in data:
-                return await self._bulk_category_by_filter(data)
             if not data.get("prompt_ids"):
                 return web.json_response(
                     {"success": False, "error": "No prompt IDs provided"}, status=400
@@ -1216,66 +1214,6 @@ class PromptRoutesMixin:
                 status=500,
             )
 
-    async def _bulk_category_by_filter(self, data: dict) -> web.Response:
-        """Set the category on every linked positive a listing filter admits.
-
-        #392 "Select all N matching": ``{images_filter, category}``, the filter
-        being the Images listing's own query (parse_listing_filter), resolved
-        now. The answer adds ``prompt_count`` (the distinct linked positives)
-        and ``skipped`` (matching images without one); none linked changes
-        nothing.
-        """
-        from .images import (
-            MAX_LISTING_SELECTION,
-            ListingSourceChanged,
-            parse_listing_filter,
-        )
-
-        def refused(message, **extra):
-            return web.json_response(
-                {"success": False, "error": message, **extra}, status=400
-            )
-
-        if set(data) != {"images_filter", "category"}:
-            return refused("Request must contain exactly category, images_filter")
-        category = data["category"]
-        try:
-            params = parse_listing_filter(data["images_filter"])
-            validate_category(category)
-            selection = await self.resolve_listing_filter(params)
-        except ListingSourceChanged:
-            return web.json_response(
-                {
-                    "success": False,
-                    "code": "source-changed",
-                    "error": "The source changed. Refresh the image collection.",
-                },
-                status=409,
-            )
-        except ValueError as exc:
-            return refused(str(exc))
-        if selection.truncated:
-            return refused(
-                f"Narrow the view to at most {MAX_LISTING_SELECTION:,} images.",
-                code="too-many-images",
-            )
-        category = (category or "").strip()
-        ids = selection.positive_ids
-        updated = (
-            await self._run_in_executor(self.db.bulk_set_category, ids, category)
-            if ids
-            else 0
-        )
-        return web.json_response(
-            {
-                "success": True,
-                "message": f"Set category for {updated} prompts",
-                "updated_count": updated,
-                "prompt_count": len(ids),
-                "skipped": selection.unlinked,
-            }
-        )
-
     def _all_prompts_for_export(self):
         """Every prompt, fetched in EXPORT_PAGE_SIZE pages (blocking)."""
         prompts, offset = [], 0

tests/browser/legacy-system-links.spec.mjs

@@ -1,163 +0,0 @@
-// System S13 (#330): the legacy admin and gallery pages open native System for their System tools. Each replaced
-// control is a plain link (`workspace#/system/<id>`, a new tab), and the legacy flows S13 keeps still work.
-import { startCoverage, saveCoverage } from '../../tools/vendor/browser-coverage.mjs';
-import { test, expect } from './fixtures.mjs';
-
-const PAGES = Object.freeze({ admin: '/prompt_manager/admin', gallery: '/prompt_manager/gallery' });
-const LABELS = Object.freeze({
-    overview: 'Overview',
-    appearance: 'Appearance',
-    sources: 'Sources & scans',
-    integrations: 'Integrations',
-    tagging: 'Auto-tagging',
-    maintenance: 'Maintenance',
-    backups: 'Backup & export',
-    diagnostics: 'Diagnostics & logs',
-});
-
-// One row per System link of the design's §2 map: the page, the control's label, how to find it, the section it opens
-// and what a test must arrange before the control shows.
-const LINKS = Object.freeze([
-    { page: 'admin', label: 'Diagnostics', locate: page => page.locator('#diagnosticsBtn'), section: 'diagnostics' },
-    { page: 'admin', label: 'View Logs', locate: page => page.locator('#logsBtn'), section: 'diagnostics' },
-]);
-
-async function post(request, url, data) {
-    await expect(await request.post(url, data === undefined ? {} : { data })).toBeOK();
-}
-
-test.beforeEach(async ({ page, request, browserName }) => {
-    await startCoverage(page, browserName);
-    await post(request, '/__test__/reset');
-    await post(request, '/__test__/system/reset');
-    await post(request, '/__test__/tagging/reset');
-    // The 3.2.0 update notice would cover the admin page's toolbar.
-    await page.addInitScript(() => { localStorage.setItem('pm_update_notice_dismissed', '3.2.0'); });
-    page.legacyErrors = [];
-    page.on('pageerror', error => page.legacyErrors.push(error.message));
-});
-
-test.afterEach(async ({ page, request, browserName }) => {
-    await saveCoverage(page, browserName);
-    await post(request, '/__test__/tagging/reset');
-    await post(request, '/__test__/system/reset');
-    expect(page.legacyErrors).toEqual([]);
-});
-
-/** Opens the legacy page with the link showing; returns the link. */
-async function openLink(page, request, link) {
-    if (link.arrange) await link.arrange(page, request);
-    await page.goto(PAGES[link.page]);
-    if (link.reveal) await link.reveal(page);
-    const control = link.locate(page);
-    await expect(control).toBeVisible();
-    return control;
-}
-
-for (const link of LINKS) {
-    test(`legacy ${link.page} ${link.label} opens System ${link.section}`, async ({ page, context, request }) => {
-        const control = await openLink(page, request, link);
-        const legacyUrl = page.url();
-        await expect(control).toHaveAttribute('href', `workspace#/system/${link.section}`);
-        await expect(control).toHaveAttribute('target', '_blank');
-        await expect(control).toHaveAttribute('rel', 'noopener');
-        const opened = context.waitForEvent('page');
-        await control.click();
-        const system = await opened;
-        await expect(system).toHaveURL(new RegExp(`/prompt_manager/workspace#/system/${link.section}$`));
-        // System's page heading is "System"; the open section is the pressed button of its section switcher.
-        const main = system.locator('#workspace-main');
-        await expect(main.getByRole('heading', { level: 1, name: 'System', exact: true })).toBeVisible();
-        await expect(main.getByRole('group', { name: 'System sections', exact: true })
-            .getByRole('button', { name: LABELS[link.section], exact: true })).toHaveAttribute('aria-pressed', 'true');
-        expect(page.url()).toBe(legacyUrl);
-        await system.close();
-    });
-}
-
-test('a System link sends no request from the legacy page', async ({ page, context, request }) => {
-    for (const link of LINKS) {
-        const control = await openLink(page, request, link);
-        // The page's own start-up reads (list, film strips, settings) finish first; then the click must add none.
-        await page.waitForLoadState('networkidle');
-        const sent = [];
-        const record = item => sent.push(`${item.method()} ${item.url()}`);
-        page.on('request', record);
-        const opened = context.waitForEvent('page');
-        await control.click();
-        const system = await opened;
-        await system.waitForLoadState('domcontentloaded');
-        page.off('request', record);
-        expect(sent, `${link.page} ${link.label}`).toEqual([]);
-        await system.close();
-    }
-});
-
-test('kept admin flows still work', async ({ page, context }) => {
-    await page.goto(PAGES.admin);
-    const texts = page.locator('#resultsList .prompt-text');
-    await expect(texts.first()).toBeVisible();
-
-    // K1: sorting reorders the list.
-    for (const [value, order] of [['text_asc', 1], ['text_desc', -1]]) {
-        const listed = page.waitForResponse(item => /\/prompt_manager\/(recent|search)\?/.test(item.url()) && item.url().includes(`sort=${value}`));
-        await page.locator('#sortBy').selectOption(value);
-        await listed;
-        await expect.poll(async () => {
-            const shown = await texts.allTextContents();
-            // The server sorts case-insensitively (SQLite NOCASE), not by locale.
-            const key = text => text.toLowerCase();
-            const sorted = [...shown].sort((a, b) => order * (key(a) < key(b) ? -1 : key(a) > key(b) ? 1 : 0));
-            return shown.length > 1 && shown.join('\n') === sorted.join('\n');
-        }).toBe(true);
-    }
-    // K3: Add Prompt saves a prompt the list then shows.
-    await page.locator('#addPromptBtn').click();
-    await page.locator('#addPromptText').fill('Kept flow lighthouse');
-    const saved = page.waitForResponse(item => item.request().method() === 'POST' && item.url().endsWith('/prompt_manager/save'));
-    await page.locator('#saveNewPromptBtn').click();
-    expect((await saved).ok()).toBe(true);
-    await expect(page.locator('#addPromptModal')).toBeHidden();
-    await expect(texts.filter({ hasText: 'Kept flow lighthouse' })).toBeVisible();
-
-    // K1: a search narrows the list, and a selection enables the bulk buttons.
-    const all = await texts.allTextContents();
-    const word = all[0].trim().split(/\s+/)[0];
-    const searched = page.waitForResponse(item => item.url().includes('/prompt_manager/search?') && item.url().includes('text='));
-    await page.locator('#searchText').fill(word);
-    await page.locator('#searchBtn').click();
-    await searched;
-    await expect.poll(async () => {
-        const shown = await texts.allTextContents();
-        return shown.length > 0 && shown.length < all.length && shown.every(text => text.toLowerCase().includes(word.toLowerCase()));
-    }).toBe(true);
-    await expect(page.locator('#bulkDeleteBtn')).toBeDisabled();
-    await page.locator('#resultsList .prompt-checkbox').first().check();
-    for (const id of ['#bulkDeleteBtn', '#bulkTagBtn', '#bulkCategoryBtn']) await expect(page.locator(id)).toBeEnabled();
-
-    // K4: Stats reads the statistics again; Export downloads the prompts.
-    const stats = page.waitForResponse(item => item.url().endsWith('/prompt_manager/stats') && item.ok());
-    await page.locator('#statsBtn').click();
-    await stats;
-    await expect(page.getByText('Stats refreshed successfully!')).toBeVisible();
-    const download = page.waitForEvent('download');
-    await page.locator('#exportBtn').click();
-    expect((await download).suggestedFilename()).toMatch(/^prompts-\d{4}-\d{2}-\d{2}\.json$/);
-
-    // K5: Scan Images opens its dialog (with the quick backup) without starting a scan.
-    await page.locator('#scanBtn').click();
-    await expect(page.locator('#scanModal')).toBeVisible();
-    await expect(page.locator('#quickBackupBtn')).toBeVisible();
-    await page.locator('#cancelScan').click();
-    await expect(page.locator('#scanModal')).toBeHidden();
-
-    // K7: Metadata and Gallery open their pages in a new tab.
-    for (const [id, path] of [['#metadataBtn', '/prompt_manager/gallery.html'], ['#galleryBtn', '/prompt_manager/gallery']]) {
-        const opened = context.waitForEvent('page');
-        await page.locator(id).click();
-        const tab = await opened;
-        await tab.waitForLoadState('domcontentloaded');
-        expect(new URL(tab.url()).pathname).toBe(path);
-        await tab.close();
-    }
-});

tests/browser/workspace-images.spec.mjs

@@ -2189,248 +2189,3 @@ test('scan for metadata opens the review dialog from Import', async ({ page, req
     await expect.poll(async () => (await (await request.get('/prompt_manager/jobs')).json()).jobs
         .map(job => [job.kind, job.state])).toEqual([['backup', 'finished']]);
 });
-
-// #392 (D135): file-manager selection beyond the concept's checkbox.
-const selectedCount = page => bulkbar(page).locator('.bulkbar > strong');
-const cardAt = (page, index) => page.locator(`article[data-image-key][data-index="${index}"]`);
-const boxAt = (page, index) => cardAt(page, index).getByRole('checkbox', { name: /^Select / });
-const checkedIndexes = page => page.locator('article[data-image-key]').evaluateAll(nodes => nodes
-    .filter(node => node.querySelector('.image-overlays input[type="checkbox"]').checked)
-    .map(node => Number(node.dataset.index)).sort((a, b) => a - b));
-const range = (from, to) => Array.from({ length: to - from + 1 }, (_, index) => from + index);
-async function bulkReset(page, request) {
-    await page.addInitScript(() => { window.IntersectionObserver = undefined; });
-    await expect(await request.post('/__test__/reset', { data: { extra_images: 200 } })).toBeOK();
-    await page.goto(workspace);
-    await expect(cards(page)).toHaveCount(40);
-}
-/** A touch press on `locator` the way a finger makes one: pointerdown, (held), pointerup. */
-const touchDown = locator => locator.evaluate(node => {
-    const { left, top } = node.getBoundingClientRect();
-    node.dispatchEvent(new PointerEvent('pointerdown', { bubbles: true, isPrimary: true, pointerType: 'touch', clientX: left + 5, clientY: top + 5 }));
-});
-const touchUpAndClick = locator => locator.evaluate(node => {
-    node.dispatchEvent(new PointerEvent('pointerup', { bubbles: true, isPrimary: true, pointerType: 'touch' }));
-    // A tap's click counts one press (`detail` 1); a keyboard click (and `HTMLElement.click()`) counts none.
-    node.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true, detail: 1 }));
-});
-async function touchTap(locator) {
-    await touchDown(locator);
-    await touchUpAndClick(locator);
-}
-
-test('Shift+click selects a range across an appended batch in Grid, List and Masonry', async ({ page, request }) => {
-    await bulkReset(page, request);
-    await page.getByRole('button', { name: 'Load more images', exact: true }).click();
-    await expect(caption(page)).toContainText('80 of 202 images');
-    for (const mode of ['Grid', 'List', 'Masonry']) {
-        await page.getByRole('group', { name: 'Image layout', exact: true }).getByRole('button', { name: mode, exact: true }).click();
-        // The anchor is the last image toggled on its own (List hides the concept's checkbox: the card carries it).
-        await cardAt(page, 3).locator('.media-info h3').click({ modifiers: ['ControlOrMeta'] });
-        await expect(selectedCount(page)).toHaveText('1 selected');
-        // The range runs into the second batch (index 40 on), and backwards from the same anchor.
-        await cardAt(page, 45).locator('.media-info h3').click({ modifiers: ['Shift'] });
-        await expect(selectedCount(page)).toHaveText('43 selected');
-        expect(await checkedIndexes(page)).toEqual(range(3, 45));
-        await cardAt(page, 0).locator('.media-info h3').click({ modifiers: ['Shift'] });
-        await expect(selectedCount(page)).toHaveText('46 selected');
-        expect(await checkedIndexes(page)).toEqual(range(0, 45));
-        await expect(page.locator('dialog[open]')).toHaveCount(0);
-        if (mode !== 'List') {
-            // A Shift+click on a checkbox gives its range the box's new state: here, unchecked.
-            await boxAt(page, 3).uncheck();
-            await boxAt(page, 10).click({ modifiers: ['Shift'] });
-            await expect(boxAt(page, 10)).not.toBeChecked();
-            await expect(selectedCount(page)).toHaveText('38 selected');
-            expect(await checkedIndexes(page)).toEqual([0, 1, 2, ...range(11, 45)]);
-        }
-        await bulkbar(page).getByRole('button', { name: 'Clear', exact: true }).click();
-        await expect(bulkbar(page)).toBeEmpty();
-    }
-});
-
-test('Ctrl/Cmd+click toggles a card without opening it, and a plain click still opens the viewer', async ({ page }) => {
-    await page.goto(workspace);
-    await expect(cards(page)).toHaveCount(2);
-    const first = cards(page).first();
-    const inspectorBefore = await details(page).innerText();
-    await first.getByRole('button', { name: 'Open same.png', exact: true }).click({ modifiers: ['ControlOrMeta'] });
-    await expect(selectedCount(page)).toHaveText('1 selected');
-    await expect(checkbox(first, 'same.png')).toBeChecked();
-    await cards(page).last().getByRole('button', { name: 'Inspect same.png', exact: true }).click({ modifiers: ['ControlOrMeta'] });
-    await expect(selectedCount(page)).toHaveText('2 selected');
-    await star(first, 'same.png').click({ modifiers: ['ControlOrMeta'] });
-    await expect(selectedCount(page)).toHaveText('1 selected');
-    await expect(star(first, 'same.png')).toHaveAttribute('aria-pressed', 'false');
-    await expect(page.locator('dialog[open]')).toHaveCount(0);
-    expect(await details(page).innerText()).toBe(inspectorBefore);
-    // A plain click keeps its meaning: the image opens the viewer.
-    await first.getByRole('button', { name: 'Open same.png', exact: true }).click();
-    await expect(page.locator('#viewer-dialog[open]')).toHaveCount(1);
-    await expect(selectedCount(page)).toHaveText('1 selected');
-});
-
-test('Ctrl/Cmd+A, Select all N matching and Add tags tag every matching image on the server', async ({ page, request }) => {
-    await bulkReset(page, request);
-    // Ctrl/Cmd+A in the search box stays the field's own.
-    await search(page).focus();
-    await page.keyboard.press('ControlOrMeta+a');
-    await expect(bulkbar(page)).toBeEmpty();
-    await cardAt(page, 0).getByRole('button', { name: /^Open / }).focus();
-    await page.keyboard.press('ControlOrMeta+a');
-    await expect(selectedCount(page)).toHaveText('40 selected');
-    const offer = bulkbar(page).getByRole('button', { name: 'Select all 202 matching', exact: true });
-    await expect(offer).toBeVisible();
-    await expect(bulkbar(page).locator('.bulkbar > *').nth(1)).toHaveText('Select all 202 matching');
-    await offer.click();
-    await expect(selectedCount(page)).toHaveText('All 202 matching selected');
-    await expect(offer).toHaveCount(0);
-    await expect(bulkbar(page).getByRole('button', { name: 'Export metadata', exact: true })).toHaveAttribute('aria-disabled', 'true');
-    // A later batch arrives checked.
-    await page.getByRole('button', { name: 'Load more images', exact: true }).click();
-    await expect(caption(page)).toContainText('80 of 202 images');
-    await expect(boxAt(page, 70)).toBeChecked();
-    await expect(selectedCount(page)).toHaveText('All 202 matching selected');
-    // Unchecking one image leaves "all matching": the other loaded images stay selected.
-    await boxAt(page, 0).uncheck();
-    await expect(selectedCount(page)).toHaveText('79 selected');
-    await expect(bulkbar(page).getByRole('button', { name: 'Export metadata', exact: true })).not.toHaveAttribute('aria-disabled', 'true');
-    await cardAt(page, 1).getByRole('button', { name: /^Open / }).focus();
-    await page.keyboard.press('ControlOrMeta+a');
-    await bulkbar(page).getByRole('button', { name: 'Select all 202 matching', exact: true }).click();
-    await expect(selectedCount(page)).toHaveText('All 202 matching selected');
-    // Add tags sends the listing filter, not 202 identities, and the server tags every match.
-    await bulkbar(page).getByRole('button', { name: 'Add tags', exact: true }).click();
-    const dialog = page.getByRole('dialog', { name: 'Tag selected images', exact: true });
-    await dialog.getByRole('textbox', { name: 'Tags, separated by commas', exact: true }).fill('picked392');
-    const started = page.waitForRequest(item => item.method() === 'POST' && new URL(item.url()).pathname === '/prompt_manager/jobs/image-tags');
-    await dialog.getByRole('button', { name: 'Apply', exact: true }).click();
-    expect((await started).postDataJSON()).toEqual({ mode: 'add', filter: { sort: 'newest' }, tags: ['picked392'] });
-    await expect.poll(async () => (await (await request.get('/prompt_manager/images/output?mode=workspace&limit=1&tags=picked392')).json()).total,
-        { timeout: 20000 }).toBe(202);
-    await expect(selectedCount(page)).toHaveText('All 202 matching selected');
-    // Escape in the grid clears the selection.
-    await cardAt(page, 2).getByRole('button', { name: /^Open / }).focus();
-    await page.keyboard.press('Escape');
-    await expect(bulkbar(page)).toBeEmpty();
-    await expect(boxAt(page, 2)).not.toBeChecked();
-});
-
-test('Shift+arrow keys extend the selection from the focused card, and Escape in the bar clears it', async ({ page, request }) => {
-    await bulkReset(page, request);
-    await cardAt(page, 0).getByRole('button', { name: /^Open / }).focus();
-    await page.keyboard.press('Shift+ArrowRight');
-    await page.keyboard.press('Shift+ArrowRight');
-    await expect(cardAt(page, 2).getByRole('button', { name: /^Open / })).toBeFocused();
-    await expect(selectedCount(page)).toHaveText('3 selected');
-    expect(await checkedIndexes(page)).toEqual([0, 1, 2]);
-    // A plain arrow moves without selecting; Shift+End reaches the last loaded card from the same anchor.
-    await page.keyboard.press('ArrowRight');
-    await expect(selectedCount(page)).toHaveText('3 selected');
-    await page.keyboard.press('Shift+End');
-    await expect(selectedCount(page)).toHaveText('40 selected');
-    await bulkbar(page).getByRole('button', { name: 'Clear', exact: true }).focus();
-    await page.keyboard.press('Escape');
-    await expect(bulkbar(page)).toBeEmpty();
-    await expect(page.locator('#workspace-main h1')).toBeFocused();
-});
-
-test('a touch long-press starts selection mode, taps then toggle, and an empty selection ends it', async ({ page }, testInfo) => {
-    await page.goto(workspace);
-    await expect(cards(page)).toHaveCount(2);
-    const [first, second] = [cards(page).first(), cards(page).last()];
-    const open = card => card.getByRole('button', { name: 'Open same.png', exact: true });
-    await touchDown(open(first));
-    // The context menu of a held press belongs to the long press.
-    expect(await open(first).evaluate(node => !node.dispatchEvent(new MouseEvent('contextmenu', { bubbles: true, cancelable: true })))).toBe(true);
-    // Held: the long press selects the card once its delay passed.
-    await expect(selectedCount(page)).toHaveText('1 selected');
-    await touchUpAndClick(open(first));
-    await expect(page.locator('dialog[open]')).toHaveCount(0);
-    await expect(checkbox(first, 'same.png')).toBeChecked();
-    // Taps now toggle instead of opening.
-    if (testInfo.project.name === 'touch') await open(second).tap();
-    else await touchTap(open(second));
-    await expect(selectedCount(page)).toHaveText('2 selected');
-    // A keyboard Enter keeps its meaning in touch selection mode: the image opens.
-    await open(first).focus();
-    await page.keyboard.press('Enter');
-    await expect(page.locator('#viewer-dialog[open]')).toHaveCount(1);
-    await page.keyboard.press('Escape');
-    await expect(page.locator('#viewer-dialog[open]')).toHaveCount(0);
-    await expect(selectedCount(page)).toHaveText('2 selected');
-    await touchTap(open(first));
-    await touchTap(open(second));
-    await expect(bulkbar(page)).toBeEmpty();
-    await expect(page.locator('dialog[open]')).toHaveCount(0);
-    // The selection is empty, so touch selection mode ended: a tap opens the image again.
-    await touchTap(open(first));
-    await expect(page.locator('#viewer-dialog[open]')).toHaveCount(1);
-});
-
-test('all matching sets the category through the listing filter and survives a return visit as the loaded images', async ({ page, request }) => {
-    await bulkReset(page, request);
-    await cardAt(page, 0).getByRole('button', { name: /^Open / }).focus();
-    await page.keyboard.press('ControlOrMeta+a');
-    await bulkbar(page).getByRole('button', { name: 'Select all 202 matching', exact: true }).click();
-    // The offer left with its press: focus moves to the bar's first action.
-    await expect(bulkbar(page).getByRole('button', { name: 'Add tags', exact: true })).toBeFocused();
-    await cardAt(page, 0).getByRole('button', { name: /^Open / }).focus();
-    await page.keyboard.press('ControlOrMeta+a');
-    await expect(selectedCount(page)).toHaveText('All 202 matching selected');
-    // Export metadata waits for loaded images: a press does nothing.
-    const exportButton = bulkbar(page).getByRole('button', { name: 'Export metadata', exact: true });
-    await expect(exportButton).toHaveAttribute('title', 'Export metadata reads each image in the browser, so it works on loaded images only.');
-    // No match linked (a stubbed answer): the nothing-linked sentence, and the selection stays.
-    await page.route('**/prompt_manager/bulk/category', route => route.fulfill({ json: { success: true, updated_count: 0, prompt_count: 0, skipped: 202 } }), { times: 1 });
-    const categorize = page.getByRole('dialog', { name: 'Categorize selected images', exact: true });
-    await bulkbar(page).getByRole('button', { name: 'Set category', exact: true }).click();
-    await categorize.getByRole('textbox', { name: 'Category', exact: true }).fill('Bulk392');
-    await categorize.getByRole('button', { name: 'Apply', exact: true }).click();
-    await expect(toast(page)).toHaveText("None of the selected images is linked to a saved prompt, so there is no prompt category to set.");
-    await expect(selectedCount(page)).toHaveText('All 202 matching selected');
-    // The real write: one request with the filter, every matching image's positive changes.
-    await bulkbar(page).getByRole('button', { name: 'Set category', exact: true }).click();
-    await categorize.getByRole('textbox', { name: 'Category', exact: true }).fill('Bulk392');
-    const posted = page.waitForRequest(item => item.method() === 'POST' && new URL(item.url()).pathname === '/prompt_manager/bulk/category');
-    await categorize.getByRole('button', { name: 'Apply', exact: true }).click();
-    expect((await posted).postDataJSON()).toEqual({ images_filter: { sort: 'newest' }, category: 'Bulk392' });
-    await expect(toast(page)).toHaveText(/^Category set on \d+ prompts?\.$/);
-    await expect(bulkbar(page)).toBeEmpty();
-    const filtered = await (await request.get('/prompt_manager/images/output?mode=workspace&limit=1&category=Bulk392')).json();
-    expect(filtered.total).toBe(202);
-    // A return visit keeps "all matching" as the loaded images, and the offer shows again.
-    await cardAt(page, 0).getByRole('button', { name: /^Open / }).focus();
-    await page.keyboard.press('ControlOrMeta+a');
-    await bulkbar(page).getByRole('button', { name: 'Select all 202 matching', exact: true }).click();
-    await page.evaluate(() => { window.location.hash = '/overview'; });
-    await expect(page.locator('#workspace-main h1')).toHaveText('Overview');
-    await page.evaluate(() => { window.location.hash = '/images'; });
-    await expect(selectedCount(page)).toHaveText('40 selected');
-    await expect(bulkbar(page).getByRole('button', { name: 'Select all 202 matching', exact: true })).toBeVisible();
-    // Escape in the bar with nothing selected does nothing; with a selection it clears.
-    await bulkbar(page).getByRole('button', { name: 'Clear', exact: true }).focus();
-    await page.keyboard.press('Escape');
-    await expect(bulkbar(page)).toBeEmpty();
-});
-
-test('all matching over 10,000 images says so before any dialog or request', async ({ page, request }) => {
-    await page.route(url => url.pathname === '/prompt_manager/images/output' && url.searchParams.get('limit') !== '1', async route => {
-        const response = await route.fetch();
-        const body = await response.json();
-        await route.fulfill({ response, json: { ...body, total: 20002 } });
-    });
-    await bulkReset(page, request);
-    await cardAt(page, 0).getByRole('button', { name: /^Open / }).focus();
-    await page.keyboard.press('ControlOrMeta+a');
-    await bulkbar(page).getByRole('button', { name: 'Select all 20,002 matching', exact: true }).click();
-    await expect(selectedCount(page)).toHaveText('All 20,002 matching selected');
-    let posted = 0;
-    page.on('request', item => { if (item.method() === 'POST') posted += 1; });
-    for (const action of ['Set category', 'Add tags', 'Auto-tag selected']) {
-        await bulkbar(page).getByRole('button', { name: action, exact: true }).click();
-        await expect(toast(page)).toHaveText('Narrow the view to at most 10,000 images.');
-        await expect(page.locator('dialog[open]')).toHaveCount(0);
-    }
-    expect(posted).toBe(0);
-});

tests/browser/workspace-tagging.spec.mjs

@@ -513,41 +513,6 @@ test('search finds an image by its image tag', async ({ page, request }) => {
     await expect(card(page, UNLINKED)).toBeVisible();
 });
 
-// #379 CUJ 8: the Tags filter finds images by their own image tags through the tag index; no prompt carries them, and
-// selecting a match shows its prompt. A linked prompt's tag still combines with the image tags.
-test('the Tags filter finds images by image tags only, and selecting one shows its prompt (#379)', async ({ page, request }) => {
-    await saveImageTags(request, FIRST, ['beach', '1girl', 'waves']);
-    await saveImageTags(request, SECOND, ['beach', 'waves']);
-    await saveImageTags(request, UNLINKED, ['beach', '1girl', 'waves', 'gulls']);
-    await page.goto(images);
-    await expect(page.locator('.gallery-body article[data-image-key]')).toHaveCount(manifest.files.length);
-    const filters = page.locator('#workspace-main search.toolbar').getByRole('button', { name: /^Filters(?: · \d+)?$/ });
-    const refine = page.getByRole('dialog', { name: 'Refine this view', exact: true });
-    const applyTags = async value => {
-        await filters.click();
-        await refine.getByLabel('Tags', { exact: true }).fill(value);
-        const listing = page.waitForRequest(item => item.url().includes('/images/output?')
-            && new URL(item.url()).searchParams.get('tags') !== null);
-        await refine.getByRole('button', { name: 'Apply filters', exact: true }).click();
-        await listing;
-    };
-    await applyTags('beach, 1girl, waves');
-    // Every listed image whose image tags hold all three; SECOND lacks 1girl.
-    await expect(page.locator('.gallery-body article[data-image-key]')).toHaveCount(2);
-    await expect(card(page, FIRST)).toBeVisible();
-    await expect(card(page, UNLINKED)).toBeVisible();
-    await expect(card(page, SECOND)).toHaveCount(0);
-    // The newest match is selected; the inspector shows its linked prompt.
-    await infoButton(page, FIRST).click();
-    await expect(card(page, FIRST)).toHaveClass(/\bselected\b/);
-    await expect(panel(page).locator('.panel-heading h2')).toHaveText(manifest.title);
-    // The linked positive's own tag combines: SECOND has beach and waves itself and minimal through its prompt.
-    await applyTags(`beach, waves, ${manifest.prompt_tags[0]}`);
-    await expect(page.locator('.gallery-body article[data-image-key]')).toHaveCount(2);
-    await expect(card(page, FIRST)).toBeVisible();
-    await expect(card(page, SECOND)).toBeVisible();
-});
-
 // Task C4 rulings: a save re-reads the selected file's details without a loading flash, and under a Tags filter or a
 // search the loaded listing is re-read in place (scroll and selection kept while the file still matches).
 const cards = page => page.locator('.gallery-body article[data-image-key]');

tests/fixtures/README.md

@@ -113,19 +113,3 @@ by their own suites. The expectations start as the observed baseline. A change
 that alters an outcome edits the vector in the same commit.
 `tests/js/legacy-metadata-characterization.test.js` pins what
 the legacy viewers show on the same files.
-
-# Legacy contract snapshot
-
-`legacy_contract_snapshot.json` records what the legacy admin and gallery pages
-talk to while System S13 (#330) moves their tools to native System: every
-registered route as `"<METHOD> <path>"` (`routes`) and the key paths of
-`GET /prompt_manager/settings` to depth 2 (`settings_keys`; list items give the
-union of their keys as `name[].key`). `tests/test_legacy_contract_snapshot.py`
-compares a temp-database API against it. Record it again only for an intended
-change, and say why in the PR body:
-
-```sh
-PM_RECORD_LEGACY_SNAPSHOT=1 python3 -m unittest tests.test_legacy_contract_snapshot
-```
-
-Cutover (#334) removes the test and this fixture.

tests/fixtures/legacy_contract_snapshot.json

@@ -1,200 +0,0 @@
-{
-  "routes": [
-    "DELETE /prompt_manager/delete/{prompt_id}",
-    "DELETE /prompt_manager/image-annotations/capture/{token}",
-    "DELETE /prompt_manager/images/favorite",
-    "DELETE /prompt_manager/images/{image_id}",
-    "DELETE /prompt_manager/pairs/{pair_id}",
-    "DELETE /prompt_manager/prompts/{prompt_id}/tags",
-    "DELETE /prompt_manager/restore/preview/{token}",
-    "DELETE /prompt_manager/saved-views/{view_id}",
-    "DELETE /prompt_manager/tags/{tag_name}",
-    "GET /prompt_manager/admin",
-    "GET /prompt_manager/autotag/models",
-    "GET /prompt_manager/backup",
-    "GET /prompt_manager/backup/status",
-    "GET /prompt_manager/categories",
-    "GET /prompt_manager/diagnostics",
-    "GET /prompt_manager/export",
-    "GET /prompt_manager/gallery",
-    "GET /prompt_manager/gallery.html",
-    "GET /prompt_manager/gallery/subfolders",
-    "GET /prompt_manager/history/runs/{run_id}",
-    "GET /prompt_manager/history/runs/{run_id}/output/current/inspection",
-    "GET /prompt_manager/history/runs/{run_id}/output/current/media",
-    "GET /prompt_manager/history/runs/{run_id}/output/current/thumbnail",
-    "GET /prompt_manager/history/runs/{run_id}/outputs",
-    "GET /prompt_manager/image-annotations/capture/{token}",
-    "GET /prompt_manager/images/all",
-    "GET /prompt_manager/images/inspect/{image_path}",
-    "GET /prompt_manager/images/output",
-    "GET /prompt_manager/images/prompt/{image_path}",
-    "GET /prompt_manager/images/recent",
-    "GET /prompt_manager/images/search",
-    "GET /prompt_manager/images/serve/{filepath}",
-    "GET /prompt_manager/images/thumbnails/plan",
-    "GET /prompt_manager/images/thumbnails/status",
-    "GET /prompt_manager/images/{image_id}/file",
-    "GET /prompt_manager/jobs",
-    "GET /prompt_manager/jobs/{job_id}",
-    "GET /prompt_manager/jobs/{job_id}/events",
-    "GET /prompt_manager/jobs/{job_id}/report",
-    "GET /prompt_manager/js/{filepath}",
-    "GET /prompt_manager/lib/{filepath}",
-    "GET /prompt_manager/library",
-    "GET /prompt_manager/library/export",
-    "GET /prompt_manager/library/options",
-    "GET /prompt_manager/library/{positive_id}",
-    "GET /prompt_manager/library/{positive_id}/history",
-    "GET /prompt_manager/library/{positive_id}/history/pairs/{pair_id}/newest",
-    "GET /prompt_manager/library/{positive_id}/images",
-    "GET /prompt_manager/logs",
-    "GET /prompt_manager/logs/config",
-    "GET /prompt_manager/logs/download/{filename}",
-    "GET /prompt_manager/logs/files",
-    "GET /prompt_manager/logs/stats",
-    "GET /prompt_manager/lora/detect",
-    "GET /prompt_manager/lora/status",
-    "GET /prompt_manager/lora/trigger-words",
-    "GET /prompt_manager/maintenance/duplicates/{job_id}",
-    "GET /prompt_manager/pairs",
-    "GET /prompt_manager/pairs/export",
-    "GET /prompt_manager/pairs/{pair_id}",
-    "GET /prompt_manager/prompts/{prompt_id}/images",
-    "GET /prompt_manager/recent",
-    "GET /prompt_manager/review/events",
-    "GET /prompt_manager/review/items",
-    "GET /prompt_manager/review/items/{item_id}",
-    "GET /prompt_manager/saved-views",
-    "GET /prompt_manager/scan/status",
-    "GET /prompt_manager/scan_duplicates",
-    "GET /prompt_manager/scan_duplicates/status",
-    "GET /prompt_manager/scan_output_dir",
-    "GET /prompt_manager/search",
-    "GET /prompt_manager/settings",
-    "GET /prompt_manager/stats",
-    "GET /prompt_manager/subfolders",
-    "GET /prompt_manager/system/diagnostics",
-    "GET /prompt_manager/system/health",
-    "GET /prompt_manager/system/library",
-    "GET /prompt_manager/system/overview",
-    "GET /prompt_manager/system/statistics",
-    "GET /prompt_manager/tags",
-    "GET /prompt_manager/tags/filter",
-    "GET /prompt_manager/tags/stats",
-    "GET /prompt_manager/tags/suggest",
-    "GET /prompt_manager/tags/{tag_name}/prompts",
-    "GET /prompt_manager/test",
-    "GET /prompt_manager/vocabulary/categories",
-    "GET /prompt_manager/vocabulary/tags",
-    "GET /prompt_manager/vocabulary/tags/{tag_id}/impact",
-    "GET /prompt_manager/web",
-    "GET /prompt_manager/workspace",
-    "PATCH /prompt_manager/library/{positive_id}",
-    "PATCH /prompt_manager/pairs/{pair_id}",
-    "PATCH /prompt_manager/saved-views/{view_id}",
-    "PATCH /prompt_manager/vocabulary/tags/{tag_id}",
-    "POST /prompt_manager/autotag/apply",
-    "POST /prompt_manager/autotag/batch/preview",
-    "POST /prompt_manager/autotag/download/{model_type}",
-    "POST /prompt_manager/autotag/single",
-    "POST /prompt_manager/autotag/start",
-    "POST /prompt_manager/autotag/unload",
-    "POST /prompt_manager/bulk/category",
-    "POST /prompt_manager/bulk/delete",
-    "POST /prompt_manager/bulk/tags",
-    "POST /prompt_manager/cleanup",
-    "POST /prompt_manager/delete_duplicate_images",
-    "POST /prompt_manager/diagnostics/test-link",
-    "POST /prompt_manager/gallery/rescan",
-    "POST /prompt_manager/image-annotations/observe",
-    "POST /prompt_manager/image-annotations/suggest",
-    "POST /prompt_manager/images/clear-thumbnails",
-    "POST /prompt_manager/images/generate-thumbnails",
-    "POST /prompt_manager/images/generate-thumbnails/progress",
-    "POST /prompt_manager/images/link",
-    "POST /prompt_manager/images/reveal",
-    "POST /prompt_manager/jobs/autotag",
-    "POST /prompt_manager/jobs/duplicates",
-    "POST /prompt_manager/jobs/image-tags",
-    "POST /prompt_manager/jobs/model-download",
-    "POST /prompt_manager/jobs/scan",
-    "POST /prompt_manager/jobs/thumbnails",
-    "POST /prompt_manager/jobs/{job_id}/cancel",
-    "POST /prompt_manager/library",
-    "POST /prompt_manager/library/{positive_id}/variants",
-    "POST /prompt_manager/logs/config",
-    "POST /prompt_manager/logs/truncate",
-    "POST /prompt_manager/lora/enable",
-    "POST /prompt_manager/lora/import/apply",
-    "POST /prompt_manager/lora/import/preview",
-    "POST /prompt_manager/lora/refresh-cache",
-    "POST /prompt_manager/lora/scan",
-    "POST /prompt_manager/maintenance",
-    "POST /prompt_manager/maintenance/apply",
-    "POST /prompt_manager/maintenance/preview",
-    "POST /prompt_manager/pairs",
-    "POST /prompt_manager/prompts/tags",
-    "POST /prompt_manager/prompts/{prompt_id}/tags",
-    "POST /prompt_manager/restore",
-    "POST /prompt_manager/restore/apply",
-    "POST /prompt_manager/restore/preview",
-    "POST /prompt_manager/review/items/{item_id}/decision",
-    "POST /prompt_manager/save",
-    "POST /prompt_manager/saved-views",
-    "POST /prompt_manager/scan",
-    "POST /prompt_manager/scan/cancel",
-    "POST /prompt_manager/scan_duplicates/stream",
-    "POST /prompt_manager/settings",
-    "POST /prompt_manager/settings/validate-source",
-    "POST /prompt_manager/system/health",
-    "POST /prompt_manager/system/library/keep",
-    "POST /prompt_manager/system/library/move",
-    "POST /prompt_manager/tags/merge",
-    "POST /prompt_manager/vocabulary/categories/apply",
-    "POST /prompt_manager/vocabulary/categories/preview",
-    "POST /prompt_manager/vocabulary/tags",
-    "POST /prompt_manager/vocabulary/tags/{tag_id}/delete",
-    "PUT /prompt_manager/image-annotations/tags",
-    "PUT /prompt_manager/images/favorite",
-    "PUT /prompt_manager/prompts/{prompt_id}",
-    "PUT /prompt_manager/prompts/{prompt_id}/rating",
-    "PUT /prompt_manager/tags/{tag_name}"
-  ],
-  "settings_keys": [
-    "monitor",
-    "monitor.observer_alive",
-    "monitor.present",
-    "monitor.scheduled",
-    "revision",
-    "settings",
-    "settings.autotag_character_threshold",
-    "settings.autotag_existing",
-    "settings.autotag_general_threshold",
-    "settings.autotag_model_type",
-    "settings.autotag_suggestion_limit",
-    "settings.autotag_template",
-    "settings.cpu_count",
-    "settings.gallery_root_path",
-    "settings.gallery_root_paths",
-    "settings.infinite_scroll",
-    "settings.monitored_directories",
-    "settings.monitoring_enabled",
-    "settings.result_timeout",
-    "settings.safety_backup",
-    "settings.thumbnail_edge",
-    "settings.thumbnail_format",
-    "settings.thumbnail_quality",
-    "settings.webui_display_mode",
-    "settings.worker_threads",
-    "sources",
-    "sources.auto_detected",
-    "sources.configured",
-    "sources.effective",
-    "success",
-    "thumbnail_encoders",
-    "thumbnail_encoders.jpeg",
-    "thumbnail_encoders.jxl",
-    "thumbnail_encoders.webp"
-  ]
-}

tests/js/workspace-images-multiselect.test.js

@@ -1,110 +0,0 @@
-const test = require('node:test');
-const assert = require('node:assert/strict');
-const source = import('../../web/js/workspace/images-multiselect.mjs');
-
-const KEYS = Object.freeze(['0:a', '0:b', '0:c', '0:d', '1:e']);
-
-test('a range runs from the anchor to the target in display order, either way', async () => {
-    const { rangeKeys } = await source;
-    assert.deepEqual(rangeKeys(KEYS, '0:b', '0:d'), ['0:b', '0:c', '0:d']);
-    assert.deepEqual(rangeKeys(KEYS, '1:e', '0:c'), ['0:c', '0:d', '1:e']);
-    assert.deepEqual(rangeKeys(KEYS, '0:c', '0:c'), ['0:c']);
-});
-
-test('a range without a listed anchor is the target alone, and an unlisted target is empty', async () => {
-    const { rangeKeys } = await source;
-    assert.deepEqual(rangeKeys(KEYS, null, '0:c'), ['0:c']);
-    assert.deepEqual(rangeKeys(KEYS, '9:gone', '0:c'), ['0:c']);
-    assert.deepEqual(rangeKeys(KEYS, '0:a', '9:gone'), []);
-});
-
-test('applying keys adds or removes them and keeps the same frozen set when nothing changes', async () => {
-    const { applyKeys } = await source;
-    const start = Object.freeze(new Set(['0:a']));
-    const added = applyKeys(start, ['0:b', '0:c'], true);
-    assert.deepEqual([...added], ['0:a', '0:b', '0:c']);
-    assert.ok(Object.isFrozen(added));
-    assert.deepEqual([...start], ['0:a']);
-    const removed = applyKeys(added, ['0:a', '0:b'], false);
-    assert.deepEqual([...removed], ['0:c']);
-    assert.equal(applyKeys(removed, ['0:c'], true), removed);
-    assert.equal(applyKeys(removed, ['0:a'], false), removed);
-});
-
-test('every listed key is checked only when each one is in the set', async () => {
-    const { everyChecked } = await source;
-    assert.equal(everyChecked(new Set(KEYS), KEYS), true);
-    assert.equal(everyChecked(new Set(KEYS.slice(1)), KEYS), false);
-    assert.equal(everyChecked(new Set(['x', ...KEYS.slice(1)]), KEYS), false);
-    assert.equal(everyChecked(new Set(), []), false);
-});
-
-test('the select-all-matching offer needs every loaded image checked and more to load', async () => {
-    const { offersAllMatching } = await source;
-    const all = new Set(KEYS);
-    assert.equal(offersAllMatching(all, KEYS, { total: 9, hasMore: true }), true);
-    assert.equal(offersAllMatching(all, KEYS, { total: 5, hasMore: false }), false);
-    assert.equal(offersAllMatching(new Set(KEYS.slice(1)), KEYS, { total: 9, hasMore: true }), false);
-    assert.equal(offersAllMatching(new Set(), [], { total: 9, hasMore: true }), false);
-});
-
-test('the counts read "N selected" and "All N matching selected", grouped', async () => {
-    const { matchingLabel, matchingOffer } = await source;
-    assert.equal(matchingLabel(12345), 'All 12,345 matching selected');
-    assert.equal(matchingOffer(12345), 'Select all 12,345 matching');
-});
-
-function fakeTimers() {
-    const timers = new Map();
-    let next = 1;
-    return {
-        set: (callback, delay) => { timers.set(next, { callback, delay }); return next++; },
-        clear: id => timers.delete(id),
-        fire: () => { for (const [id, { callback }] of [...timers]) { timers.delete(id); callback(); } },
-        pending: () => timers.size,
-        delays: () => [...timers.values()].map(timer => timer.delay),
-    };
-}
-
-test('a held press fires once after the delay and swallows the click that follows', async () => {
-    const { createLongPress, LONG_PRESS_MS } = await source;
-    const timers = fakeTimers(), fired = [];
-    const press = createLongPress({ onLongPress: target => fired.push(target), setTimer: timers.set, clearTimer: timers.clear });
-    press.down(10, 10, 'card-a');
-    assert.deepEqual(timers.delays(), [LONG_PRESS_MS]);
-    assert.equal(LONG_PRESS_MS, 500);
-    press.move(14, 13);
-    timers.fire();
-    assert.deepEqual(fired, ['card-a']);
-    press.up();
-    assert.equal(press.consumeClick(), true);
-    assert.equal(press.consumeClick(), false);
-});
-
-test('moving past the slop, lifting early or cancelling never fires', async () => {
-    const { createLongPress, LONG_PRESS_SLOP } = await source;
-    assert.equal(LONG_PRESS_SLOP, 10);
-    const timers = fakeTimers(), fired = [];
-    const press = createLongPress({ onLongPress: target => fired.push(target), setTimer: timers.set, clearTimer: timers.clear });
-    press.down(0, 0, 'a'); press.move(0, 11);
-    assert.equal(timers.pending(), 0);
-    press.down(0, 0, 'b'); press.up();
-    assert.equal(timers.pending(), 0);
-    press.down(0, 0, 'c');
-    assert.equal(press.pending(), true);
-    press.cancel();
-    assert.equal(press.pending(), false);
-    assert.equal(timers.pending(), 0);
-    press.move(0, 0); press.up(); press.cancel();
-    assert.deepEqual(fired, []);
-    assert.equal(press.consumeClick(), false);
-    // A new press drops a long press whose click never came.
-    press.down(0, 0, 'd'); timers.fire();
-    press.down(0, 0, 'e');
-    assert.equal(press.consumeClick(), false);
-    timers.fire();
-    assert.deepEqual(fired, ['d', 'e']);
-    // A cancel (a mouse press on a hybrid device) forgets a fired press whose click never came.
-    press.cancel();
-    assert.equal(press.consumeClick(), false);
-});

tests/js/workspace-images-state.test.js

@@ -494,11 +494,3 @@ test('defaults apply to a new visit but not to the current view or a saved view'
     assert.deepEqual(initialImagesView({}), { layout: 'grid', density: 'comfortable' });
     assert.deepEqual(initialImagesView({ preferences: {} }), { layout: 'grid', density: 'comfortable' });
 });
-
-test('listingFilter is the listing query as an object, without paging (#392)', async () => {
-    const { listingFilter } = await source;
-    assert.deepEqual(listingFilter({q:'cat', root:'1', subfolder:'a/b', category:'Animals', tags:[' x ','y'], media:'video', sort:'oldest', favorites:true}),
-        {q:'cat', root:'1', subfolder:'a/b', category:'Animals', tags:'x,y', media:'video', sort:'oldest', favorites:'1'});
-    assert.deepEqual(listingFilter({root:'all', q:'', tags:[], media:'all'}), {sort:'newest'});
-    assert.throws(() => listingFilter({sort:'sideways'}), TypeError);
-});

tests/js/workspace-images-tagging-bulk.test.js

@@ -196,29 +196,3 @@ test('a preset starts the Tag image dialog on the chosen model and options', asy
     assert.throws(() => createImageTaggingController({ api, target, preset: { model: 'gguf', options: { instructions: '' } } }), TypeError);
     assert.throws(() => createImageTaggingController({ api, target, preset: { model: 'gguf', options: { nope: 1 } } }), TypeError);
 });
-
-test('all matching sends the listing filter instead of targets, up to 10,000 images (#392)', async () => {
-    const { openAddTags, openAutoTag, MAX_FILTER_IMAGES, TOO_MANY_MATCHING } = module();
-    assert.equal(MAX_FILTER_IMAGES, 10000);
-    assert.equal(TOO_MANY_MATCHING, 'Narrow the view to at most 10,000 images.');
-    const toasts = [], posted = [], tagged = [];
-    let ended = null;
-    const store = { start: async (kind, body) => { posted.push([kind, body]); return { job: { id: JOB_ID, state: 'running' } }; },
-        find: () => ended, subscribe: () => () => {} };
-    const filter = { q: 'cat', sort: 'newest' };
-    // The loaded images can be more than 500: the filter, not the identities, is sent.
-    const loaded = Array.from({ length: 600 }, (_, index) => image(`bulk/${index}.png`));
-    let dialog = null;
-    openAddTags({ scope: pageScope(), store, images: loaded, filter, count: 1234, notify: text => toasts.push(text),
-        onTagged: keys => tagged.push(keys.size), openInput: args => { dialog = args; } });
-    assert.ok(dialog, 'the Add tags dialog opens');
-    ended = { id: JOB_ID, state: 'finished', counters: { tagged: 3 } };
-    await dialog.onApply('sunset');
-    assert.deepEqual(posted, [['image-tags', { mode: 'add', filter, tags: ['sunset'] }]]);
-    // The loaded files are read again when the job tagged any.
-    assert.deepEqual(tagged, [600]);
-    openAddTags({ scope: pageScope(), store, images: loaded, filter, count: 10001, notify: text => toasts.push(text),
-        openInput: () => assert.fail('no dialog over the cap') });
-    openAutoTag({ api: {}, scope: pageScope(), store, images: loaded, filter, count: 10001, notify: text => toasts.push(text) });
-    assert.deepEqual(toasts, [TOO_MANY_MATCHING, TOO_MANY_MATCHING]);
-});

tests/test_annotations.py

@@ -430,9 +430,7 @@ class ReplaceImageTagsTests(AnnotationTestCase):
             self.assertTrue(
                 self.db.refresh_image_fingerprint(loc, DIGEST_A, SIZE, MTIME + 1)
             )
-            self.assertEqual(
-                self.db.image_tag_locators(self.db.image_tag_ids(["img"], "")), {loc}
-            )
+            list(self.db.iter_image_tag_records())
         self.assertEqual(self.db.get_prompt_by_id(prompt)["tags"], ["prompt-tag"])
 
 
@@ -553,26 +551,14 @@ class CurrentImageTagsTests(AnnotationTestCase):
         self.assertEqual(current, {locators[0]: ["z", "y"], locators[502]: ["x"]})
         lookups = [s for s in statements if "media_annotation_files" in s]
         self.assertEqual(len(lookups), 2)
-        # The tag search finds every record's file by tag id, and the empty
-        # set's file never.
         self.assertEqual(
-            self.db.image_tag_locators(self.db.image_tag_ids(["z", "x"], "")),
-            {locators[0], locators[502]},
+            list(self.db.iter_image_tag_records()),
+            [
+                (locators[0], SIZE, MTIME, ["z", "y"]),
+                (locators[250], SIZE, MTIME + 1, []),
+                (locators[502], SIZE, MTIME + 2, ["x"]),
+            ],
         )
-        self.assertEqual(
-            self.db.current_image_tags({locators[250]: (SIZE, MTIME + 1)}),
-            {locators[250]: []},
-        )
-
-    def test_tag_locators_cover_more_ids_than_one_chunk(self):
-        # A broad text search can match more than 500 names: every id's file
-        # comes back across the chunks.
-        locators = [self.locator(f"t{i:04}.png") for i in range(503)]
-        for i, loc in enumerate(locators):
-            self.replace(loc, tags=[f"name_{i:04}"])
-        ids = self.db.image_tag_ids([], "name_")
-        self.assertEqual(len(ids), 503)
-        self.assertEqual(self.db.image_tag_locators(ids), set(locators))
 
 
 class AutotagMarkTests(AnnotationTestCase):

tests/test_api_admin.py

@@ -846,14 +846,6 @@ class TestSettingsReadMonitorThroughModule(AdminAPITestCase):
         self.assertEqual(data["settings"]["gallery_root_paths"], ["output"])
 
 
-def _wired_prompt(text):
-    """A sampler-less graph whose one encoder feeds a guider (#252)."""
-    return {
-        "1": {"class_type": "CLIPTextEncode", "inputs": {"text": text}},
-        "2": {"class_type": "BasicGuider", "inputs": {"conditioning": ["1", 0]}},
-    }
-
-
 def _raise(*args, **kwargs):
     raise RuntimeError("boom")
 
@@ -2194,7 +2186,11 @@ class TestOutputScanInternals(AdminAPITestCase):
 
     def test_ingest_outcomes(self):
         f = Path("gen.png")
-        meta = {"prompt": json.dumps(_wired_prompt("a cat"))}
+        meta = {
+            "prompt": json.dumps(
+                {"1": {"class_type": "CLIPTextEncode", "inputs": {"text": "a cat"}}}
+            )
+        }
         self.assertIsNone(self.api._ingest_scanned_file(f, {}))
         self.assertIsNone(self.api._ingest_scanned_file(f, {"prompt": "{}"}))
         self.assertEqual(
@@ -2206,19 +2202,31 @@ class TestOutputScanInternals(AdminAPITestCase):
 
     def test_ingest_link_failures_are_tolerated(self):
         f = Path("gen.png")
-        meta = {"prompt": json.dumps(_wired_prompt("a dog"))}
+        meta = {
+            "prompt": json.dumps(
+                {"1": {"class_type": "CLIPTextEncode", "inputs": {"text": "a dog"}}}
+            )
+        }
         self.api.db.link_image_to_prompt = _raise
         self.assertEqual(self.api._ingest_scanned_file(f, meta), "added")
         self.assertEqual(self.api._ingest_scanned_file(f, meta), "found")
 
     def test_ingest_save_failure_counts_as_found(self):
         f = Path("gen.png")
-        meta = {"prompt": json.dumps(_wired_prompt("a bird"))}
+        meta = {
+            "prompt": json.dumps(
+                {"1": {"class_type": "CLIPTextEncode", "inputs": {"text": "a bird"}}}
+            )
+        }
         self.api.db.save_prompt = lambda *a, **k: None
         self.assertEqual(self.api._ingest_scanned_file(f, meta), "found")
 
     def test_batch_counts_and_per_file_errors(self):
-        meta = {"prompt": json.dumps(_wired_prompt("a fish"))}
+        meta = {
+            "prompt": json.dumps(
+                {"1": {"class_type": "CLIPTextEncode", "inputs": {"text": "a fish"}}}
+            )
+        }
         self.api.db.get_prompt_by_hash = _raise
         counts = self.api._ingest_scan_batch_sync(
             [(Path("a.png"), meta), (Path("b.png"), {})]
@@ -2907,7 +2915,7 @@ class TestScanReadsVideos(AdminAPITestCase):
         shutil.which("ffmpeg") and shutil.which("ffprobe"), "ffmpeg not installed"
     )
     async def test_scan_adds_prompts_found_in_videos(self):
-        graph = _wired_prompt("a cat")
+        graph = {"1": {"class_type": "CLIPTextEncode", "inputs": {"text": "a cat"}}}
         _write_mp4(
             self.output_dir / "clip.mp4", json.dumps({"prompt": json.dumps(graph)})
         )

tests/test_api_core.py

@@ -835,6 +835,7 @@ class TestMetadataParsing(unittest.TestCase):
         self.assertEqual(parsed["positive_prompt"], "a cat")
         self.assertEqual(parsed["negative_prompt"], "dog")
         self.assertEqual(parsed["parameters"]["parameters"], meta["parameters"])
+        self.assertEqual(self.api._extract_readable_prompt(parsed), "a cat")
 
     def test_parse_comfyui_fields(self):
         meta = {
@@ -855,6 +856,97 @@ class TestMetadataParsing(unittest.TestCase):
         self.assertEqual(parsed["prompt"], "plain text")
         self.assertEqual(parsed["workflow"], {"nodes": []})
 
+    def test_extract_readable_prompt_variants(self):
+        extract = self.api._extract_readable_prompt
+        self.assertEqual(extract({"prompt": "plain"}), "plain")
+        self.assertEqual(extract({"prompt": ["a", "", "b"]}), "a b")
+        self.assertEqual(extract({"prompt": 42}), "42")
+        self.assertEqual(
+            extract({"prompt": None, "parameters": {"positive": ["x", "y"]}}), "x y"
+        )
+        self.assertIsNone(extract({"prompt": {}, "parameters": {}}))
+
+        graph = {
+            "1": {"class_type": "CLIPTextEncode", "inputs": {"text": "pos"}},
+            "2": {"class_type": "CLIPTextEncode", "inputs": {"text": "neg"}},
+            "3": {
+                "class_type": "KSampler",
+                "inputs": {"positive": ["1", 0], "negative": ["2", 0]},
+            },
+        }
+        self.assertEqual(extract({"prompt": graph}), "pos")
+        self.assertEqual(extract({"prompt": {"x": 1}, "workflow": graph}), "pos")
+
+    def test_node_inputs_and_text_lookup(self):
+        self.assertEqual(self.api._get_node_inputs("nope"), {})
+        self.assertEqual(self.api._get_node_inputs({"inputs": 5}), {})
+        self.assertEqual(self.api._get_node_inputs({"inputs": {"a": 1}}), {"a": 1})
+        listed = self.api._get_node_inputs(
+            {"inputs": [{"name": "text", "link": None}, {"nope": 1}, "junk"]}
+        )
+        self.assertEqual(list(listed), ["text"])
+
+        self.assertIsNone(self.api._find_text_in_node(None))
+        self.assertEqual(self.api._find_text_in_node({"inputs": {"text": "hi"}}), "hi")
+        self.assertEqual(
+            self.api._find_text_in_node(
+                {"type": "CLIPTextEncode", "widgets_values": ["w"]}
+            ),
+            "w",
+        )
+        self.assertIsNone(
+            self.api._find_text_in_node(
+                {"type": "CLIPTextEncode", "widgets_values": [" "]}
+            )
+        )
+        self.assertIsNone(self.api._find_text_in_node({"type": "KSampler"}))
+
+    def test_positive_prompt_from_nodes_array_and_fallbacks(self):
+        extract = self.api._extract_positive_prompt_from_comfyui_data
+        self.assertIsNone(extract("x"))
+        self.assertIsNone(extract({}))
+        self.assertIsNone(extract({"nodes": []}))
+
+        workflow = {
+            "nodes": [
+                {"id": 1, "type": "CLIPTextEncode", "widgets_values": ["pos"]},
+                {
+                    "id": 2,
+                    "type": "CLIPTextEncode",
+                    "widgets_values": ["neg"],
+                    "title": "Negative",
+                },
+                {"id": 3, "type": "KSampler", "inputs": [{"name": "seed", "link": 4}]},
+                "junk",
+            ]
+        }
+        self.assertEqual(extract(workflow), "pos")
+
+        only_negative = {
+            "nodes": [
+                {
+                    "id": 2,
+                    "type": "CLIPTextEncode",
+                    "widgets_values": ["neg"],
+                    "title": "neg",
+                },
+            ]
+        }
+        self.assertEqual(extract(only_negative), "neg")
+
+        bad_link = {
+            "1": {"class_type": "CLIPTextEncode", "inputs": {"text": "pos"}},
+            "3": {
+                "class_type": "KSampler",
+                "inputs": {"positive": "oops", "negative": []},
+            },
+            "4": {
+                "class_type": "KSampler",
+                "inputs": {"positive": ["zz", 0], "negative": []},
+            },
+        }
+        self.assertEqual(extract(bad_link), "pos")
+
 
 if __name__ == "__main__":
     unittest.main()

tests/test_api_workspace_images.py

@@ -1831,39 +1831,6 @@ class TestWorkspaceCursorEncoding(unittest.TestCase):
                 self.assertEqual(_workspace_cursor_key(token, "scope", order), key)
 
 
-# The pre-#379 candidate read, kept as the differential reference for the
-# indexed lookup (`image_tag_ids` + `image_tag_locators`): every byte record
-# streamed with its tag names, a locator kept when any record's names are
-# relevant (`_image_tags_relevant`).
-_REFERENCE_RECORDS = (
-    "SELECT f.locator,b.id,t.name FROM media_annotation_files f "
-    "JOIN media_annotation_bytes b ON b.file_id=f.id "
-    "LEFT JOIN media_image_tags mit ON mit.byte_id=b.id "
-    "LEFT JOIN tags t ON t.id=mit.tag_id "
-    "ORDER BY f.locator,b.first_seen_at,b.id,mit.position"
-)
-
-
-def _image_tags_relevant(names, wanted, query):
-    if wanted and not wanted.isdisjoint(names):
-        return True
-    return bool(query) and any(query in name.casefold() for name in names)
-
-
-def reference_candidates(db, wanted, query):
-    """Locators the old full stream admitted for (``wanted``, ``query``)."""
-    records = {}
-    for locator, byte_id, name in db.model.get_connection().execute(_REFERENCE_RECORDS):
-        names = records.setdefault((locator, byte_id), [])
-        if name is not None:
-            names.append(name)
-    return {
-        locator
-        for (locator, _byte), names in records.items()
-        if _image_tags_relevant(names, set(wanted), query)
-    }
-
-
 class TestWorkspaceImageTags(ImageAPITestCase):
     """B3: image tags in the Tags filter and search (spec amendment S1)."""
 
@@ -2071,7 +2038,7 @@ class TestWorkspaceImageTags(ImageAPITestCase):
         leak = "no such table: media_annotation_files"
         with patch.object(
             self.api.db,
-            "image_tag_locators",
+            "iter_image_tag_records",
             side_effect=sqlite3.OperationalError(leak),
         ):
             # As a failed link read does under a Tags filter: a fixed coded
@@ -2089,140 +2056,6 @@ class TestWorkspaceImageTags(ImageAPITestCase):
         self.assertEqual(self.names(body), ["dunes_by_name.png"])
         self.assertIn("image tags", "\n".join(logged.output))
 
-    def seed_differential(self):
-        """Mixed-case and underscore names, a stale record, an unlisted file."""
-        a = self.media("a.png", mtime=101)
-        b = self.media("b.png", mtime=102)
-        c = self.media("c.png", mtime=103)
-        self.tag(a, ["Beach", "long_hair", "1girl"])
-        self.tag(b, ["beach", "waves"])
-        self.tag(c, ["Sunset"])
-        # c's bytes change: its old record (Sunset) is stale, the new one current.
-        make_png(c, size=(5, 5))
-        os.utime(c, (104, 104))
-        self.tag(c, ["night_sky", "BEACH"])
-        outside = Path(self._output_tmp.name) / "elsewhere" / "x.png"
-        outside.parent.mkdir(parents=True, exist_ok=True)
-        make_png(outside)
-        self.tag(outside, ["beach", "outside_only"])
-
-    async def test_indexed_candidates_equal_the_full_stream(self):
-        self.seed_differential()
-        cases = [
-            (["beach"], ""),
-            (["Beach"], ""),
-            (["long_hair", "waves"], ""),
-            ([], "beach"),
-            ([], "hair"),
-            ([], "_"),
-            ([], "sun"),
-            (["nope"], "zzz"),
-            (["outside_only"], ""),
-            (["beach"], "night"),
-        ]
-        db = self.api.db
-        for wanted, query in cases:
-            with self.subTest(wanted=wanted, query=query):
-                indexed = set(db.image_tag_locators(db.image_tag_ids(wanted, query)))
-                self.assertEqual(indexed, reference_candidates(db, wanted, query))
-        # The API answers are the indexed lookup's: exact names under Tags, a
-        # case-folded substring under q, current records only.
-        _, body = await self.get(tags="beach")
-        self.assertEqual(sorted(self.names(body)), ["b.png"])
-        _, body = await self.get(q="beach")
-        self.assertEqual(sorted(self.names(body)), ["a.png", "b.png", "c.png"])
-        _, body = await self.get(q="sunset")
-        self.assertEqual(self.names(body), [])
-
-    async def test_tag_search_reads_image_tags_only_by_tag_id(self):
-        self.seed_differential()
-        statements = []
-        original = self.api.db.model.get_connection
-
-        def trace_connection():
-            connection = original()
-            connection.set_trace_callback(statements.append)
-            return connection
-
-        with patch.object(
-            self.api.db.model, "get_connection", side_effect=trace_connection
-        ):
-            for params in ({"tags": "beach"}, {"q": "hair"}):
-                response, _ = await self.get(**params)
-                self.assertEqual(response.status, 200)
-        reads = [
-            sql
-            for sql in statements
-            if "media_image_tags" in sql and sql.lstrip().upper().startswith("SELECT")
-        ]
-        self.assertTrue(reads)
-        for sql in reads:
-            # Only a tag-id lookup, an EXISTS probe on the tag index, or the
-            # current records' own tags (byte_id IN) read the junction.
-            self.assertTrue(
-                "tag_id IN" in sql or "EXISTS" in sql or "byte_id IN" in sql, sql
-            )
-
-    async def test_the_image_tag_lookup_never_reads_prompt_tags(self):
-        self.seed_differential()
-        linked = self.media("linked.png", mtime=105)
-        prompt = self._save_prompt(
-            "Prompt with its own tag", tags=["prompt_only_beach"]
-        )
-        self.api.db.link_image_to_prompt(prompt, str(linked))
-        db = self.api.db
-        # The tag is only on a prompt: the image-tag lookup never yields it,
-        # under the Tags filter or the text search.
-        self.assertEqual(db.image_tag_ids(["prompt_only_beach"], ""), [])
-        self.assertEqual(db.image_tag_ids([], "prompt_only"), [])
-        self.assertEqual(
-            db.image_tag_locators(db.image_tag_ids([], "beach")),
-            reference_candidates(db, [], "beach"),
-        )
-        # The search still matches through the linked positive's prompt tags
-        # (the design keeps that, #379 "Behavior that does not change").
-        _, body = await self.get(q="prompt_only")
-        self.assertEqual(self.names(body), ["linked.png"])
-
-    @unittest.skipUnless(os.environ.get("PM_PERF") == "1", "timing run (PM_PERF=1)")
-    async def test_tag_search_timing(self):
-        """Linux timing for the PR body: 23,600 records, 10 tags each."""
-        import hashlib
-        import statistics
-        import time
-
-        db = self.api.db
-        epoch = db.get_execution_epoch()
-        names = [f"name_{n:04d}" for n in range(2000)]
-        root = os.path.realpath(self.output_dir)
-        for n in range(23_600):
-            path = self.output_dir / "perf" / f"{n:05d}.png"
-            path.parent.mkdir(exist_ok=True)
-            path.write_bytes(b"x")
-            os.utime(path, (n + 1, n + 1))
-            stat = path.stat()
-            db.replace_image_tags(
-                locator=os.path.normcase(os.path.join(root, "perf", path.name)),
-                sha256=hashlib.sha256(str(n).encode()).hexdigest(),
-                size=stat.st_size,
-                mtime_ns=stat.st_mtime_ns,
-                expected_epoch=epoch,
-                expected_tag_revision=0,
-                tags=[names[(n * 7 + k) % 2000] for k in range(10)],
-            )
-        await self.get(limit=1)  # the listing, warm
-        for label, params in (
-            ("one tag", {"tags": "name_0042"}),
-            ("text", {"q": "e_1"}),
-        ):
-            times = []
-            for _ in range(5):
-                started = time.perf_counter()
-                response, _ = await self.get(limit=100, **params)
-                times.append(time.perf_counter() - started)
-                self.assertEqual(response.status, 200)
-            print(f"PM_PERF {label}: median {statistics.median(times) * 1000:.0f} ms")
-
     async def test_legacy_output_failure_logs_its_traceback(self):
         self.media("legacy.png", mtime=100)
         with (
@@ -2335,162 +2168,3 @@ class TestWorkspaceImageTags(ImageAPITestCase):
                 )
             ]
         self.assertFalse([step for step in plan if step.startswith("SCAN")], plan)
-
-
-class TestListingFilterSelection(ImageAPITestCase):
-    """#392: "Select all N matching" resolves the listing filter on the server."""
-
-    async def tearDownAsync(self):
-        self.api.db.close_all()
-        await super().tearDownAsync()
-
-    def media(self, name, mtime=100):
-        target = self.output_dir / name
-        target.parent.mkdir(parents=True, exist_ok=True)
-        make_png(target)
-        os.utime(target, (mtime, mtime))
-        return target
-
-    async def listing(self, **params):
-        response = await self.client.get(
-            "/prompt_manager/images/output",
-            params={"mode": "workspace", "limit": 500, **params},
-        )
-        return (await response.json())["images"]
-
-    async def test_resolve_lists_every_match_in_listing_order_beyond_a_page(self):
-        for number in range(7):
-            self.media(f"bulk/{number:02}.png", 100 + number)
-        self.media("other/x.png", 500)
-        from py.api.images import parse_listing_filter
-
-        params = parse_listing_filter({"subfolder": "bulk", "sort": "newest"})
-        resolved = await self.api.resolve_listing_filter(params, cap=100)
-
-        listed = await self.listing(subfolder="bulk", sort="newest")
-        self.assertEqual(
-            [list(target) for target in resolved.targets],
-            [[i["root_index"], i["root_scope"], i["path"]] for i in listed],
-        )
-        self.assertEqual(len(resolved.targets), 7)
-        self.assertFalse(resolved.truncated)
-
-    async def test_resolve_reports_linked_positives_and_unlinked_count(self):
-        first = self.media("a.png", 300)
-        second = self.media("b.png", 200)
-        self.media("c.png", 100)
-        prompt = self._save_prompt("shared positive")
-        self.api.db.link_image_to_prompt(prompt, str(first))
-        self.api.db.link_image_to_prompt(prompt, str(second))
-        from py.api.images import parse_listing_filter
-
-        resolved = await self.api.resolve_listing_filter(parse_listing_filter({}), 100)
-
-        self.assertEqual(resolved.positive_ids, [prompt])
-        self.assertEqual(resolved.unlinked, 1)
-
-    async def test_resolve_marks_more_than_the_cap_as_truncated(self):
-        for number in range(4):
-            self.media(f"{number}.png", 100 + number)
-        from py.api.images import parse_listing_filter
-
-        resolved = await self.api.resolve_listing_filter(parse_listing_filter({}), 3)
-
-        self.assertTrue(resolved.truncated)
-
-    def test_parse_listing_filter_rejects_anything_but_listing_strings(self):
-        from py.api.images import parse_listing_filter
-
-        self.assertEqual(
-            parse_listing_filter({"q": "cat", "tags": "a,b", "root": "0"}),
-            {"q": "cat", "tags": "a,b", "root": "0"},
-        )
-        for bad in (
-            None,
-            [],
-            "q=cat",
-            {"mode": "workspace"},
-            {"cursor": "x"},
-            {"path": "a.png"},
-            {"q": 1},
-            {"q": "x" * 2049},
-            {"sort": "sideways"},
-            {"media": "audio"},
-            {"favorites": "yes"},
-            {"subfolder": "../up"},
-            {"root": "-1"},
-        ):
-            with self.subTest(bad=bad):
-                with self.assertRaises(ValueError):
-                    params = parse_listing_filter(bad)
-                    # Root bounds need the roots: the resolver checks them.
-                    from py.api.images import _workspace_root
-
-                    _workspace_root(params, [self.output_dir])
-
-    async def test_bulk_category_takes_the_listing_filter(self):
-        first = self.media("keep/a.png", 300)
-        second = self.media("keep/b.png", 200)
-        self.media("keep/c.png", 100)
-        other = self.media("skip/d.png", 400)
-        prompt = self._save_prompt("in the filter")
-        outside = self._save_prompt("outside the filter")
-        self.api.db.link_image_to_prompt(prompt, str(first))
-        self.api.db.link_image_to_prompt(prompt, str(second))
-        self.api.db.link_image_to_prompt(outside, str(other))
-
-        response = await self.client.post(
-            "/prompt_manager/bulk/category",
-            json={"images_filter": {"subfolder": "keep"}, "category": "Kept"},
-        )
-        data = await response.json()
-
-        self.assertEqual(response.status, 200, data)
-        self.assertEqual(
-            (data["updated_count"], data["prompt_count"], data["skipped"]), (1, 1, 1)
-        )
-        self.assertEqual(self.api.db.get_prompt_by_id(prompt)["category"], "Kept")
-        self.assertNotEqual(self.api.db.get_prompt_by_id(outside)["category"], "Kept")
-
-    async def test_bulk_category_filter_with_no_linked_image_changes_nothing(self):
-        self.media("a.png")
-
-        response = await self.client.post(
-            "/prompt_manager/bulk/category",
-            json={"images_filter": {}, "category": "Kept"},
-        )
-        data = await response.json()
-
-        self.assertEqual(response.status, 200, data)
-        self.assertEqual(
-            (data["updated_count"], data["prompt_count"], data["skipped"]), (0, 0, 1)
-        )
-
-    async def test_bulk_category_refuses_a_bad_or_doubled_filter(self):
-        self.media("a.png")
-        prompt = self._save_prompt("p")
-        for body in (
-            {"images_filter": {"sort": "sideways"}, "category": "x"},
-            {"images_filter": "all", "category": "x"},
-            {"images_filter": {}, "prompt_ids": [prompt], "category": "x"},
-            {"images_filter": {"root": "9"}, "category": "x"},
-        ):
-            with self.subTest(body=body):
-                response = await self.client.post(
-                    "/prompt_manager/bulk/category", json=body
-                )
-                self.assertEqual(response.status, 400, await response.text())
-
-    async def test_bulk_category_refuses_a_renumbered_source(self):
-        self.media("a.png")
-
-        response = await self.client.post(
-            "/prompt_manager/bulk/category",
-            json={
-                "images_filter": {"root": "0", "root_scope": "f" * 64},
-                "category": "x",
-            },
-        )
-
-        self.assertEqual(response.status, 409)
-        self.assertEqual((await response.json())["code"], "source-changed")

tests/test_image_tag_jobs.py

@@ -11,7 +11,6 @@ engine is B2's fake service.
 import asyncio
 import hashlib
 import json
-import os
 import sqlite3
 import threading
 import unittest
@@ -829,108 +828,3 @@ class TestFixRound(ImageTagJobTestCase):
 
 if __name__ == "__main__":
     unittest.main()
-
-
-class TestFilterStart(ImageTagJobTestCase):
-    """#392: "Select all N matching" starts the job with the listing filter."""
-
-    async def test_filter_start_tags_every_matching_file_in_listing_order(self):
-        for number in range(6):
-            path = self.png(f"bulk/{number:02}.png", color=(number, 1, 1))
-            os.utime(path, (100 + number, 100 + number))
-        self.png("other/x.png")
-
-        job = await self.run_job(
-            {
-                "mode": "add",
-                "filter": {"subfolder": "bulk", "sort": "oldest"},
-                "tags": ["picked"],
-            }
-        )
-
-        self.assertEqual(job.scope, {"mode": "add", "images": 6})
-        self.assertEqual(job.counters["tagged"], 6)
-        self.assertEqual(
-            [path for path, _detail in self.rows(job, "tagged")],
-            [f"bulk/{number:02}.png" for number in range(6)],
-        )
-        self.assertEqual(self.stored("bulk/03.png")["tags"], ["picked"])
-        self.assertEqual(self.stored("other/x.png")["tags"], [])
-
-    async def test_auto_filter_start_runs_the_model_on_the_matching_files(self):
-        self.png("bulk/a.png")
-        self.png("other/b.png", color=(1, 2, 3))
-
-        job = await self.run_job(
-            {
-                "mode": "auto",
-                "filter": {"subfolder": "bulk"},
-                "model_type": "wd14-vit",
-                "options": dict(WD14),
-            }
-        )
-
-        self.assertEqual(job.scope["images"], 1)
-        self.assertEqual(job.counters["tagged"], 1)
-        self.assertEqual(self.stored("other/b.png")["tags"], [])
-
-    async def test_filter_with_no_match_is_refused_without_a_job(self):
-        self.png("a.png")
-
-        status, data = await self.start(
-            {"mode": "add", "filter": {"subfolder": "missing"}, "tags": ["x"]}
-        )
-
-        self.assertEqual((status, data["code"]), (400, "no-images"))
-        self.assertEqual(self.api._jobs.list(), [])
-
-    async def test_filter_over_the_cap_is_refused_without_a_job(self):
-        from py.api import image_tag_jobs
-
-        for number in range(3):
-            self.png(f"{number}.png", color=(number, 0, 0))
-        with patch.object(image_tag_jobs, "MAX_FILTER_TARGETS", 2):
-            status, data = await self.start(
-                {"mode": "add", "filter": {}, "tags": ["x"]}
-            )
-
-        self.assertEqual((status, data["code"]), (400, "too-many-images"))
-        self.assertEqual(self.api._jobs.list(), [])
-        self.assertEqual(image_tag_jobs.MAX_FILTER_TARGETS, 10_000)
-
-    async def test_filter_bodies_are_validated(self):
-        self.png("a.png")
-        target = self.target("a.png")
-        for body in (
-            {"mode": "add", "filter": {}, "targets": [target], "tags": ["x"]},
-            {"mode": "add", "filter": "all", "tags": ["x"]},
-            {"mode": "add", "filter": {"sort": "sideways"}, "tags": ["x"]},
-            {"mode": "add", "filter": {"cursor": "x"}, "tags": ["x"]},
-            {"mode": "add", "filter": {"root": "7"}, "tags": ["x"]},
-            {"mode": "add", "filter": {}, "tags": []},
-        ):
-            with self.subTest(body=body):
-                status, data = await self.start(body)
-                self.assertEqual(status, 400, data)
-        self.assertEqual(self.api._jobs.list(), [])
-
-    async def test_a_filter_whose_source_was_renumbered_is_refused(self):
-        self.png("a.png")
-        scope = self.target("a.png")["root_scope"]
-
-        job = await self.run_job(
-            {"mode": "add", "filter": {"root": "0", "root_scope": scope}, "tags": ["x"]}
-        )
-        self.assertEqual(job.counters["tagged"], 1)
-        status, data = await self.start(
-            {
-                "mode": "add",
-                "filter": {"root": "0", "root_scope": "f" * 64},
-                "tags": ["x"],
-            }
-        )
-        self.assertEqual((status, data["code"]), (409, "source-changed"))
-        status, data = await self.start(
-            {"mode": "add", "filter": {"root_scope": scope}, "tags": ["x"]}
-        )
-        self.assertEqual(status, 400, data)

tests/test_legacy_contract_snapshot.py

@@ -1,136 +0,0 @@
-"""The legacy pages' backend contract does not move under System S13 (#330).
-
-S13 points the legacy admin and gallery buttons at native System and removes
-their duplicate dialogs, changing no backend file. This snapshot pins what the
-legacy pages talk to: every registered route (method and path) and the key
-paths of ``GET /prompt_manager/settings``, the one route whose legacy request
-body S13 shrinks. Record again only with a reason in the PR body:
-
-    PM_RECORD_LEGACY_SNAPSHOT=1 python3 -m unittest tests.test_legacy_contract_snapshot
-
-Cutover (#334) removes this test and its fixture.
-"""
-
-import json
-import os
-import unittest
-from pathlib import Path
-
-try:
-    from tests.test_api_admin import AdminAPITestCase
-except ImportError:  # discovered with tests/ as the top-level directory
-    from test_api_admin import AdminAPITestCase
-
-from py.config import GalleryConfig  # noqa: E402
-
-SNAPSHOT = (
-    Path(__file__).resolve().parent / "fixtures" / "legacy_contract_snapshot.json"
-)
-RECORD_ENV = "PM_RECORD_LEGACY_SNAPSHOT"
-SETTINGS = "/prompt_manager/settings"
-DEPTH = 2
-CHANGED = (
-    "the legacy contract changed; if the change is intended (a new route, a new"
-    " settings key), record it with PM_RECORD_LEGACY_SNAPSHOT=1 and say why in"
-    " the PR body"
-)
-
-
-def key_paths(value, prefix="", depth=1):
-    """The key paths of a JSON object to ``DEPTH`` levels.
-
-    ``{"a": {"b": 1}}`` gives ``a`` and ``a.b``; the items of a list of
-    objects give the union of their keys as ``a[].b``.
-    """
-    paths = set()
-    for key, child in value.items():
-        path = f"{prefix}{key}"
-        paths.add(path)
-        if depth >= DEPTH:
-            continue
-        if isinstance(child, dict):
-            paths |= key_paths(child, f"{path}.", depth + 1)
-        elif isinstance(child, list):
-            for item in child:
-                if isinstance(item, dict):
-                    paths |= key_paths(item, f"{path}[].", depth + 1)
-    return paths
-
-
-class TestLegacyContractSnapshot(AdminAPITestCase):
-    """Routes and settings keys against tests/fixtures/legacy_contract_snapshot.json.
-
-    The base case isolates config.json (``PROMPT_MANAGER_CONFIG_PATH`` in the
-    temp tree), stubs ComfyUI's ``folder_paths`` and resets the gallery roots;
-    nothing here reads the maintainer's install.
-    """
-
-    async def asyncSetUp(self):
-        await super().asyncSetUp()
-        self.api._get_all_output_dirs = lambda: [str(self.output_dir)]
-        GalleryConfig.MONITORING_DIRECTORIES = [str(self.output_dir)]
-
-    def _routes(self):
-        return sorted(
-            {
-                f"{route.method} {route.resource.canonical}"
-                for route in self.app.router.routes()
-                if route.method != "HEAD"
-            }
-        )
-
-    async def _settings_keys(self):
-        resp = await self.client.request("GET", SETTINGS)
-        body = await resp.json()
-        self.assertEqual(resp.status, 200, body)
-        return sorted(key_paths(body))
-
-    def _snapshot(self):
-        with open(SNAPSHOT, encoding="utf-8") as f:
-            return json.load(f)
-
-    def _record(self, key, value):
-        recorded = self._snapshot() if SNAPSHOT.exists() else {}
-        recorded[key] = value
-        with open(SNAPSHOT, "w", encoding="utf-8", newline="\n") as f:
-            json.dump(recorded, f, indent=2)
-            f.write("\n")
-
-    async def test_routes_match_the_snapshot(self):
-        routes = self._routes()
-        if os.environ.get(RECORD_ENV) == "1":
-            self._record("routes", routes)
-        self.assertGreater(len(routes), 50)
-        self.assertEqual(routes, self._snapshot()["routes"], CHANGED)
-
-    async def test_settings_response_keeps_its_keys(self):
-        keys = await self._settings_keys()
-        if os.environ.get(RECORD_ENV) == "1":
-            self._record("settings_keys", keys)
-        self.assertIn("settings.infinite_scroll", keys)
-        self.assertEqual(keys, self._snapshot()["settings_keys"], CHANGED)
-
-
-class TestKeyPaths(unittest.TestCase):
-    def test_depth_and_list_items(self):
-        value = {
-            "success": True,
-            "settings": {"a": 1, "deep": {"hidden": 1}},
-            "rows": [{"path": "x"}, {"label": "y"}],
-        }
-        self.assertEqual(
-            sorted(key_paths(value)),
-            [
-                "rows",
-                "rows[].label",
-                "rows[].path",
-                "settings",
-                "settings.a",
-                "settings.deep",
-                "success",
-            ],
-        )
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/test_pair_scan.py

@@ -115,12 +115,7 @@ class TestPairScan(AdminAPITestCase):
         self.assertEqual(second["pairs_added"], 0)
 
     def test_legacy_single_prompt_second_pass_not_reported_as_new_link(self):
-        # A sampler-less graph: one encoder wired into a guider (#252).
-        single = {
-            "1": graph()["1"],
-            "2": {"class_type": "BasicGuider", "inputs": {"conditioning": ["1", 0]}},
-        }
-        meta = {"prompt": json.dumps(single)}
+        meta = {"prompt": json.dumps({"1": graph()["1"]})}
         path = self.output_dir / "old.png"
         self.assertEqual(self.api._ingest_scanned_file(path, meta), "added")
         self.assertEqual(self.api._ingest_scanned_file(path, meta), "unchanged")
@@ -297,155 +292,3 @@ class TestPairScan(AdminAPITestCase):
             self.api.db.get_image_prompt_info(str(path))["workflow_data"], workflow
         )
         self.assertEqual(self.api._ingest_scanned_file(path, metadata), "unchanged")
-
-
-def flux_graph(text="a red fox", encoder="CLIPTextEncode"):
-    """A sampler-less Flux graph: the prompt reaches a guider's conditioning (#252)."""
-    return {
-        "1": {"class_type": "UNETLoader", "inputs": {"unet_name": "flux.safetensors"}},
-        "2": {"class_type": "DualCLIPLoader", "inputs": {"clip_name1": "t5"}},
-        "6": {"class_type": encoder, "inputs": {"text": text, "clip": ["2", 0]}},
-        "22": {
-            "class_type": "BasicGuider",
-            "inputs": {"model": ["1", 0], "conditioning": ["6", 0]},
-        },
-        "13": {
-            "class_type": "SamplerCustomAdvanced",
-            "inputs": {"guider": ["22", 0], "sigmas": ["17", 0]},
-        },
-        "17": {"class_type": "BasicScheduler", "inputs": {"steps": 20}},
-        "9": {"class_type": "SaveImage", "inputs": {"images": ["13", 0]}},
-    }
-
-
-class TestSamplerLessScan(AdminAPITestCase):
-    """Graphs where no node takes a positive or negative input (#252)."""
-
-    def _scanned(self, name, prompt_graph, workflow=None):
-        meta = {"prompt": json.dumps(prompt_graph)}
-        if workflow is not None:
-            meta["workflow"] = json.dumps(workflow)
-        return self.api._ingest_scanned_file(self.output_dir / name, meta)
-
-    def _texts(self):
-        return [p["text"] for p in self.api.db.get_recent_prompts()["prompts"]]
-
-    def test_the_one_wired_prompt_is_linked(self):
-        self.assertEqual(self._scanned("flux.png", flux_graph()), "added")
-        self.assertEqual(self._texts(), ["a red fox"])
-
-    def test_a_text_node_feeding_the_encoder_is_one_prompt(self):
-        g = flux_graph(text=["30", 0])
-        g["30"] = {"class_type": "TextInput", "inputs": {"text": "a red fox"}}
-        self.assertEqual(self._scanned("textinput.png", g), "added")
-        self.assertEqual(self._texts(), ["a red fox"])
-
-    def test_a_display_node_that_feeds_nothing_is_never_the_prompt(self):
-        # A real scan stored a "=== GIT CLONE REPORT ===" display text this way.
-        g = flux_graph()
-        g["40"] = {
-            "class_type": "easy showAnything",
-            "inputs": {"text": "=== GIT CLONE REPORT ===\nTotal repositories: 1"},
-        }
-        self.assertEqual(self._scanned("report.png", g), "added")
-        self.assertEqual(self._texts(), ["a red fox"])
-
-    def test_only_unconsumed_texts_store_nothing(self):
-        g = {
-            "40": {"class_type": "easy showAnything", "inputs": {"text": "report"}},
-            "41": {"class_type": "Textbox", "inputs": {"text": "install note"}},
-        }
-        self.assertEqual(self._scanned("notes.png", g), "found")
-        self.assertEqual(self._texts(), [])
-
-    def test_two_wired_texts_are_ambiguous_and_stay_unlinked(self):
-        # A LoRA loader's text input is wired too: the scan stored "<lora:...>".
-        g = flux_graph()
-        g["50"] = {
-            "class_type": "Lora Loader (LoraManager)",
-            "inputs": {
-                "model": ["1", 0],
-                "clip": ["2", 0],
-                "text": "<lora:style:1.00>",
-            },
-        }
-        g["22"]["inputs"]["model"] = ["50", 0]
-        g["6"]["inputs"]["clip"] = ["50", 1]
-        self.assertEqual(self._scanned("lora.png", g), "unresolved")
-        self.assertEqual(self._texts(), [])
-
-    def test_an_untraceable_wired_text_makes_the_graph_ambiguous(self):
-        # The encoder's text comes from a node no rule reads: never guess the other.
-        g = flux_graph(text=["60", 0])
-        g["60"] = {"class_type": "SomeLLMNode", "inputs": {"seed": 1}}
-        g["50"] = {
-            "class_type": "Lora Loader (LoraManager)",
-            "inputs": {"model": ["1", 0], "text": "<lora:style:1.00>"},
-        }
-        g["22"]["inputs"]["model"] = ["50", 0]
-        self.assertEqual(self._scanned("llm.png", g), "unresolved")
-        self.assertEqual(self._texts(), [])
-
-    def test_this_repositorys_prompt_node_is_authoritative(self):
-        g = flux_graph(text="a red fox", encoder="PromptManager")
-        g["50"] = {
-            "class_type": "Lora Loader (LoraManager)",
-            "inputs": {"model": ["1", 0], "text": "<lora:style:1.00>"},
-        }
-        g["22"]["inputs"]["model"] = ["50", 0]
-        self.assertEqual(self._scanned("own.png", g), "added")
-        self.assertEqual(self._texts(), ["a red fox"])
-
-    def test_a_numeric_text_is_never_stored_as_a_prompt(self):
-        self.assertEqual(self._scanned("number.png", flux_graph(text="2048")), "found")
-        self.assertEqual(self._texts(), [])
-
-    def test_workflow_widget_values_are_never_read(self):
-        # The API text is linked from a node no rule reads; the UI workflow
-        # still holds a stale widget value, which the old scan stored.
-        g = flux_graph(text=["70", 0])
-        g["70"] = {"class_type": "PromptBuilder", "inputs": {"prompt": "x", "n": 2}}
-        workflow = {
-            "nodes": [
-                {"id": 6, "type": "CLIPTextEncode", "widgets_values": ["stale text"]}
-            ]
-        }
-        self.assertEqual(self._scanned("stale.png", g, workflow), "unresolved")
-        self.assertEqual(self._texts(), [])
-
-    def test_a_lora_loaders_trigger_word_output_is_not_its_text(self):
-        # The encoder reads the loader's trigger-word output (slot 2), not its
-        # text input: the prompt is unknown, never the "<lora:...>" syntax.
-        g = flux_graph(text=["50", 2])
-        g["50"] = {
-            "class_type": "Lora Loader (LoraManager)",
-            "inputs": {"model": ["1", 0], "text": "<lora:style:1.00>"},
-        }
-        g["22"]["inputs"]["model"] = ["50", 0]
-        self.assertEqual(self._scanned("trigger.png", g), "unresolved")
-        self.assertEqual(self._texts(), [])
-
-    def test_a_seeded_text_node_holds_a_template_not_the_prompt(self):
-        g = flux_graph(text=["80", 0])
-        g["80"] = {
-            "class_type": "RandomPrompt",
-            "inputs": {"text": "a {red|blue} fox", "seed": 5},
-        }
-        self.assertEqual(self._scanned("random.png", g), "unresolved")
-        self.assertEqual(self._texts(), [])
-
-    def test_a1111_parameters_beside_an_undecided_graph_are_read(self):
-        # Metadata savers write both; the old scan read the A1111 positive.
-        g = flux_graph()
-        g["50"] = {
-            "class_type": "Lora Loader (LoraManager)",
-            "inputs": {"model": ["1", 0], "text": "<lora:style:1.00>"},
-        }
-        g["22"]["inputs"]["model"] = ["50", 0]
-        meta = {
-            "prompt": json.dumps(g),
-            "parameters": "a red fox\nNegative prompt: blur\nSteps: 20",
-        }
-        path = self.output_dir / "saver.png"
-        self.assertEqual(self.api._ingest_scanned_file(path, meta), "added")
-        self.assertEqual(self._texts(), ["a red fox"])

tests/test_sampler_less_prompt.py

@@ -1,112 +0,0 @@
-"""``sampler_less_prompt``: the one wired text of a graph with no sampler (#252)."""
-
-import time
-import unittest
-
-from utils.prompt_pair_resolver import sampler_less_prompt
-
-
-def _guided(**nodes):
-    """``nodes`` plus a guider consuming node ``"1"``."""
-    graph = {"9": {"class_type": "BasicGuider", "inputs": {"conditioning": ["1", 0]}}}
-    graph.update(nodes)
-    return graph
-
-
-class TestSamplerLessPrompt(unittest.TestCase):
-    def test_not_a_graph_or_too_large_is_absent(self):
-        for graph in (None, [], {}, "text"):
-            self.assertEqual(sampler_less_prompt(graph)["state"], "absent")
-        big = {str(i): {"class_type": "X", "inputs": {}} for i in range(3)}
-        self.assertEqual(sampler_less_prompt(big, max_visits=2)["state"], "absent")
-
-    def test_one_literal_text(self):
-        graph = _guided(**{"1": {"class_type": "Enc", "inputs": {"text": " a fox "}}})
-        self.assertEqual(
-            sampler_less_prompt(graph),
-            {"state": "resolved", "text": "a fox", "texts": ["a fox"]},
-        )
-
-    def test_a_number_literal_is_never_a_prompt(self):
-        for value in (2048, "2048", "1.5", " 7 "):
-            graph = _guided(**{"1": {"class_type": "Enc", "inputs": {"text": value}}})
-            self.assertEqual(sampler_less_prompt(graph)["state"], "absent", value)
-
-    def test_a_long_digit_run_with_a_letter_is_text_and_fast(self):
-        text = "9" * 50_000 + "x"
-        graph = _guided(**{"1": {"class_type": "Enc", "inputs": {"text": text}}})
-        started = time.monotonic()
-        self.assertEqual(sampler_less_prompt(graph)["text"], text)
-        self.assertLess(time.monotonic() - started, 1.0)
-
-    def test_number_like_words_are_prompts(self):
-        for value in ("nan", "inf", "Infinity", "1_000"):
-            graph = _guided(**{"1": {"class_type": "Enc", "inputs": {"text": value}}})
-            self.assertEqual(sampler_less_prompt(graph)["text"], value)
-
-    def test_an_own_node_with_unreadable_text_beside_another_text_is_ambiguous(self):
-        graph = _guided(
-            **{
-                "1": {"class_type": "PromptManager", "inputs": {"text": ["5", 0]}},
-                "5": {"class_type": "LLM", "inputs": {"seed": 3}},
-                "2": {"class_type": "Enc", "inputs": {"text": "<lora:x:1>"}},
-                "3": {"class_type": "Sink", "inputs": {"c": ["2", 0]}},
-            }
-        )
-        self.assertEqual(sampler_less_prompt(graph)["state"], "ambiguous")
-
-    def test_unhashable_class_type_is_an_unknown_node_not_a_crash(self):
-        graph = _guided(**{"1": {"class_type": ["x"], "inputs": {"text": "a fox"}}})
-        self.assertEqual(sampler_less_prompt(graph)["text"], "a fox")
-
-    def test_own_negative_node_is_not_authoritative(self):
-        graph = _guided(
-            **{
-                "1": {"class_type": "Enc", "inputs": {"text": "a fox"}},
-                "2": {
-                    "class_type": "PromptManagerNegative",
-                    "inputs": {"text": "blur"},
-                },
-                "3": {"class_type": "Sink", "inputs": {"c": ["2", 0]}},
-            }
-        )
-        found = sampler_less_prompt(graph)
-        self.assertEqual(found["state"], "ambiguous")
-        self.assertEqual(found["texts"], ["a fox", "blur"])
-
-    def test_own_node_text_wins_over_an_untraceable_text(self):
-        graph = _guided(
-            **{
-                "1": {"class_type": "PromptManagerText", "inputs": {"text": "a fox"}},
-                "2": {"class_type": "Enc", "inputs": {"text": ["5", 0]}},
-                "5": {"class_type": "LLM", "inputs": {"seed": 3}},
-                "6": {"class_type": "Sink", "inputs": {"c": ["2", 0]}},
-            }
-        )
-        self.assertEqual(sampler_less_prompt(graph)["text"], "a fox")
-
-    def test_two_own_texts_are_ambiguous(self):
-        graph = _guided(
-            **{
-                "1": {"class_type": "PromptManager", "inputs": {"text": "a fox"}},
-                "2": {"class_type": "PromptManager", "inputs": {"text": "a cat"}},
-                "3": {"class_type": "Sink", "inputs": {"c": ["2", 0]}},
-            }
-        )
-        self.assertEqual(sampler_less_prompt(graph)["state"], "ambiguous")
-
-    def test_only_an_untraceable_text_is_ambiguous_with_nothing_to_show(self):
-        graph = _guided(
-            **{
-                "1": {"class_type": "Enc", "inputs": {"text": ["5", 0]}},
-                "5": {"class_type": "LLM", "inputs": {"seed": 3}},
-            }
-        )
-        self.assertEqual(
-            sampler_less_prompt(graph),
-            {"state": "ambiguous", "text": None, "texts": []},
-        )
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/vendor/legacy-coverage.test.mjs

@@ -1,7 +1,6 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
-import { COLUMNS, CONTROL_EXEMPTIONS, PAGES, REMOVAL_COLUMNS, STATUSES, declaredTitles, duplicateRemovals, idUses, methodUses,
-    parseControl, parseCoverageTable, parseRemovalTable, readCoverageTable, readPage, readRemovalTable, removalProblems,
+import { COLUMNS, CONTROL_EXEMPTIONS, STATUSES, declaredTitles, parseControl, parseCoverageTable, readCoverageTable,
     rowProblems } from '../../tools/vendor/legacy-coverage.mjs';
 
 // TESTING.md "Legacy System capability coverage" (#249 System S12, #329): every legacy System capability names an
@@ -115,99 +114,3 @@ test('a covered row names its native control unless it is exempt', () => {
         assert.deepEqual([row.Status, row['Native control']], ['covered', '—']);
     }
 });
-
-// TESTING.md "Legacy System UI removed by S13" (#330): a legacy element is removed only when its capability is
-// `covered`, the removal copies that row's native test, and the element is really gone from its page.
-const COVERAGE_HEADER = '| Capability | Legacy anchor | Owner | Status | Native control | Test |\n| --- | --- | --- | --- | --- | --- |';
-const REMOVAL_HEADER = '| Capability | Page | Removed ids | Removed methods | Native test |\n| --- | --- | --- | --- | --- |';
-const FIXTURE_COVERAGE = parseCoverageTable(['### Legacy System capability coverage', '', COVERAGE_HEADER,
-    '| View logs | `admin.html:1` | S12 Logs | covered | `diagnostics` · combobox · "Level" | level filter works (logs.spec.mjs) |',
-    '| Infinite scrolling default | `admin.html:2` | Legacy prompt list | kept in legacy | — | scrolls (list-state.test.js) |',
-    ''].join('\n'));
-const removalRow = cells => parseRemovalTable(['### Legacy System UI removed by S13', '', REMOVAL_HEADER, `| ${cells} |`, '']
-    .join('\n'))[0];
-const EMPTY_PAGE = () => ({ html: '<button id="kept">Kept</button>', script: 'class Admin {\n    kept() {}\n}\n' });
-
-test('every removed legacy element cites a covered capability and its native test', () => {
-    const coverage = readCoverageTable();
-    const rows = readRemovalTable();
-    for (const row of rows) {
-        const cited = coverage.find(item => item.Capability === row.Capability);
-        assert.ok(cited, `TESTING.md:${row.line} cites "${row.Capability}"`);
-        assert.equal(cited.Status, 'covered', `TESTING.md:${row.line} ${row.Capability}`);
-        assert.equal(row['Native test'], cited.Test, `TESTING.md:${row.line} ${row.Capability}`);
-        assert.ok(Object.keys(PAGES).includes(row.Page), `TESTING.md:${row.line} page ${row.Page}`);
-    }
-    assert.deepEqual(duplicateRemovals(rows), []);
-    assert.deepEqual(REMOVAL_COLUMNS, ['Capability', 'Page', 'Removed ids', 'Removed methods', 'Native test']);
-});
-
-test('a removed id or method is gone from its page', () => {
-    const coverage = readCoverageTable();
-    for (const row of readRemovalTable()) {
-        assert.deepEqual(removalProblems(row, coverage, page => readPage(page)), [], `TESTING.md:${row.line} ${row.Capability}`);
-    }
-    // Each way a page can still hold an id or a method is found; a call through another object, or a longer name, is not
-    // a definition.
-    const page = {
-        html: '<div id="logsModal"></div><button onclick="window.admin.closeLogs()">x</button>',
-        script: [
-            "document.getElementById('logLevel').value;",
-            "this.showModal('diagnosticsModal');",
-            '<span data-id="logsContainer"></span>',
-            'document.querySelector("#logLimit option");',
-            "const backdrops = ['settingsModal', 'duplicatesModal'];",
-            'class Admin {',
-            '    async refreshLogs(level) {',
-            '    }',
-            '}            displayLogs(logs) {',
-            '    }',
-            'this.loadLogStats();',
-            '// downloadLogs() {',
-            'other.formatBytesLater(1);',
-        ].join('\n'),
-    };
-    assert.deepEqual(idUses('logsModal', page), ['id="logsModal" in the markup']);
-    assert.deepEqual(idUses('logLevel', page), ["getElementById('logLevel')"]);
-    assert.deepEqual(idUses('logLimit', page), ["querySelector('#logLimit')"]);
-    assert.deepEqual(idUses('duplicatesModal', page), ["'duplicatesModal' in a modal list"]);
-    assert.deepEqual(idUses('logLevelX', page), []);
-    assert.deepEqual(idUses('diagnosticsModal', page), ["a …Modal('diagnosticsModal') call"]);
-    assert.deepEqual(idUses('logsContainer', page), []);
-    assert.deepEqual(methodUses('closeLogs', page), ['.closeLogs( called in the markup']);
-    assert.deepEqual(methodUses('refreshLogs', page), ['refreshLogs() defined']);
-    assert.deepEqual(methodUses('displayLogs', page), ['displayLogs() defined']);
-    assert.deepEqual(methodUses('loadLogStats', page), ['.loadLogStats( called']);
-    assert.deepEqual(methodUses('downloadLogs', page), []);
-    assert.deepEqual(methodUses('formatBytes', page), []);
-    // One id or method is listed on one row per page.
-    const twice = [removalRow('View logs | admin | `#logsModal` | — | level filter works (logs.spec.mjs)'),
-        { ...removalRow('View logs | admin | `#logsModal` | — | level filter works (logs.spec.mjs)'), line: 9 }];
-    assert.match(duplicateRemovals(twice).join(), /admin #logsModal is listed on rows/);
-    assert.deepEqual(removalProblems(removalRow('View logs | admin | `logsModal`, `#ok` | `close` | level filter works (logs.spec.mjs)'),
-        FIXTURE_COVERAGE, EMPTY_PAGE), ['malformed entry "logsModal"', 'malformed entry "close"']);
-});
-
-test('a removal citing a kept-in-legacy capability fails', () => {
-    const row = removalRow('Infinite scrolling default | admin | `#infiniteScrollDefault` | — | scrolls (list-state.test.js)');
-    assert.deepEqual(removalProblems(row, FIXTURE_COVERAGE, EMPTY_PAGE), ['cites a kept in legacy capability']);
-    const unknown = removalRow('Something else | admin | — | — | scrolls (list-state.test.js)');
-    assert.deepEqual(removalProblems(unknown, FIXTURE_COVERAGE, EMPTY_PAGE), ['cites no single coverage row "Something else"']);
-});
-
-test('a removal whose native test differs fails', () => {
-    const row = removalRow('View logs | admin | `#logsModal` | `showLogsModal()` | another title (logs.spec.mjs)');
-    assert.deepEqual(removalProblems(row, FIXTURE_COVERAGE, EMPTY_PAGE),
-        ['its native test differs from the coverage row\'s "level filter works (logs.spec.mjs)"']);
-    assert.deepEqual(removalProblems({ ...row, 'Native test': 'level filter works (logs.spec.mjs)' }, FIXTURE_COVERAGE, EMPTY_PAGE), []);
-});
-
-test('a removed id still on its page fails', () => {
-    const row = removalRow('View logs | admin | `#logsModal` | `showLogsModal()` | level filter works (logs.spec.mjs)');
-    const page = () => ({ html: '<div id="logsModal" class="hidden"></div>', script: 'class Admin {\n    showLogsModal() {\n    }\n}\n' });
-    assert.deepEqual(removalProblems(row, FIXTURE_COVERAGE, page), [
-        '#logsModal is still on the admin page: id="logsModal" in the markup',
-        'showLogsModal() is still on the admin page: showLogsModal() defined',
-    ]);
-    assert.deepEqual(removalProblems({ ...row, Page: 'metadata' }, FIXTURE_COVERAGE, page), ['unknown page "metadata"']);
-});

tools/vendor/frontend-coverage-baseline.json

@@ -275,12 +275,6 @@
     "functions": 85,
     "statements": 98
   },
-  "workspace/images-multiselect.mjs": {
-    "lines": 98,
-    "branches": 98,
-    "functions": 98,
-    "statements": 98
-  },
   "workspace/images-selection.mjs": {
     "lines": 98,
     "branches": 93,

tools/vendor/legacy-coverage.mjs

@@ -42,30 +42,25 @@ function cells(line) {
     return out;
 }
 
-/** The rows, keyed by `columns`, of the first Markdown table under `heading` (`label` names it in errors). */
-function parseTable(markdown, heading, columns, label) {
+/** The table's rows as objects keyed by COLUMNS, from the section that starts at HEADING. */
+export function parseCoverageTable(markdown) {
     const lines = markdown.split('\n');
-    const start = lines.findIndex(line => line.trim() === heading);
-    if (start === -1) throw new Error(`TESTING.md has no "${heading}" section`);
+    const start = lines.findIndex(line => line.trim() === HEADING);
+    if (start === -1) throw new Error(`TESTING.md has no "${HEADING}" section`);
     const header = lines.findIndex((line, index) => index > start && line.trim().startsWith('|'));
     if (header === -1 || lines.slice(start + 1, header).some(line => /^#{1,3} /.test(line))) {
-        throw new Error(`The ${label} section has no table`);
+        throw new Error('The coverage section has no table');
     }
-    const found = cells(lines[header]);
-    if (found.join('|') !== columns.join('|')) throw new Error(`The ${label} table's columns are ${found.join(', ')}`);
+    const columns = cells(lines[header]);
+    if (columns.join('|') !== COLUMNS.join('|')) throw new Error(`The coverage table's columns are ${columns.join(', ')}`);
     const rows = [];
     for (let index = header + 2; index < lines.length && lines[index].trim().startsWith('|'); index += 1) {
         const values = cells(lines[index]);
-        rows.push({ line: index + 1, ...Object.fromEntries(columns.map((column, at) => [column, values[at] ?? ''])) });
+        rows.push({ line: index + 1, ...Object.fromEntries(COLUMNS.map((column, at) => [column, values[at] ?? ''])) });
     }
     return rows;
 }
 
-/** The table's rows as objects keyed by COLUMNS, from the section that starts at HEADING. */
-export function parseCoverageTable(markdown) {
-    return parseTable(markdown, HEADING, COLUMNS, 'coverage');
-}
-
 /**
  * A Native control cell: `` `<section>` · <role> · "<name>" ``, optionally ` · in "<row title>"` when the name is shared
  * by several rows of the section → {section, role, name, row}; `—` → null; else it throws.
@@ -218,130 +213,3 @@ export function rowProblems(row, { root = ROOT, locate = file => testFile(file,
 export function readCoverageTable(root = ROOT) {
     return parseCoverageTable(readFileSync(join(root, 'TESTING.md'), 'utf8'));
 }
-
-// ── Legacy System UI removed by S13 (#330) ──────────────────────────────────────────────────────────────────────────
-// TESTING.md "Legacy System UI removed by S13": one row per covered capability whose legacy UI S13 removed, with the
-// element ids and methods that went. A row must cite a `covered` coverage row and copy its Test cell, and none of its
-// ids or methods may still be on its page.
-export const REMOVAL_HEADING = '### Legacy System UI removed by S13';
-export const REMOVAL_COLUMNS = Object.freeze(['Capability', 'Page', 'Removed ids', 'Removed methods', 'Native test']);
-/** Each legacy page's markup and script. */
-export const PAGES = Object.freeze({
-    admin: Object.freeze({ html: 'web/admin.html', script: 'web/js/admin.js' }),
-    gallery: Object.freeze({ html: 'web/gallery.html', script: 'web/js/gallery.js' }),
-});
-
-/** The removal table's rows, from the section that starts at REMOVAL_HEADING. */
-export function parseRemovalTable(markdown) {
-    return parseTable(markdown, REMOVAL_HEADING, REMOVAL_COLUMNS, 'removal');
-}
-
-/** The removal table read from TESTING.md. */
-export function readRemovalTable(root = ROOT) {
-    return parseRemovalTable(readFileSync(join(root, 'TESTING.md'), 'utf8'));
-}
-
-/** A Removed ids or Removed methods cell → its entries without backticks (`—` → none). */
-export function listCell(cell) {
-    if (cell.trim() === NONE) return [];
-    return cell.split(',').map(entry => entry.trim().replace(/^`|`$/g, '')).filter(Boolean);
-}
-
-/** The removed ids of a row (without `#`) and its malformed entries. */
-function removedIds(row) {
-    const entries = listCell(row['Removed ids']);
-    return { ids: entries.filter(entry => /^#[\w-]+$/.test(entry)).map(entry => entry.slice(1)),
-        bad: entries.filter(entry => !/^#[\w-]+$/.test(entry)) };
-}
-
-/** The removed methods of a row (without `()`) and its malformed entries. */
-function removedMethods(row) {
-    const entries = listCell(row['Removed methods']);
-    return { names: entries.filter(entry => /^[A-Za-z_$][\w$]*\(\)$/.test(entry)).map(entry => entry.slice(0, -2)),
-        bad: entries.filter(entry => !/^[A-Za-z_$][\w$]*\(\)$/.test(entry)) };
-}
-
-const escapeRegExp = text => text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-
-/**
- * Where `id` is still on a page: `id="<id>"` in its markup or script; in its script a lookup, a `…Modal("<id>")` call
- * (`showModal`, `hideModal`) or a modal-list entry.
- */
-export function idUses(id, { html, script }) {
-    const name = escapeRegExp(id);
-    const code = stripJsComments(script);
-    const uses = [];
-    // `id=`, not `data-id=`: the attribute starts after a space or a tag's `<name`.
-    const attribute = new RegExp(`(?:^|\\s)id=["']${name}["']`, 'm');
-    if (attribute.test(html)) uses.push(`id="${id}" in the markup`);
-    if (attribute.test(code)) uses.push(`id="${id}" in the script`);
-    if (new RegExp(`getElementById\\(\\s*["'\`]${name}["'\`]\\s*\\)`).test(code)) uses.push(`getElementById('${id}')`);
-    if (new RegExp(`querySelector(?:All)?\\(\\s*["'\`]#${name}\\b`).test(code)) uses.push(`querySelector('#${id}')`);
-    if (new RegExp(`\\w*Modal\\(\\s*["'\`]${name}["'\`]`).test(code)) uses.push(`a …Modal('${id}') call`);
-    // A string list of modal ids (the gallery's backdrop list): the entry next to another `…Modal` entry.
-    for (const list of code.matchAll(/\[[^\[\]]*\]/g)) {
-        const entry = new RegExp(`["']${name}["']`);
-        if (entry.test(list[0]) && /["'][\w-]*Modal["']/.test(list[0].replace(entry, ''))) {
-            uses.push(`'${id}' in a modal list`);
-            break;
-        }
-    }
-    return uses;
-}
-
-/**
- * Where method `name` is still on a page: a definition in its script, or a `.<name>(` call (`this.`, `window.admin.`)
- * in its script or markup.
- */
-export function methodUses(name, { html, script }) {
-    const method = escapeRegExp(name);
-    const code = stripJsComments(script);
-    const uses = [];
-    if (new RegExp(`(?:^|[\\s;}])(?:async\\s+)?${method}\\s*\\([^)]*\\)\\s*\\{`, 'm').test(code)) uses.push(`${name}() defined`);
-    if (new RegExp(`\\.${method}\\s*\\(`).test(code)) uses.push(`.${name}( called`);
-    if (new RegExp(`\\.${method}\\s*\\(`).test(html)) uses.push(`.${name}( called in the markup`);
-    return uses;
-}
-
-/**
- * Every problem of one removal row (empty: sound). `coverage` is the coverage table's rows; `readPage(page)` returns
- * that page's `{html, script}`.
- */
-export function removalProblems(row, coverage, readPage) {
-    const problems = [];
-    const cited = coverage.filter(item => item.Capability === row.Capability);
-    if (cited.length !== 1) problems.push(`cites no single coverage row "${row.Capability}"`);
-    else if (cited[0].Status !== 'covered') problems.push(`cites a ${cited[0].Status} capability`);
-    else if (cited[0].Test !== row['Native test']) problems.push(`its native test differs from the coverage row's "${cited[0].Test}"`);
-    if (!Object.hasOwn(PAGES, row.Page)) {
-        problems.push(`unknown page "${row.Page}"`);
-        return problems;
-    }
-    const { ids, bad: badIds } = removedIds(row);
-    const { names, bad: badNames } = removedMethods(row);
-    for (const entry of [...badIds, ...badNames]) problems.push(`malformed entry "${entry}"`);
-    const page = readPage(row.Page);
-    for (const id of ids) for (const use of idUses(id, page)) problems.push(`#${id} is still on the ${row.Page} page: ${use}`);
-    for (const name of names) for (const use of methodUses(name, page)) problems.push(`${name}() is still on the ${row.Page} page: ${use}`);
-    return problems;
-}
-
-/** Ids and methods listed on more than one row of the same page. */
-export function duplicateRemovals(rows) {
-    const seen = new Map();
-    const duplicates = [];
-    for (const row of rows) {
-        for (const entry of [...listCell(row['Removed ids']), ...listCell(row['Removed methods'])]) {
-            const key = `${row.Page} ${entry}`;
-            if (seen.has(key)) duplicates.push(`${key} is listed on rows ${seen.get(key)} and ${row.line}`);
-            else seen.set(key, row.line);
-        }
-    }
-    return duplicates;
-}
-
-/** A page's markup and script from the repository. */
-export function readPage(page, root = ROOT) {
-    const files = PAGES[page];
-    return { html: readFileSync(join(root, files.html), 'utf8'), script: readFileSync(join(root, files.script), 'utf8') };
-}

utils/prompt_pair_resolver.py

@@ -2578,115 +2578,3 @@ def resolve_text_input(
         return resolver.text(inputs.get(input_name), "string")[0]
     except _Unresolved:
         return None
-
-
-_NUMBER = re.compile(r"[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?")
-
-
-def _numeric(text: str) -> bool:
-    """Whether ``text`` is a plain number (a widget value such as ``2048``)."""
-    return _NUMBER.fullmatch(text) is not None
-
-
-def sampler_less_prompt(graph: Any, *, max_visits: int = 500) -> Dict[str, Any]:
-    """The positive prompt of an API graph with no sampler pair, if one (#252).
-
-    For graphs ``_no_sampler`` finds ``absent`` (no node takes a ``positive``
-    or ``negative`` input, such as a Flux guider or a video wrapper). Only the
-    executed API graph is read, never the UI workflow. A candidate is a node
-    with a ``text`` input whose output another node consumes: a text that
-    feeds nothing did not make the image. Its text is traced as a STRING
-    (``resolve_text_input``); a linked text no rule reads is unknown unless
-    it is built from a candidate's text (``_covered``). Blank and
-    numeric texts are never prompts, and a node with a seed input holds a
-    template, not the prompt (unknown). This repository's own positive-text
-    nodes are authoritative: when they give a text, only they count.
-
-    Returns ``{"state", "text", "texts"}``: ``resolved`` with the one distinct
-    text; ``ambiguous`` when several texts or an unknown one could be the
-    prompt (``texts`` lists the readable ones); ``absent`` when none.
-    """
-    absent = {"state": "absent", "text": None, "texts": []}
-    if not isinstance(graph, dict) or not graph or len(graph) > max_visits:
-        return absent
-    nodes = {str(key): value for key, value in graph.items()}
-    consumed = {
-        str(value[0])
-        for node in nodes.values()
-        if isinstance(node, dict) and isinstance(node.get("inputs"), dict)
-        for value in node["inputs"].values()
-        if _link(value)
-    }
-    own: list = []
-    other: list = []
-    unknown = False
-    for node_id, node in nodes.items():
-        inputs = node.get("inputs") if isinstance(node, dict) else None
-        if node_id not in consumed or not _has_text_input(node):
-            continue
-        if _seeded(inputs):
-            # Generated at run time (a wildcard or a language model): its
-            # text input is a template, not the prompt that ran.
-            unknown = True
-            continue
-        value = inputs["text"]
-        text = resolve_text_input(nodes, node_id, "text", max_visits=max_visits)
-        if text is None:
-            # A literal that is not a string (a number) is never a prompt.
-            if _link(value) and not _covered(nodes, value):
-                unknown = True
-            continue
-        text = text.strip()
-        if not text or _numeric(text):
-            continue
-        kind = node.get("class_type")
-        if isinstance(kind, str) and kind in _OWN_CLASSES and "Negative" not in kind:
-            own.append(text)
-        else:
-            other.append(text)
-    texts = list(dict.fromkeys(own or other))
-    if len(texts) == 1 and (own or not unknown):
-        return {"state": "resolved", "text": texts[0], "texts": texts}
-    if texts or unknown:
-        return {"state": "ambiguous", "text": None, "texts": texts}
-    return absent
-
-
-def _has_text_input(node: Any) -> bool:
-    inputs = node.get("inputs") if isinstance(node, dict) else None
-    return isinstance(inputs, dict) and "text" in inputs
-
-
-def _seeded(inputs: dict) -> bool:
-    """A seed input: the node's string output is a run-time value (the
-    resolver's ``runtime-value`` rule)."""
-    return any(isinstance(name, str) and name.endswith("seed") for name in inputs)
-
-
-def _covered(nodes: dict, link: list) -> bool:
-    """Whether an unreadable text link is built from a candidate's text.
-
-    True when a node upstream of ``link`` is read through its first output
-    (slot 0, the legacy encoder rule's text) and has an unseeded ``text``
-    input: that candidate is read on its own, and whatever else is joined to
-    it at run time (a caption, a language model) is no stored prompt to
-    choose. Another output of such a node (a loader's trigger words) is not
-    its text. False when the text comes only from inputs no candidate holds
-    (a builder's ``prompt`` field): the prompt is unknown then.
-    """
-    seen, stack = set(), [(str(link[0]), link[1])]
-    while stack:
-        node_id, slot = stack.pop()
-        if (node_id, slot) in seen:
-            continue
-        seen.add((node_id, slot))
-        node = nodes.get(node_id)
-        inputs = node.get("inputs") if isinstance(node, dict) else None
-        if not isinstance(inputs, dict):
-            continue
-        if "text" in inputs and slot == 0 and not _seeded(inputs):
-            return True
-        stack.extend(
-            (str(value[0]), value[1]) for value in inputs.values() if _link(value)
-        )
-    return False

web/admin.html

@@ -168,11 +168,10 @@
                                 class="px-2.5 py-1 bg-pm-surface border border-pm hover:bg-pm-hover text-pm text-xs font-medium rounded-pm-sm transition-colors">
                             Settings
                         </button>
-                        <a id="diagnosticsBtn" href="workspace#/system/diagnostics" target="_blank" rel="noopener"
-                           title="Opens System › Diagnostics &amp; logs in a new tab"
-                           class="px-2.5 py-1 bg-pm-surface border border-pm hover:bg-pm-hover text-pm text-xs font-medium rounded-pm-sm transition-colors">
+                        <button id="diagnosticsBtn"
+                                class="px-2.5 py-1 bg-pm-surface border border-pm hover:bg-pm-hover text-pm text-xs font-medium rounded-pm-sm transition-colors">
                             Diagnostics
-                        </a>
+                        </button>
                         <button id="maintenanceBtn"
                                 class="px-2.5 py-1 bg-pm-surface border border-pm hover:bg-pm-hover text-pm text-xs font-medium rounded-pm-sm transition-colors">
                             Maintenance
@@ -193,11 +192,10 @@
                                 class="px-2.5 py-1 bg-pm-surface border border-pm hover:bg-pm-hover text-pm text-xs font-medium rounded-pm-sm transition-colors">
                             Auto Tag
                         </button>
-                        <a id="logsBtn" href="workspace#/system/diagnostics" target="_blank" rel="noopener"
-                           title="Opens System › Diagnostics &amp; logs in a new tab"
-                           class="px-2.5 py-1 bg-pm-surface border border-pm hover:bg-pm-hover text-pm text-xs font-medium rounded-pm-sm transition-colors">
+                        <button id="logsBtn"
+                                class="px-2.5 py-1 bg-pm-surface border border-pm hover:bg-pm-hover text-pm text-xs font-medium rounded-pm-sm transition-colors">
                             View Logs
-                        </a>
+                        </button>
                         <button id="metadataBtn"
                                 class="px-2.5 py-1 bg-pm-surface border border-pm hover:bg-pm-hover text-pm text-xs font-medium rounded-pm-sm transition-colors">
                             Metadata
@@ -643,6 +641,37 @@
         </div>
     </div>
 
+    <!-- Diagnostics Modal -->
+    <div id="diagnosticsModal" class="fixed inset-0 bg-black/60 backdrop-blur-[2px] hidden items-center justify-center z-50">
+        <div class="bg-pm-surface rounded-pm-lg max-w-4xl w-full max-h-[90vh] overflow-hidden mx-4 border border-pm shadow-pm">
+            <div class="p-4 border-b border-pm">
+                <div class="flex items-center justify-between">
+                    <h3 class="text-sm font-semibold text-pm">Gallery System Diagnostics</h3>
+                    <button onclick="window.admin.closeDiagnostics()" class="p-1 rounded-pm-sm hover:bg-pm-hover transition-colors">
+                        <svg class="w-4 h-4 text-pm-secondary" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M6 18L18 6M6 6l12 12"></path>
+                        </svg>
+                    </button>
+                </div>
+            </div>
+            <div class="p-4 overflow-y-auto max-h-[calc(90vh-120px)]">
+                <div class="flex items-center justify-between mb-3">
+                    <button id="runDiagnosticsBtn" class="px-2.5 py-1.5 bg-pm-accent hover:bg-pm-accent-hover text-pm-accent-fg text-xs font-medium rounded-pm-sm transition-colors">
+                        Run Diagnostics
+                    </button>
+                    <button id="testImageLinkBtn" class="px-2.5 py-1.5 bg-pm-surface border border-pm hover:bg-pm-hover text-pm text-xs font-medium rounded-pm-sm transition-colors">
+                        Test Image Link
+                    </button>
+                </div>
+                <div id="diagnosticsContent" class="space-y-3">
+                    <div class="text-center py-6 text-pm-secondary text-xs">
+                        Click "Run Diagnostics" to check the gallery system status
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+
     <!-- Maintenance Modal -->
     <div id="maintenanceModal" class="fixed inset-0 bg-black/60 backdrop-blur-[2px] hidden items-center justify-center z-50">
         <div class="bg-pm-surface rounded-pm-lg max-w-4xl w-full max-h-[90vh] overflow-hidden mx-4 border border-pm shadow-pm">
@@ -835,6 +864,130 @@
         <span class="inline-block w-1.5 h-1.5 rounded-full bg-pm-accent mr-1.5 align-middle animate-pulse"></span><span id="scanPillText" class="align-middle">Scanning...</span>
     </button>
 
+    <!-- Logs Modal -->
+    <div id="logsModal" class="fixed inset-0 bg-black/60 backdrop-blur-[2px] hidden items-center justify-center z-50">
+        <div class="bg-pm-surface rounded-pm-lg max-w-6xl w-full max-h-[90vh] overflow-hidden mx-4 border border-pm shadow-pm">
+            <div class="p-4 border-b border-pm">
+                <div class="flex items-center justify-between">
+                    <h3 class="text-sm font-semibold text-pm">System Logs</h3>
+                    <button onclick="window.admin.closeLogs()" class="p-1 rounded-pm-sm hover:bg-pm-hover transition-colors">
+                        <svg class="w-4 h-4 text-pm-secondary" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M6 18L18 6M6 6l12 12"></path>
+                        </svg>
+                    </button>
+                </div>
+            </div>
+
+            <!-- Log Controls -->
+            <div class="p-4 border-b border-pm">
+                <div class="grid grid-cols-1 md:grid-cols-5 gap-3 mb-3">
+                    <div>
+                        <label class="block text-xs font-medium text-pm-secondary mb-1">Log Level</label>
+                        <select id="logLevel" class="w-full px-2.5 py-1.5 bg-pm-input border border-pm rounded-pm-sm text-pm text-[13px] focus:outline-none">
+                            <option value="">All Levels</option>
+                            <option value="DEBUG">Debug</option>
+                            <option value="INFO">Info</option>
+                            <option value="WARNING">Warning</option>
+                            <option value="ERROR">Error</option>
+                            <option value="CRITICAL">Critical</option>
+                        </select>
+                    </div>
+                    <div>
+                        <label class="block text-xs font-medium text-pm-secondary mb-1">Limit</label>
+                        <select id="logLimit" class="w-full px-2.5 py-1.5 bg-pm-input border border-pm rounded-pm-sm text-pm text-[13px] focus:outline-none">
+                            <option value="50">Last 50</option>
+                            <option value="100" selected>Last 100</option>
+                            <option value="200">Last 200</option>
+                            <option value="500">Last 500</option>
+                        </select>
+                    </div>
+                    <div class="flex items-end">
+                        <button id="refreshLogsBtn" class="w-full px-2.5 py-1.5 bg-pm-accent hover:bg-pm-accent-hover text-pm-accent-fg text-xs font-medium rounded-pm-sm transition-colors">
+                            Refresh
+                        </button>
+                    </div>
+                    <div class="flex items-end">
+                        <button id="downloadLogsBtn" class="w-full px-2.5 py-1.5 bg-pm-surface border border-pm hover:bg-pm-hover text-pm text-xs font-medium rounded-pm-sm transition-colors">
+                            Download
+                        </button>
+                    </div>
+                    <div class="flex items-end">
+                        <button id="clearLogsBtn" class="w-full px-2.5 py-1.5 text-pm-error bg-transparent hover:bg-pm-error-tint border border-pm text-xs font-medium rounded-pm-sm transition-colors">
+                            Clear Logs
+                        </button>
+                    </div>
+                </div>
+
+                <!-- Log Stats -->
+                <div class="grid grid-cols-2 md:grid-cols-5 gap-3 mb-3">
+                    <div class="bg-pm-input rounded-pm-md p-2">
+                        <div class="text-[11px] text-pm-secondary">Total Logs</div>
+                        <div class="text-sm font-semibold text-pm-accent" id="logStatsTotal">-</div>
+                    </div>
+                    <div class="bg-pm-input rounded-pm-md p-2">
+                        <div class="text-[11px] text-pm-secondary">Errors</div>
+                        <div class="text-sm font-semibold text-pm-error" id="logStatsErrors">-</div>
+                    </div>
+                    <div class="bg-pm-input rounded-pm-md p-2">
+                        <div class="text-[11px] text-pm-secondary">Warnings</div>
+                        <div class="text-sm font-semibold text-pm-warning" id="logStatsWarnings">-</div>
+                    </div>
+                    <div class="bg-pm-input rounded-pm-md p-2">
+                        <div class="text-[11px] text-pm-secondary">Current Level</div>
+                        <div class="text-sm font-semibold text-pm-success" id="logStatsLevel">-</div>
+                    </div>
+                    <div class="bg-pm-input rounded-pm-md p-2">
+                        <div class="text-[11px] text-pm-secondary">Log Size</div>
+                        <div class="text-sm font-semibold text-pm" id="logStatsSize">-</div>
+                    </div>
+                </div>
+
+                <!-- Log Settings -->
+                <div class="grid grid-cols-1 md:grid-cols-3 gap-3">
+                    <div>
+                        <label class="block text-xs font-medium text-pm-secondary mb-1">Set Log Level</label>
+                        <select id="setLogLevel" class="w-full px-2.5 py-1.5 bg-pm-input border border-pm rounded-pm-sm text-pm text-[13px] focus:outline-none">
+                            <option value="DEBUG">Debug</option>
+                            <option value="INFO" selected>Info</option>
+                            <option value="WARNING">Warning</option>
+                            <option value="ERROR">Error</option>
+                            <option value="CRITICAL">Critical</option>
+                        </select>
+                    </div>
+                    <div class="flex items-center">
+                        <label class="flex items-center gap-1.5 text-pm">
+                            <input type="checkbox" id="consoleLogging" checked class="w-3.5 h-3.5 accent-[var(--pm-accent)]">
+                            <span class="text-xs">Console Logging</span>
+                        </label>
+                    </div>
+                    <div class="flex items-end">
+                        <button id="updateLogConfigBtn" class="w-full px-2.5 py-1.5 bg-pm-accent hover:bg-pm-accent-hover text-pm-accent-fg text-xs font-medium rounded-pm-sm transition-colors">
+                            Update Config
+                        </button>
+                    </div>
+                </div>
+            </div>
+
+            <!-- Log Viewer -->
+            <div class="flex-1 overflow-hidden">
+                <div class="h-96 overflow-y-auto bg-pm-primary font-mono text-xs">
+                    <div id="logsContainer" class="p-3 space-y-0.5">
+                        <div class="text-center py-6 text-pm-muted text-xs">
+                            Click "Refresh" to load logs
+                        </div>
+                    </div>
+                </div>
+            </div>
+
+            <!-- Log Files -->
+            <div class="p-4 border-t border-pm">
+                <h4 class="text-xs font-semibold text-pm-secondary uppercase tracking-wide mb-3">Log Files</h4>
+                <div id="logFilesList" class="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-2">
+                </div>
+            </div>
+        </div>
+    </div>
+
     <!-- Add Prompt Modal -->
     <div id="addPromptModal" class="fixed inset-0 bg-black/60 backdrop-blur-[2px] hidden items-center justify-center z-50">
         <div class="bg-pm-surface rounded-pm-lg p-4 max-w-2xl w-full mx-4 border border-pm max-h-[90vh] overflow-y-auto shadow-pm">

web/js/admin.js

@@ -47,6 +47,7 @@
                     edit: ({ promptId }) => this.editPrompt(promptId),
                     delete: ({ promptId }) => this.deletePrompt(promptId),
                     "open-film": ({ promptId, index }) => this.openFilmStripViewer(promptId, index),
+                    "download-log": ({ filename }) => this.downloadLogFile(filename),
                     "remove-review-tag": ({ index }) => this.removeReviewTag(index),
                     "pick-tag-suggestion": ({ tag }) => this.pickTagSuggestion(tag),
                 };
@@ -127,12 +128,14 @@
                 document.getElementById("exportBtn").addEventListener("click", () => this.exportPrompts());
                 document.getElementById("settingsBtn").addEventListener("click", () => this.showSettingsModal());
                 document.getElementById("statsBtn").addEventListener("click", () => this.showStats());
+                document.getElementById("diagnosticsBtn").addEventListener("click", () => this.showDiagnosticsModal());
                 document.getElementById("maintenanceBtn").addEventListener("click", () => this.showMaintenanceModal());
                 document.getElementById("backupBtn").addEventListener("click", () => this.backupDatabase());
                 document.getElementById("restoreBtn").addEventListener("click", () => this.showRestoreModal());
                 document.getElementById("scanBtn").addEventListener("click", () => this.showScanModal());
                 document.getElementById("autoTagBtn").addEventListener("click", () => this.showAutoTagModal());
                 document.getElementById("addPromptBtn").addEventListener("click", () => this.showAddPromptModal());
+                document.getElementById("logsBtn").addEventListener("click", () => this.showLogsModal());
                 document.getElementById("metadataBtn").addEventListener("click", () => this.openMetadataViewer());
                 document.getElementById("galleryBtn").addEventListener("click", () => this.openGallery());
 
@@ -212,6 +215,10 @@
                 document.getElementById("confirmRestore").addEventListener("click", () => this.confirmRestore());
                 document.getElementById("cancelRestore").addEventListener("click", () => this.hideModal("restoreModal"));
 
+                // Diagnostics modal
+                document.getElementById("runDiagnosticsBtn").addEventListener("click", () => this.runDiagnostics());
+                document.getElementById("testImageLinkBtn").addEventListener("click", () => this.testImageLink());
+
                 // Maintenance modal
                 document.getElementById("runMaintenanceBtn").addEventListener("click", () => this.runMaintenance());
                 document.getElementById("selectAllMaintenanceBtn").addEventListener("click", () => this.selectAllMaintenance());
@@ -223,6 +230,12 @@
                 document.getElementById("scanPill").addEventListener("click", () => this.showScanModal());
                 document.getElementById("quickBackupBtn").addEventListener("click", () => this.quickBackup());
 
+                // Logs modal
+                document.getElementById("refreshLogsBtn").addEventListener("click", () => this.refreshLogs());
+                document.getElementById("downloadLogsBtn").addEventListener("click", () => this.downloadLogs());
+                document.getElementById("clearLogsBtn").addEventListener("click", () => this.clearLogs());
+                document.getElementById("updateLogConfigBtn").addEventListener("click", () => this.updateLogConfig());
+
                 // Auto Tag modals
                 document.getElementById("startAutoTagBtn").addEventListener("click", () => this.startAutoTag());
                 document.getElementById("startReviewBtn").addEventListener("click", () => this.startReview());
@@ -1788,6 +1801,15 @@
                 return `${size.toFixed(1)} ${units[unitIndex]}`;
             }
 
+            // Diagnostics functionality
+            showDiagnosticsModal() {
+                this.showModal("diagnosticsModal");
+            }
+
+            closeDiagnostics() {
+                this.hideModal("diagnosticsModal");
+            }
+
             // Maintenance functionality
             showMaintenanceModal() {
                 this.showModal("maintenanceModal");
@@ -1959,6 +1981,160 @@
                 resultsContainer.innerHTML = html;
             }
 
+            async runDiagnostics() {
+                const content = document.getElementById("diagnosticsContent");
+                content.innerHTML = `
+                    <div class="text-center py-4">
+                        <div class="w-12 h-12 border-4 border-orange-500/30 border-t-orange-500 rounded-full animate-spin mx-auto mb-4"></div>
+                        <p class="text-pm-secondary">Running diagnostics...</p>
+                    </div>
+                `;
+
+                try {
+                    const response = await ApiClient.fetchUrl('/prompt_manager/diagnostics');
+                    if (response.ok) {
+                        const data = await response.json();
+                        if (data.success) {
+                            this.renderDiagnostics(data.diagnostics);
+                        } else {
+                            throw new Error(data.error || 'Diagnostics failed');
+                        }
+                    } else {
+                        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+                    }
+                } catch (error) {
+                    console.error('Diagnostics error:', error);
+                    content.innerHTML = `
+                        <div class="bg-pm-error-tint border border-pm-error rounded-pm-sm p-4">
+                            <h4 class="text-pm-error font-medium mb-2">❌ Diagnostics Failed</h4>
+                            <p class="text-pm-secondary">${escapeHtml(error.message)}</p>
+                        </div>
+                    `;
+                }
+            }
+
+            renderDiagnostics(diagnostics) {
+                const content = document.getElementById("diagnosticsContent");
+                
+                let html = '<div class="space-y-4">';
+                
+                // Summary
+                html += '<div class="bg-pm-surface rounded-pm-sm p-4">';
+                html += '<h4 class="text-pm font-medium mb-3">📋 Diagnostic Summary</h4>';
+                html += '<div class="grid grid-cols-1 md:grid-cols-2 gap-3">';
+
+                for (const [category, result] of Object.entries(diagnostics)) {
+                    const status = result.status === 'ok' ? '✅ PASS' : (result.status === 'warning' ? '⚠️ WARNING' : '❌ FAIL');
+                    const statusColor = result.status === 'ok' ? 'text-pm-success' : (result.status === 'warning' ? 'text-pm-warning' : 'text-pm-error');
+
+                    html += `
+                        <div class="flex justify-between items-center p-2 bg-pm-input rounded">
+                            <span class="text-pm-secondary capitalize">${escapeHtml(category)}</span>
+                            <span class="${statusColor} font-mono text-sm">${status}</span>
+                        </div>
+                    `;
+                }
+                
+                html += '</div></div>';
+                
+                // Detailed results
+                for (const [category, result] of Object.entries(diagnostics)) {
+                    const bgColor = result.status === 'ok' ? 'bg-pm-success-tint border-pm-success' :
+                                   (result.status === 'warning' ? 'bg-pm-warning/20 border-pm-warning' : 'bg-pm-error-tint border-pm-error');
+
+                    html += `<div class="${bgColor} border rounded-pm-sm p-4">`;
+                    html += `<h4 class="text-pm font-medium mb-2 capitalize">${escapeHtml(category)}</h4>`;
+
+                    if (result.message) {
+                        html += `<p class="text-pm-secondary mb-2">${escapeHtml(result.message)}</p>`;
+                    }
+
+                    // Show specific details based on category
+                    if (category === 'database' && result.status === 'ok') {
+                        html += `<div class="text-sm text-pm-secondary">`;
+                        html += `<p>Prompts: ${escapeHtml(result.prompt_count || 0)}</p>`;
+                        html += `<p>Images table: ${result.has_images_table ? 'Yes' : 'No'}</p>`;
+                        html += `</div>`;
+                    }
+
+                    if (category === 'images_table' && result.status === 'ok') {
+                        html += `<div class="text-sm text-pm-secondary">`;
+                        html += `<p>Images: ${escapeHtml(result.image_count || 0)}</p>`;
+                        if (result.recent_images && result.recent_images.length > 0) {
+                            html += `<p>Recent images:</p>`;
+                            html += `<ul class="ml-4 list-disc">`;
+                            result.recent_images.slice(0, 3).forEach(img => {
+                                html += `<li>${escapeHtml(img.filename)} → Prompt ${escapeHtml(img.prompt_id)}</li>`;
+                            });
+                            html += `</ul>`;
+                        }
+                        html += `</div>`;
+                    }
+
+                    if (category === 'comfyui_output' && result.output_dirs) {
+                        html += `<div class="text-sm text-pm-secondary">`;
+                        html += `<p>Output directories found:</p>`;
+                        html += `<ul class="ml-4 list-disc">`;
+                        result.output_dirs.forEach(dir => {
+                            html += `<li>${escapeHtml(dir)}</li>`;
+                        });
+                        html += `</ul>`;
+                        html += `</div>`;
+                    }
+
+                    if (category === 'dependencies' && result.dependencies) {
+                        html += `<div class="text-sm text-pm-secondary">`;
+                        for (const [dep, available] of Object.entries(result.dependencies)) {
+                            const status = available ? '✅' : '❌';
+                            html += `<p>${status} ${escapeHtml(dep)}</p>`;
+                        }
+                        html += `</div>`;
+                    }
+                    
+                    html += '</div>';
+                }
+                
+                html += '</div>';
+                content.innerHTML = html;
+            }
+
+            async testImageLink() {
+                if (this.prompts.length === 0) {
+                    this.showNotification('No prompts available for testing', 'warning');
+                    return;
+                }
+                
+                // Use the first prompt for testing
+                const testPrompt = this.prompts[0];
+                
+                try {
+                    const response = await ApiClient.fetchUrl('/prompt_manager/diagnostics/test-link', {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify({
+                            prompt_id: testPrompt.id,
+                            image_path: '/test/fake/image.png'
+                        })
+                    });
+                    
+                    if (response.ok) {
+                        const data = await response.json();
+                        if (data.success) {
+                            this.showNotification('✅ Test image link created successfully!', 'success');
+                            // Refresh the gallery to show the test image
+                            setTimeout(() => this.refreshList(), 1000);
+                        } else {
+                            throw new Error(data.result?.message || 'Test failed');
+                        }
+                    } else {
+                        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+                    }
+                } catch (error) {
+                    console.error('Test link error:', error);
+                    this.showNotification(`❌ Test failed: ${error.message}`, 'error');
+                }
+            }
+
             // Database backup and restore functionality
             async backupDatabase() {
                 try {
@@ -2321,6 +2497,273 @@
                 this.showNotification(`Scan failed: ${state.message}`, "error");
             }
 
+            // Logs functionality
+            showLogsModal() {
+                this.showModal("logsModal");
+                this.loadLogStats();
+                this.loadLogFiles();
+                this.loadLogConfig();
+            }
+
+            closeLogs() {
+                this.hideModal("logsModal");
+            }
+
+            async loadLogStats() {
+                try {
+                    const response = await ApiClient.fetchUrl('/prompt_manager/logs/stats');
+                    const data = await response.json();
+                    
+                    if (data.success) {
+                        const stats = data.stats;
+                        document.getElementById("logStatsTotal").textContent = stats.buffer_count || 0;
+                        document.getElementById("logStatsErrors").textContent = stats.level_counts?.ERROR || 0;
+                        document.getElementById("logStatsWarnings").textContent = stats.level_counts?.WARNING || 0;
+                        document.getElementById("logStatsLevel").textContent = stats.current_level || "INFO";
+                        document.getElementById("logStatsSize").textContent = this.formatBytes(stats.total_log_size || 0);
+                    }
+                } catch (error) {
+                    console.error("Failed to load log stats:", error);
+                }
+            }
+
+            async loadLogConfig() {
+                try {
+                    const response = await ApiClient.fetchUrl('/prompt_manager/logs/config');
+                    const data = await response.json();
+                    
+                    if (data.success) {
+                        const config = data.config;
+                        document.getElementById("setLogLevel").value = config.level || "INFO";
+                        document.getElementById("consoleLogging").checked = config.console_logging !== false;
+                    }
+                } catch (error) {
+                    console.error("Failed to load log config:", error);
+                }
+            }
+
+            async loadLogFiles() {
+                try {
+                    const response = await ApiClient.fetchUrl('/prompt_manager/logs/files');
+                    const data = await response.json();
+                    
+                    if (data.success) {
+                        const container = document.getElementById("logFilesList");
+                        
+                        if (data.files.length === 0) {
+                            container.innerHTML = '<div class="col-span-full text-center text-pm-muted">No log files found</div>';
+                            return;
+                        }
+                        
+                        container.innerHTML = data.files.map(file => `
+                            <div class="bg-pm-surface rounded-pm-sm p-3">
+                                <div class="flex items-center justify-between mb-2">
+                                    <span class="text-sm font-medium text-pm">${escapeHtml(file.filename)}</span>
+                                    ${file.is_main ? '<span class="bg-pm-accent text-xs px-2 py-1 rounded">Active</span>' : ''}
+                                </div>
+                                <div class="text-xs text-pm-secondary mb-2">
+                                    Size: ${this.formatBytes(file.size)} | Modified: ${new Date(file.modified).toLocaleString()}
+                                </div>
+                                <button data-action="download-log" data-filename="${escapeHtml(file.filename)}"
+                                        class="w-full px-3 py-1 bg-pm-success hover:bg-pm-success text-pm text-xs rounded transition-colors">
+                                    📥 Download
+                                </button>
+                            </div>
+                        `).join('');
+                    }
+                } catch (error) {
+                    console.error("Failed to load log files:", error);
+                }
+            }
+
+            async refreshLogs() {
+                const level = document.getElementById("logLevel").value;
+                const limit = parseInt(document.getElementById("logLimit").value);
+                
+                try {
+                    const url = new URL(ApiClient.resolveUrl('/prompt_manager/logs'), window.location.origin);
+                    if (level) url.searchParams.set('level', level);
+                    url.searchParams.set('limit', limit.toString());
+                    
+                    const response = await ApiClient.fetchUrl(url);
+                    const data = await response.json();
+                    
+                    if (data.success) {
+                        this.displayLogs(data.logs);
+                        this.showNotification(`Loaded ${data.logs.length} log entries`, "success");
+                    } else {
+                        this.showNotification(`Failed to load logs: ${data.error}`, "error");
+                    }
+                } catch (error) {
+                    console.error("Failed to refresh logs:", error);
+                    this.showNotification("Failed to refresh logs", "error");
+                }
+            }
+
+            displayLogs(logs) {
+                const container = document.getElementById("logsContainer");
+                
+                if (logs.length === 0) {
+                    container.innerHTML = '<div class="text-center py-4 text-pm-muted">No logs found</div>';
+                    return;
+                }
+
+                container.innerHTML = logs.map(log => {
+                    const levelColors = {
+                        DEBUG: 'text-pm-secondary',
+                        INFO: 'text-pm-accent',
+                        WARNING: 'text-pm-warning',
+                        ERROR: 'text-pm-error',
+                        CRITICAL: 'text-pm-error'
+                    };
+
+                    const levelColor = levelColors[log.level] || 'text-pm-secondary';
+                    const timestamp = new Date(log.timestamp).toLocaleString();
+
+                    return `
+                        <div class="border-l-2 border-pm pl-3 py-1 hover:bg-pm-surface transition-colors">
+                            <div class="flex items-start space-x-2 text-sm">
+                                <span class="text-pm-muted text-xs font-mono w-24 flex-shrink-0">${escapeHtml(timestamp.split(' ')[1])}</span>
+                                <span class="${levelColor} font-semibold w-16 flex-shrink-0">${escapeHtml(log.level)}</span>
+                                <span class="text-pm-accent text-xs w-32 flex-shrink-0">${escapeHtml(log.logger)}</span>
+                                <span class="text-pm-secondary flex-1">${escapeHtml(log.message)}</span>
+                            </div>
+                            <div class="text-xs text-pm-muted ml-44">
+                                ${escapeHtml(log.filename)}:${escapeHtml(log.lineno)}
+                            </div>
+                        </div>
+                    `;
+                }).join('');
+                
+                // Auto-scroll to bottom
+                container.scrollTop = container.scrollHeight;
+            }
+
+            async downloadLogs() {
+                const level = document.getElementById("logLevel").value;
+                const limit = parseInt(document.getElementById("logLimit").value);
+                
+                try {
+                    const url = new URL(ApiClient.resolveUrl('/prompt_manager/logs'), window.location.origin);
+                    if (level) url.searchParams.set('level', level);
+                    url.searchParams.set('limit', limit.toString());
+                    
+                    const response = await ApiClient.fetchUrl(url);
+                    const data = await response.json();
+                    
+                    if (data.success) {
+                        const logText = data.logs.map(log => 
+                            `${log.timestamp} [${log.level}] ${log.logger}: ${log.message} (${log.filename}:${log.lineno})`
+                        ).join('\n');
+                        
+                        const blob = new Blob([logText], { type: 'text/plain' });
+                        const url2 = URL.createObjectURL(blob);
+                        const a = document.createElement('a');
+                        a.href = url2;
+                        a.download = `prompt_manager_logs_${new Date().toISOString().slice(0, 19).replace(/:/g, '-')}.txt`;
+                        document.body.appendChild(a);
+                        a.click();
+                        document.body.removeChild(a);
+                        URL.revokeObjectURL(url2);
+                        
+                        this.showNotification("Logs downloaded successfully", "success");
+                    } else {
+                        this.showNotification(`Failed to download logs: ${data.error}`, "error");
+                    }
+                } catch (error) {
+                    console.error("Failed to download logs:", error);
+                    this.showNotification("Failed to download logs", "error");
+                }
+            }
+
+            async downloadLogFile(filename) {
+                try {
+                    const response = await ApiClient.fetchUrl(`/prompt_manager/logs/download/${encodeURIComponent(filename)}`);
+                    
+                    if (response.ok) {
+                        const blob = await response.blob();
+                        const url = URL.createObjectURL(blob);
+                        const a = document.createElement('a');
+                        a.href = url;
+                        a.download = filename;
+                        document.body.appendChild(a);
+                        a.click();
+                        document.body.removeChild(a);
+                        URL.revokeObjectURL(url);
+                        
+                        this.showNotification(`Downloaded ${filename}`, "success");
+                    } else {
+                        this.showNotification(`Failed to download ${filename}`, "error");
+                    }
+                } catch (error) {
+                    console.error("Failed to download log file:", error);
+                    this.showNotification("Failed to download log file", "error");
+                }
+            }
+
+            async clearLogs() {
+                if (!confirm("Are you sure you want to clear all log files? This cannot be undone.")) {
+                    return;
+                }
+                
+                try {
+                    const response = await ApiClient.fetchUrl('/prompt_manager/logs/truncate', {
+                        method: 'POST'
+                    });
+                    const data = await response.json();
+                    
+                    if (data.success) {
+                        this.showNotification(data.message, "success");
+                        this.refreshLogs();
+                        this.loadLogStats();
+                        this.loadLogFiles();
+                    } else {
+                        this.showNotification(`Failed to clear logs: ${data.error}`, "error");
+                    }
+                } catch (error) {
+                    console.error("Failed to clear logs:", error);
+                    this.showNotification("Failed to clear logs", "error");
+                }
+            }
+
+            async updateLogConfig() {
+                const level = document.getElementById("setLogLevel").value;
+                const consoleLogging = document.getElementById("consoleLogging").checked;
+                
+                try {
+                    const response = await ApiClient.fetchUrl('/prompt_manager/logs/config', {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json'
+                        },
+                        body: JSON.stringify({
+                            level: level,
+                            console_logging: consoleLogging
+                        })
+                    });
+                    
+                    const data = await response.json();
+                    
+                    if (data.success) {
+                        this.showNotification("Log configuration updated", "success");
+                        this.loadLogStats();
+                    } else {
+                        this.showNotification(`Failed to update config: ${data.error}`, "error");
+                    }
+                } catch (error) {
+                    console.error("Failed to update log config:", error);
+                    this.showNotification("Failed to update log configuration", "error");
+                }
+            }
+
+            formatBytes(bytes) {
+                if (bytes === 0) return '0 B';
+                const k = 1024;
+                const sizes = ['B', 'KB', 'MB', 'GB'];
+                const i = Math.floor(Math.log(bytes) / Math.log(k));
+                return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + ' ' + sizes[i];
+            }
+
             // Pagination methods
             updatePaginationControls() {
                 const { currentPage, totalPages, total, limit } = this.pagination;

web/js/workspace/images-multiselect.mjs

@@ -1,80 +0,0 @@
-/**
- * File-manager selection on the Images page (#392, D135): pure helpers for the selection bar (images-selection.mjs).
- * Keys are image keys (`root_index:path`) in the listing's display order, so a range spans every loaded batch
- * whether or not its cards are mounted.
- */
-
-/** The press that turns on touch selection mode, and how far it may drift before it counts as a scroll. */
-export const LONG_PRESS_MS = 500;
-export const LONG_PRESS_SLOP = 10;
-
-/**
- * The keys from `from` to `to`, inclusive, in `keys` order (either direction). Without a listed `from` (no anchor
- * yet, or it left the listing) the range is `to` alone; an unlisted `to` gives none.
- */
-export function rangeKeys(keys, from, to) {
-    const end = keys.indexOf(to);
-    if (end < 0) return [];
-    const start = from === null || from === undefined ? -1 : keys.indexOf(from);
-    if (start < 0) return [to];
-    return keys.slice(Math.min(start, end), Math.max(start, end) + 1);
-}
-
-/** `selected` with `keys` added (`on`) or removed, frozen; the same set when nothing changes. */
-export function applyKeys(selected, keys, on) {
-    if (keys.every(key => selected.has(key) === on)) return selected;
-    const next = new Set(selected);
-    for (const key of keys) {
-        if (on) next.add(key); else next.delete(key);
-    }
-    return Object.freeze(next);
-}
-
-/** Whether `keys` is non-empty and every one of them is in `selected`. */
-export function everyChecked(selected, keys) {
-    return keys.length > 0 && selected.size >= keys.length && keys.every(key => selected.has(key));
-}
-
-/** "Select all N matching" shows once every loaded image is checked and the listing holds more than is loaded. */
-export function offersAllMatching(selected, keys, { total, hasMore }) {
-    return Boolean(hasMore) && total > keys.length && everyChecked(selected, keys);
-}
-
-const grouped = count => count.toLocaleString('en-US');
-export const matchingLabel = total => `All ${grouped(total)} matching selected`;
-export const matchingOffer = total => `Select all ${grouped(total)} matching`;
-
-/**
- * A touch long-press: `down` starts the timer, a `move` past the slop, `up` or `cancel` stops it, and
- * `onLongPress(target)` runs once it fires. `consumeClick()` answers whether the click the press ends in belongs to
- * the long press (so the page swallows it); it answers once. A new `down` forgets an unclaimed long press.
- */
-export function createLongPress({ onLongPress, delay = LONG_PRESS_MS, slop = LONG_PRESS_SLOP,
-    setTimer = setTimeout, clearTimer = clearTimeout }) {
-    let timer = null, origin = null, fired = false;
-    const stop = () => {
-        if (timer !== null) clearTimer(timer);
-        timer = null; origin = null;
-    };
-    return {
-        down(x, y, target) {
-            stop();
-            fired = false;
-            origin = { x, y };
-            timer = setTimer(() => { timer = null; origin = null; fired = true; onLongPress(target); }, delay);
-        },
-        move(x, y) {
-            if (origin && Math.hypot(x - origin.x, y - origin.y) > slop) stop();
-        },
-        up: stop,
-        /** A press that ends without its click (a mouse press next, a scroll): its long press is forgotten too. */
-        cancel() { stop(); fired = false; },
-        /** Whether a touch press is held and has not yet fired (its context menu belongs to the long press). */
-        pending: () => timer !== null,
-        consumeClick() {
-            const claimed = fired;
-            fired = false;
-            return claimed;
-        },
-    };
-}

web/js/workspace/images-selection.mjs

@@ -4,16 +4,11 @@ import { inspectPath, toInspectionRecord } from './inspection-state.mjs';
 import { BUNDLE_FILENAME, metadataBundle, collectImagesMetadata, exportOutcome } from './images-export.mjs';
 import { CATEGORY_DIALOG, CATEGORY_FAILED, CATEGORY_MAX_LENGTH, CATEGORY_NONE_LINKED, categoryOutcome, categoryTargets, updatedCount } from './images-category.mjs';
 import { openInputDialog } from './workspace-dialogs.mjs';
-import { MAX_FILTER_IMAGES, TOO_MANY_MATCHING, openAddTags, openAutoTag } from './images-tagging-bulk.mjs';
+import { openAddTags, openAutoTag } from './images-tagging-bulk.mjs';
 import { showWorkspaceToast } from './toast.mjs';
-import { applyKeys, createLongPress, matchingLabel, matchingOffer, offersAllMatching, rangeKeys } from './images-multiselect.mjs';
 
 const CHECKBOX = '.image-overlays input[type="checkbox"]';
-const CHECKBOX_LABEL = '.image-overlays > label';
-const CARD = 'article[data-image-key]';
 const CATEGORY_URL = '/prompt_manager/bulk/category';
-// D135: Export metadata reads every image's inspection in the browser, so it waits for loaded images.
-export const EXPORT_LOADED_ONLY = 'Export metadata reads each image in the browser, so it works on loaded images only.';
 
 function el(tag, text, className) {
     const element = document.createElement(tag);
@@ -34,196 +29,60 @@ function el(tag, text, className) {
  * - `retain(kept)` drops the checked files a refreshed listing no longer holds (a tag save under a filter, I7).
  * - With the Activity store `activity`, Add tags and Auto-tag selected (D85) follow the count, as the concept's Add tags
  *   leads its actions; `onTagged(keys)` re-reads the files a finished tagging job tagged. The selection stays.
- *
- * File-manager selection (#392, D135, beyond the concept's checkbox): the anchor is the last image toggled on its own;
- * Shift+click (a checkbox or anywhere on a card) applies the anchor's range, Ctrl/Cmd+click toggles a card without
- * opening it, a touch long-press starts touch selection mode in which taps toggle. `selectAll`, `extend` and
- * `clear` serve the grid's keys (images.mjs). `getListing()` gives `{total, hasMore, positiveCount}` and
- * `getFilter()` the listing filter: once every loaded image is checked and more match, the bar offers "Select all N
- * matching", whose actions send that filter to the server.
  */
 export function mountSelectionBar({ scope, api, grid, getItems, focusFallback, onCategorySet, activity = null, onTagged,
-    getListing, getFilter, checked: initial = Object.freeze(new Set()) }) {
+    checked: initial = Object.freeze(new Set()) }) {
     let checked = initial;
     let exporting = false, categorizing = false;
-    // D135: the range anchor, "all N matching" mode, touch selection mode and a pending Shift+click on a checkbox.
-    let anchor = null, allMatching = false, touchMode = false, lastPointer = 'mouse', shiftBox = null;
     const element = el('div');
     element.id = 'bulkbar';
     const bulk = el('div', undefined, 'bulkbar'), count = el('strong');
-    const selectMatching = createButton('');
-    scope.listen(selectMatching, 'click', () => {
-        allMatching = true;
-        render();
-        focusAfterOffer();
-    });
     const setCategory = createButton('Set category');
     scope.listen(setCategory, 'click', () => openCategory(setCategory));
     const exportMetadata = createButton('Export metadata');
-    scope.listen(exportMetadata, 'click', () => { if (!allMatching) exportChecked(exportMetadata); });
+    scope.listen(exportMetadata, 'click', () => exportChecked(exportMetadata));
     const clearButton = createButton('Clear');
     // Clear hides the bar it sits in, so focus moves to the page heading instead of falling to the page.
     scope.listen(clearButton, 'click', () => { clear(); focusFallback.focus({ preventScroll: true }); });
     bulk.append(count);
     if (activity) {
         const addTags = createButton('Add tags');
-        scope.listen(addTags, 'click', () => openAddTags({ scope, store: activity, images: checkedImages(), trigger: addTags, onTagged,
-            ...matchingTarget() }));
+        scope.listen(addTags, 'click', () => openAddTags({ scope, store: activity, images: checkedImages(), trigger: addTags, onTagged }));
         const autoTag = createButton('Auto-tag selected'); // D85
-        scope.listen(autoTag, 'click', () => openAutoTag({ api, scope, store: activity, images: checkedImages(), trigger: autoTag, onTagged,
-            ...matchingTarget() }));
+        scope.listen(autoTag, 'click', () => openAutoTag({ api, scope, store: activity, images: checkedImages(), trigger: autoTag, onTagged }));
         bulk.append(addTags, autoTag);
     }
     bulk.append(setCategory, exportMetadata, clearButton);
 
     /** The count updates in place: the same bar and `strong`, its text written only when it changes. */
     function render() {
-        if (!checked.size && !allMatching) { touchMode = false; bulk.remove(); return; }
-        const listing = getListing();
-        const label = allMatching ? matchingLabel(listing.total) : selectionLabel(checked.size);
+        if (!checked.size) { bulk.remove(); return; }
+        const label = selectionLabel(checked.size);
         if (count.textContent !== label) count.textContent = label;
-        // "Select all N matching" (D135) follows the count while every loaded image is checked and more match.
-        if (!allMatching && offersAllMatching(checked, loadedKeys(), listing)) {
-            const offer = matchingOffer(listing.total);
-            if (selectMatching.textContent !== offer) selectMatching.textContent = offer;
-            if (count.nextElementSibling !== selectMatching) count.after(selectMatching);
-        } else selectMatching.remove();
-        if (allMatching) {
-            exportMetadata.setAttribute('aria-disabled', 'true');
-            exportMetadata.title = EXPORT_LOADED_ONLY;
-        } else if (exportMetadata.title) {
-            exportMetadata.removeAttribute('title');
-            if (!exporting) exportMetadata.removeAttribute('aria-disabled');
-        }
         if (bulk.parentNode !== element) element.append(bulk);
     }
-    /** Every rendered checkbox shows the selection (cards mounted later read `isChecked`). */
-    function paint() {
-        for (const box of grid.querySelectorAll(CHECKBOX)) {
-            const on = isChecked(box.closest(CARD).dataset.imageKey);
-            if (box.checked !== on) box.checked = on;
-        }
-    }
-    function update(next) {
-        checked = next;
-        paint();
-        render();
-    }
-    /** Leaving "all N matching": the loaded images become the explicit selection the next change applies to. */
-    function settleMatching() {
-        if (!allMatching) return;
-        allMatching = false;
-        checked = Object.freeze(new Set(loadedKeys()));
-    }
     function clear() {
-        anchor = null; touchMode = false;
-        if (!checked.size && !allMatching) return;
-        allMatching = false;
-        update(Object.freeze(new Set()));
+        if (!checked.size) return;
+        checked = Object.freeze(new Set());
+        for (const box of grid.querySelectorAll(CHECKBOX)) box.checked = false;
+        render();
     }
     /** Keep only the checked files `kept(key)` still lists (a refreshed result), so the count is what the actions apply to. */
     function retain(kept) {
-        if (allMatching) { render(); return; }
         const next = [...checked].filter(kept);
         if (next.length === checked.size) return;
         checked = Object.freeze(new Set(next));
         render();
     }
-    function loadedKeys() {
-        return getItems().map(imageKey);
-    }
-    function isChecked(key) {
-        return allMatching || checked.has(key);
-    }
     function checkedImages() {
-        return allMatching ? getItems() : getItems().filter(image => checked.has(imageKey(image)));
-    }
-    /** The actions' images for "all N matching": the listing filter and its total, which the server resolves. */
-    function matchingTarget() {
-        return allMatching ? { filter: getFilter(), count: getListing().total } : {};
-    }
-    /** Toggle one image on its own; it becomes the anchor. */
-    function toggle(key, on = !isChecked(key)) {
-        settleMatching();
-        anchor = key;
-        update(toggleSelection(checked, key, on));
-    }
-    /** The anchor's range to `key` takes `on`; without an anchor `key` is toggled on and becomes it. */
-    function range(key, on = true) {
-        settleMatching();
-        const keys = rangeKeys(loadedKeys(), anchor, key);
-        if (anchor === null || keys.length === 1) anchor = key;
-        update(applyKeys(checked, keys, on));
-    }
-    /** Shift+arrow keys: the range from the anchor (`from`, the card focus left, when there is none) to `to`. */
-    function extend(from, to) {
-        if (anchor === null || !loadedKeys().includes(anchor)) anchor = from;
-        range(to, true);
-    }
-    function selectAll() {
-        if (allMatching) return;
-        update(applyKeys(checked, loadedKeys(), true));
-    }
-    function focusAfterOffer() {
-        // The pressed offer left the bar: focus moves to the count's first action instead of the page.
-        (bulk.querySelector('button:not([aria-disabled="true"])') ?? focusFallback).focus({ preventScroll: true });
+        return getItems().filter(image => checked.has(imageKey(image)));
     }
     // Every card carries its image key; its only form control is the checkbox, so a toggle never opens or inspects.
     scope.listen(grid, 'change', event => {
         const box = event.target;
         if (!box.matches(CHECKBOX)) return;
-        const key = box.closest(CARD).dataset.imageKey;
-        if (shiftBox === key) range(key, box.checked);
-        else toggle(key, box.checked);
-        shiftBox = null;
-    });
-    // D135: modified clicks select instead of opening, inspecting or starring. Captured, so the page's own click
-    // handler (images.mjs) never sees them; a plain click keeps its meaning.
-    grid.addEventListener('click', event => {
-        const card = event.target.closest(CARD);
-        if (!card) return;
-        const key = card.dataset.imageKey;
-        if (longPress.consumeClick()) { swallow(event); return; }
-        if (event.target.closest(CHECKBOX_LABEL)) {
-            // The box toggles natively; its change event applies the range.
-            if (event.shiftKey) shiftBox = key;
-            return;
-        }
-        // A keyboard click (Enter, Space: `detail` 0) keeps its plain meaning in touch selection mode.
-        const tapped = touchMode && lastPointer !== 'mouse' && event.detail !== 0;
-        if (event.shiftKey) { swallow(event); range(key, true); }
-        else if (event.ctrlKey || event.metaKey || tapped) { swallow(event); toggle(key); }
-    }, { capture: true, signal: scope.signal });
-    function swallow(event) {
-        event.preventDefault();
-        event.stopPropagation();
-    }
-    // A touch long-press selects the card and starts touch selection mode (D135).
-    const longPress = createLongPress({ onLongPress: key => {
-        touchMode = true;
-        anchor = key;
-        if (!isChecked(key)) toggle(key, true);
-    } });
-    scope.cleanup(() => longPress.cancel());
-    scope.listen(grid, 'pointerdown', event => {
-        lastPointer = event.pointerType || 'mouse';
-        shiftBox = null;
-        const card = event.target.closest(CARD);
-        if (lastPointer === 'mouse' || !card || !event.isPrimary) { longPress.cancel(); return; }
-        longPress.down(event.clientX, event.clientY, card.dataset.imageKey);
-    });
-    scope.listen(grid, 'pointermove', event => longPress.move(event.clientX, event.clientY));
-    for (const type of ['pointerup', 'pointercancel', 'pointerleave']) scope.listen(grid, type, () => longPress.up());
-    // A long-press's context menu (Android) would cover the selection it just started.
-    scope.listen(grid, 'contextmenu', event => {
-        if (lastPointer !== 'mouse' && (touchMode || longPress.pending())) event.preventDefault();
-    });
-    // Escape in the bar clears the selection; the bar hides, so focus moves to the page heading as after Clear.
-    scope.listen(element, 'keydown', event => {
-        if (event.key !== 'Escape' || (!checked.size && !allMatching)) return;
-        event.preventDefault();
-        clear();
-        focusFallback.focus({ preventScroll: true });
+        checked = toggleSelection(checked, box.closest('article[data-image-key]').dataset.imageKey, box.checked);
+        render();
     });
 
     /** Busy until it settles: `aria-disabled` now, released in a `finally` so a throw cannot leave it stuck. */
@@ -267,11 +126,8 @@ export function mountSelectionBar({ scope, api, grid, getItems, focusFallback, o
      */
     function openCategory(button) {
         if (categorizing) return;
-        // All matching (D135): the listing's positive count says whether any match is linked; the server resolves.
-        if (allMatching && getListing().total > MAX_FILTER_IMAGES) { showWorkspaceToast(TOO_MANY_MATCHING); return; }
-        const targets = allMatching ? {filter: getFilter()} : categoryTargets(checkedImages());
-        const linked = allMatching ? getListing().positiveCount !== 0 : targets.promptIds.length > 0;
-        if (!linked) { showWorkspaceToast(CATEGORY_NONE_LINKED); return; }
+        const targets = categoryTargets(checkedImages());
+        if (!targets.promptIds.length) { showWorkspaceToast(CATEGORY_NONE_LINKED); return; }
         openInputDialog({ scope, trigger: button, title: CATEGORY_DIALOG.title, label: CATEGORY_DIALOG.label,
             action: CATEGORY_DIALOG.action, maxLength: CATEGORY_MAX_LENGTH, onApply: category => applyCategory(button, targets, category) });
     }
@@ -279,12 +135,12 @@ export function mountSelectionBar({ scope, api, grid, getItems, focusFallback, o
      * The write carries no page signal: once sent it finishes even if the page is left (`writing` then tells the page
      * not to save a visit that predates it). A failure keeps the selection; a success reloads through `onCategorySet`.
      */
-    async function applyCategory(button, { promptIds, skipped, filter }, category) {
+    async function applyCategory(button, { promptIds, skipped }, category) {
         categorizing = true;
         const release = busy(button);
         let result = null;
         try {
-            result = await api.post(CATEGORY_URL, filter ? { images_filter: filter, category } : { prompt_ids: promptIds, category });
+            result = await api.post(CATEGORY_URL, { prompt_ids: promptIds, category });
         } catch {
             // Reported below; the selection stays as it was.
         } finally {
@@ -293,9 +149,7 @@ export function mountSelectionBar({ scope, api, grid, getItems, focusFallback, o
         }
         if (scope.signal.aborted) return;
         if (!result) { showWorkspaceToast(CATEGORY_FAILED); return; }
-        if (filter && !result.prompt_count) { showWorkspaceToast(CATEGORY_NONE_LINKED); return; }
-        showWorkspaceToast(filter ? categoryOutcome(updatedCount(result, result.prompt_count), Number(result.skipped) || 0)
-            : categoryOutcome(updatedCount(result, promptIds.length), skipped));
+        showWorkspaceToast(categoryOutcome(updatedCount(result, promptIds.length), skipped));
         const focused = document.activeElement === button;
         onCategorySet();
         // The reload hides the bar with the focused action in it, as Clear does: focus moves to the page heading.
@@ -305,16 +159,10 @@ export function mountSelectionBar({ scope, api, grid, getItems, focusFallback, o
     render();
     return {
         element,
-        isChecked,
-        // A saved visit keeps "all N matching" as its loaded images; the offer then shows again.
-        checked: () => (allMatching ? Object.freeze(new Set(loadedKeys())) : checked),
-        hasSelection: () => allMatching || checked.size > 0,
+        isChecked: key => checked.has(key),
+        checked: () => checked,
         clear,
         retain,
-        selectAll,
-        extend,
-        /** A loaded batch or a refreshed total: the count and the offer follow it. */
-        listingChanged: () => { if (checked.size || allMatching) render(); },
         /** Whether a Set category write is still in flight. */
         writing: () => categorizing,
     };

web/js/workspace/images-state.mjs

@@ -56,16 +56,6 @@ function queryFor(filters, batchSize) {
     return query.toString();
 }
 
-/**
- * The listing's filter as the bulk routes take it (#392 "Select all N matching"): the same parameters the listing
- * query carries, as an object of strings, without `mode`, `limit` and `cursor`.
- */
-export function listingFilter(filters) {
-    const query = new URLSearchParams(queryFor(filters, 1));
-    query.delete('mode'); query.delete('limit');
-    return Object.fromEntries(query);
-}
-
 function validatePage(page, cursor) {
     if (!page || !Array.isArray(page.images) || !Number.isSafeInteger(page.total) || page.total < 0 ||
         typeof page.has_more !== 'boolean' ||

web/js/workspace/images-tagging-bulk.mjs

@@ -9,10 +9,6 @@
  *   apply** (D90, ruling T3-bulk): **Apply automatically** starts the job, **Review each image** starts the browser
  *   review session (images-tagging-review.mjs). A model that is not downloaded keeps Start disabled and says why.
  *
- * - **All N matching** (#392, D135): with `filter` (the listing's, images-state.mjs `listingFilter`) and `count` (its
- *   total), both send the filter instead of the targets and the server resolves it, up to 10,000 images. Review each
- *   image walks images in the browser, so it is not offered.
- *
  * The toast says the job started (the Activity store's "Tagging started." / "Auto-tagging started."), or why it did
  * not: a running record-changing job (named, with its link), a held model, a refused body. Activity shows progress.
  * The selection stays either way. When a started job ends having tagged files, `onTagged(keys)` re-reads them.
@@ -30,9 +26,6 @@ import { showWorkspaceToast } from './toast.mjs';
 export const IMAGE_TAG_JOB = 'image-tags';
 export const MAX_BULK_IMAGES = 500;
 export const TOO_MANY = 'Select at most 500 images.';
-// #392: a filter start resolves on the server (py/api/images.py MAX_LISTING_SELECTION).
-export const MAX_FILTER_IMAGES = 10000;
-export const TOO_MANY_MATCHING = 'Narrow the view to at most 10,000 images.';
 export const NO_TAGS = 'Enter at least one tag.'; // D118
 export const ADD_DIALOG = Object.freeze({title: 'Tag selected images', label: 'Tags, separated by commas', action: 'Apply'});
 export const AUTO_TITLE = 'Auto-tag selected images';
@@ -60,16 +53,6 @@ export function bulkTargets(images) {
     return images.map(imageTarget).filter(Boolean);
 }
 
-/**
- * The job body's images: `{filter}` for all matching (null over MAX_FILTER_IMAGES), else `{targets}` (null over 500).
- * Returns `[images, refusal]`, the refusal being the toast to show.
- */
-function jobImages(images, filter, count) {
-    if (filter) return count > MAX_FILTER_IMAGES ? [null, TOO_MANY_MATCHING] : [{filter}, null];
-    const targets = bulkTargets(images);
-    return targets ? [{targets}, null] : [null, TOO_MANY];
-}
-
 /** The Add tags field's names, deduplicated as the Tag image dialog's manual field is. */
 export const parseBulkTags = parseManualTags;
 
@@ -124,13 +107,13 @@ function followTagged({store, scope, job, images, onTagged}) {
  * to no names keeps the dialog and its text, and reports NO_TAGS on the field (D118). `openInput` is the dialog seam.
  */
 export function openAddTags({scope, store, images, trigger, onTagged = () => {}, notify = showWorkspaceToast,
-    openInput = openInputDialog, filter = null, count = images.length}) {
-    const [chosen, refusal] = jobImages(images, filter, count);
-    if (refusal) { notify(refusal); return; }
+    openInput = openInputDialog}) {
+    const targets = bulkTargets(images);
+    if (!targets) { notify(TOO_MANY); return; }
     openInput({scope, trigger, ...ADD_DIALOG, validate: text => (parseBulkTags(text).length ? null : NO_TAGS),
         onApply: async text => {
         const tags = parseBulkTags(text);
-        const job = await startTagJob({store, scope, body: {mode: 'add', ...chosen, tags}, notify});
+        const job = await startTagJob({store, scope, body: {mode: 'add', targets, tags}, notify});
         if (job) followTagged({store, scope, job, images, onTagged});
     }});
 }
@@ -158,16 +141,15 @@ function applyChoice(onChange) {
  * Auto-tag selected (D85): the model panel, How to apply (D90), Cancel and Start. Start validates the fields as
  * Generate does, then starts the job or the review session over `images` (the checked files, taken now).
  */
-export function openAutoTag({api, scope, store, images, trigger, onTagged = () => {}, notify = showWorkspaceToast,
-    filter = null, count = images.length}) {
-    const [chosen, refusal] = jobImages(images, filter, count);
-    if (refusal) { notify(refusal); return; }
+export function openAutoTag({api, scope, store, images, trigger, onTagged = () => {}, notify = showWorkspaceToast}) {
+    const targets = bulkTargets(images);
+    if (!targets) { notify(TOO_MANY); return; }
     const listed = images.filter(imageTarget);
     const local = createScope();
     const options = createTaggingOptionsController({api});
     // D85: the Tag image dialog's model panel without Generate; its Suggestions field is the job's count (D91).
     const {element: panel, validate} = renderModelPanel({scope: local, controller: options,
-        heading: `Auto-tag ${countOf(filter ? count : listed.length, 'image')}`, generate: false}); // D118
+        heading: `Auto-tag ${countOf(listed.length, 'image')}`, generate: false}); // D118
     let choice = APPLY_CHOICES[0];
     const actions = el('div', undefined, 'dialog-actions');
     const cancel = createButton('Cancel');
@@ -177,8 +159,7 @@ export function openAutoTag({api, scope, store, images, trigger, onTagged = () =
     const status = el('div', undefined, 'small');
     status.id = 'tag-generation-status';
     status.setAttribute('role', 'status');
-    // D90; all matching (D135) has no Review each image, which walks images in the browser.
-    const choices = filter ? null : applyChoice(next => { choice = next; start.textContent = next.action; });
+    const choices = applyChoice(next => { choice = next; start.textContent = next.action; }); // D90
     const render = state => {
         if (status.textContent !== state.unavailable) status.textContent = state.unavailable;
         if (state.canStart) start.removeAttribute('aria-disabled');
@@ -197,11 +178,11 @@ export function openAutoTag({api, scope, store, images, trigger, onTagged = () =
             return;
         }
         closeWorkspaceDialog();
-        startTagJob({store, scope, body: {mode: 'auto', ...chosen, ...request}, notify}).then(job => {
+        startTagJob({store, scope, body: {mode: 'auto', targets, ...request}, notify}).then(job => {
             if (job) followTagged({store, scope, job, images: listed, onTagged});
         });
     });
-    openContentDialog({scope, title: AUTO_TITLE, nodes: [panel, choices, status, actions].filter(Boolean), trigger, onClose: () => {
+    openContentDialog({scope, title: AUTO_TITLE, nodes: [panel, choices, status, actions], trigger, onClose: () => {
         document.getElementById('modal')?.classList.remove('tagging-modal');
         local.dispose();
         options.dispose();

web/js/workspace/images.mjs

@@ -1,5 +1,5 @@
 import { createScope, createButton } from '../shared/toolkit/core.js';
-import { createImageStream, withItem, imageKey, countLine, captionDate, scopeLabel, activeRefinements, initialImagesView, listingFilter } from './images-state.mjs';
+import { createImageStream, withItem, imageKey, countLine, captionDate, scopeLabel, activeRefinements, initialImagesView } from './images-state.mjs';
 import { createImageCard } from './image-card.mjs';
 import { layoutImages, visibleImages, gridMetrics, stacksCardInfo } from './image-layout.mjs';
 import { mountFileInspector } from './file-inspector.mjs';
@@ -254,15 +254,8 @@ export function mountImages(main, api, parentScope, {embedded = false, fetchPage
     body.append(collection, details);
     // The checked cards and the concept's selection bar (#249 D8), between the filter row and the gallery layout. The
     // selection is kept across appended batches and cleared with the collection; the Library-embedded gallery has none.
-    const bar = embedded ? null : mountSelectionBar({scope, api, grid, getItems:() => state?.items ?? [], focusFallback,
-        checked:visit?.checked, onCategorySet:() => { loadCategories(); reset(); }, activity, onTagged:keys => refreshTagged(keys),
-        // #392 "Select all N matching": the listing's total and its filter, as the server lists them.
-        getListing:() => ({total:state?.total ?? 0, hasMore:Boolean(state?.hasMore), positiveCount:state?.positiveCount ?? null}),
-        // A Source filter carries its root's scope, so a renumbered source is refused (source-changed), not acted on.
-        getFilter:() => {
-            const filter = listingFilter(filters), scope = state?.items[0]?.root_scope;
-            return filter.root !== undefined && typeof scope === 'string' ? {...filter, root_scope:scope} : filter;
-        }});
+    const bar = embedded ? null : mountSelectionBar({scope, api, grid, getItems:() => state.items, focusFallback,
+        checked:visit?.checked, onCategorySet:() => { loadCategories(); reset(); }, activity, onTagged:keys => refreshTagged(keys)});
     if (bar) main.append(bar.element);
     main.append(body);
     const mediaViewer = createMediaViewer({api,container:main,parentScope:scope,inspectionController:inspection,sender,
@@ -393,19 +386,8 @@ export function mountImages(main, api, parentScope, {embedded = false, fetchPage
         const columns = geometry.columns;
         const target = { Home: 0, End: state.items.length - 1, ArrowRight: index + 1,
             ArrowLeft: index - 1, ArrowDown: index + columns, ArrowUp: index - columns }[event.key];
-        if (target !== undefined) {
-            event.preventDefault();
-            const next = Math.max(0, Math.min(state.items.length - 1, target));
-            focusImage(next);
-            // D135: Shift extends the selection from the anchor (this card when there is none) to the new card.
-            if (event.shiftKey && bar) bar.extend(card.dataset.imageKey, imageKey(state.items[next]));
-        } else if (bar && (event.ctrlKey || event.metaKey) && !event.altKey && event.key.toLowerCase() === 'a') {
-            event.preventDefault();
-            bar.selectAll();
-        } else if (bar && event.key === 'Escape' && bar.hasSelection()) {
-            event.preventDefault();
-            bar.clear();
-        } else if (event.key === 'Tab') {
+        if (target !== undefined) { event.preventDefault(); focusImage(Math.max(0, Math.min(state.items.length - 1, target))); }
+        else if (event.key === 'Tab') {
             const backward = event.shiftKey && event.target.matches('.image-open');
             const forward = !event.shiftKey && event.target.closest('.image-card-actions');
             const adjacent = backward ? index - 1 : index + 1;
@@ -480,7 +462,6 @@ export function mountImages(main, api, parentScope, {embedded = false, fetchPage
         if (replaced && selection !== null && !itemIndexes.has(selection)) dropSelection();
         if (replaced) bar?.retain(key => itemIndexes.has(key));
         state = next;
-        bar?.listingChanged();
         if (!embedded) {
             setText(count, countLine(next));
             setText(captionDay, captionDate(next.items, filters.sort));

web/js/workspace/workspace.css

@@ -142,8 +142,6 @@ main:focus-visible { outline: 2px solid var(--ca-focus); outline-offset: 4px; }
    absolute. Columns and gap still come from the concept's `.image-grid` tracks. */
 .image-grid { position: relative; /* D3 */ }
 .image-grid > .media-card { position: absolute; }
-/* #392 D135: a long-press on a card selects it, so no image callout (iOS) takes the press. */
-#image-grid > .media-card { -webkit-touch-callout: none; }
 /* #249 D3: a list row's info keeps its own height so it can be measured; centred, it looks as the stretched concept row.
    #249 D31: it may also shrink below a long nowrap title (the h3 ellipsis then applies, as in the grid). */
 .list-grid .media-info { align-self: center; min-width: 0; /* D3, D31 */ }