fix(inspector): skip only plain first stages on shared links; an unfinished prefix scan anchors nothing (#381)

Review of the saver anchor: a same-links earlier stage is skipped only when it
is not a detailer, sets no prompt override and continues no other sampler, so
an earlier prompt or override behind it is never hidden. A work limit while
tracing a saver prefix ends the match scan without an anchor instead of
counting that saver as no match.

TESTING.md

@@ -790,7 +790,8 @@ sampler found means no anchor: nothing is guessed and the file stays "several po
 prompts". Ingestion ignores file names. Shared-conditioning stages: in a sampler's
 latent walk, an earlier sampler reading the very same conditioning links (positive and
 negative, or a guider; compared by node ID text and slot) is the same prompt, not an
-unattributed stage (`tests/test_resolver_saver_anchor.py`, shapes in
+unattributed stage, when it is a plain first stage: not a detailer, no prompt override
+set, and no listed sampler in its own latent ancestry (else it stays unattributed) (`tests/test_resolver_saver_anchor.py`, shapes in
 `tests/saver_anchor_graphs.py` from the maintainer's `gpu_unlock_bench`, dataset and
 ANIMA runs; browser parity through the `anchor-*` cases, which carry `__file_name`).
 

tests/local_resolver_cases.py

@@ -942,6 +942,12 @@ def golden_cases():
             anchor.two_stage_same_conditioning(["91", 0]),
             "final_00003_.png",
         ),
+        ("hidden-earlier", anchor.hidden_earlier_prompt(), "out_00001_.png"),
+        (
+            "hidden-override",
+            anchor.hidden_earlier_prompt(override=True),
+            "out_00001_.png",
+        ),
     ):
         cases[f"anchor-{name}"] = {"prompt": _dump(graph)}
         if file_name is not None:

tests/saver_anchor_graphs.py

@@ -127,3 +127,55 @@ def two_stage_same_conditioning(second_positive=None):
     if second_positive is not None:
         graph["91"] = _encode(BRANCH_TEXTS[1])
     return graph
+
+
+def hidden_earlier_prompt(override=False):
+    """Review shape: the skipped same-links stage continues a different prompt.
+
+    10 (cat) -> 11 (dog) -> unlisted LatentBlend -> 13 (dog, same links as 11)
+    -> VAEDecode -> SaveImage ``out``. With ``override``, 11 is a
+    ``KSampler (Efficient)`` with a linked ``script``.
+    """
+    graph = _base()
+    graph["5"] = _encode("cat X")
+    graph["6"] = _encode("dog Y")
+    graph["10"] = _ksampler(["5", 0], ["3", 0], ["2", 0])
+    graph["11"] = _ksampler(["6", 0], ["3", 0], ["10", 0])
+    if override:
+        graph["11"] = _ksampler(["6", 0], ["3", 0], ["2", 0])
+        graph["11"]["class_type"] = "KSampler (Efficient)"
+        graph["11"]["inputs"]["script"] = ["40", 0]
+        graph["40"] = {"class_type": "XY Plot", "inputs": {"grid_spacing": 0}}
+    graph["12"] = {
+        "class_type": "LatentBlend",
+        "inputs": {"samples1": ["11", 0], "samples2": ["2", 0], "blend_factor": 0.5},
+    }
+    graph["13"] = _ksampler(["6", 0], ["3", 0], ["12", 0], 0.5)
+    graph["14"] = {
+        "class_type": "VAEDecode",
+        "inputs": {"samples": ["13", 0], "vae": ["1", 2]},
+    }
+    graph["15"] = {
+        "class_type": "SaveImage",
+        "inputs": {"filename_prefix": "out", "images": ["14", 0]},
+    }
+    return graph
+
+
+def deep_prefixes(chain):
+    """Review shape: two branches whose savers both trace the prefix ``dup``.
+
+    Saver A's prefix runs through ``chain`` DisplayText nodes; saver B's
+    through one more, so a short visit allowance can finish only one trace.
+    """
+    graph = branch_bench(prefixes=[["p0", 0], ["q", 0], "x_1", "x_2"])
+    graph["pz"] = {"class_type": "StringConstant", "inputs": {"string": "dup"}}
+    previous = "pz"
+    for index in range(chain - 1, -1, -1):
+        graph[f"p{index}"] = {
+            "class_type": "DisplayText",
+            "inputs": {"text": [previous, 0]},
+        }
+        previous = f"p{index}"
+    graph["q"] = {"class_type": "DisplayText", "inputs": {"text": ["p0", 0]}}
+    return graph

tests/test_prompt_pair_resolver.py

@@ -2974,15 +2974,11 @@ class TestLatentAncestry(unittest.TestCase):
         source["60"]["class_type"] = "UltimateSDUpscale"
         result = _inspect(source, output_node_id="9")
         self.assertEqual((result["state"], result["sampler_id"]), ("resolved", "3"))
-        # Reached only through an unlisted image node, it stays unattributed,
-        # unless both stages read the same conditioning links (#381).
+        # Reached only through an unlisted image node, it stays unattributed:
+        # a detailer is never a plain first stage, even on the same links (#381).
         source["61"] = {"class_type": "MysteryFilter", "inputs": {"image": ["60", 0]}}
         source["5"]["inputs"]["pixels"] = ["61", 0]
         result = _inspect(source, output_node_id="9")
-        self.assertEqual((result["state"], result["sampler_id"]), ("resolved", "3"))
-        source["74"] = parity._enc(parity.POS)
-        source["60"]["inputs"]["positive"] = ["74", 0]
-        result = _inspect(source, output_node_id="9")
         self.assertEqual(result["reason"], resolver.MULTISTAGE_UNATTRIBUTED_REASON)
 
     def test_latent_walk_budget_exhaustion_is_work_limit(self):

tests/test_resolver_saver_anchor.py

@@ -108,3 +108,28 @@ class TestSharedConditioningStages(unittest.TestCase):
 
 if __name__ == "__main__":
     unittest.main()
+
+
+class TestReviewFindings(unittest.TestCase):
+    """Shapes from the independent review of the saver-anchor commit."""
+
+    def test_a_skipped_stage_never_hides_its_own_earlier_prompt(self):
+        result = _inspect(shapes.hidden_earlier_prompt(), "out_00001_.png")
+        self.assertNotEqual(result["state"], "resolved")
+        self.assertEqual(result["reason"], resolver.MULTISTAGE_UNATTRIBUTED_REASON)
+
+    def test_a_skipped_stage_never_hides_its_override(self):
+        result = _inspect(shapes.hidden_earlier_prompt(override=True), "out_00001_.png")
+        self.assertNotEqual(result["state"], "resolved")
+
+    def test_an_unfinished_prefix_scan_anchors_nothing(self):
+        graph = shapes.deep_prefixes(9)
+        for visits in range(10, 30):
+            with self.subTest(visits=visits):
+                result = resolver.resolve_prompt_pair(
+                    {"prompt": graph},
+                    profile=resolver.INSPECTION_PROFILE,
+                    max_visits=visits,
+                    file_name="dup_00001_.png",
+                )
+                self.assertNotEqual(result["state"], "resolved")

utils/prompt_pair_resolver.py

@@ -1552,6 +1552,44 @@ class _GraphResolver:
             keys.append(tuple(values))
         return keys[0] == keys[1]
 
+    def alone(self, node_id: str) -> bool:
+        """Whether a sampler's prompt is its own links' text alone.
+
+        True when it sets no prompt override and its latent ancestry reaches no
+        listed sampler (a plain first stage). Any failure but running out of
+        visits is ``False``; the walk never recurses into another stage.
+        """
+        name, inputs = self.node(node_id)
+        entry = self.semantics.samplers[name]
+        if entry["strategy"] == _DETAILER:
+            return False
+        if any(
+            inputs.get(override) not in (None, "")
+            for override in entry.get("prompt_overrides", ())
+        ):
+            return False
+        value = inputs.get(entry.get("latent")) if entry.get("latent") else None
+        if value is None:
+            return True
+        if not _link(value):
+            return False
+        queue, queued = self.walk_from(value)
+        try:
+            while queue:
+                current, depth = queue.popleft()
+                if current == node_id or depth >= self.max_depth:
+                    return False
+                self.budget.spend()
+                name, inputs = self.node(current)
+                if name in self.stage_classes or self.stage_shaped(name, inputs):
+                    return False
+                self.enqueue(queue, queued, inputs, depth + 1)
+        except _Unresolved as error:
+            if error.code == "work-limit":
+                raise
+            return False
+        return True
+
     def saver_stages(self, file_name: Any) -> Optional[list]:
         """The candidate samplers of the one saver that wrote ``file_name``.
 
@@ -1599,7 +1637,11 @@ class _GraphResolver:
         if _link(prefix):
             try:
                 prefix = self.text(prefix, "string")[0]
-            except (_Unresolved, _Diverging):
+            except _Diverging:
+                return False
+            except _Unresolved as error:
+                if error.code == "work-limit":
+                    raise  # an unfinished scan anchors nothing (never a guess)
                 return False
         if not isinstance(prefix, str):
             return False
@@ -2012,7 +2054,7 @@ class _GraphResolver:
                 if not traced:
                     lineage, traced = self.lineage_predecessor(value), True
                 if node_id != lineage:
-                    if self.same_conditioning(origin, node_id):
+                    if self.same_conditioning(origin, node_id) and self.alone(node_id):
                         # Same positive and negative links: the same prompt
                         # whichever stage this is (#381).
                         continue

web/js/workspace/local-resolver-stages.mjs

@@ -322,6 +322,32 @@ function sameConditioning(resolver, first, second) {
     return keys[0] === keys[1];
 }
 
+/** `alone`: no prompt override set and no listed sampler in its latent ancestry (a plain first stage). */
+function alone(resolver, nodeId) {
+    let [name, inputs] = resolver.node(nodeId);
+    const entry = resolver.semantics.samplers.get(name);
+    if (entry.strategy === DETAILER) return false;
+    if ((entry.prompt_overrides ?? []).some(override => { const value = pyGet(inputs, override); return value !== null && value !== undefined && value !== ''; })) return false;
+    const value = entry.latent ? pyGet(inputs, entry.latent) : null;
+    if (value === null || value === undefined) return true;
+    if (!isLink(value)) return false;
+    const start = String(value[0]), queue = [[start, 0]], queued = new Set([start]);
+    try {
+        for (let head = 0; head < queue.length; head++) {
+            const [current, depth] = queue[head];
+            if (current === nodeId || depth >= resolver.maxDepth) return false;
+            resolver.budget.spend();
+            [name, inputs] = resolver.node(current);
+            if (resolver.stageClasses.has(name) || resolver.stageShaped(name, inputs)) return false;
+            resolver.enqueue(queue, queued, inputs, depth + 1);
+        }
+    } catch (error) {
+        if (!(error instanceof Unresolved) || error.code === 'work-limit') throw error;
+        return false;
+    }
+    return true;
+}
+
 export function latentStages(resolver, origin, value) {
     if (!isLink(value)) throw new Unresolved('Unknown latent ancestry', 'malformed');
     const start = String(value[0]), queue = [[start, 0]], queued = new Set([start]);
@@ -336,7 +362,7 @@ export function latentStages(resolver, origin, value) {
             if (!traced) { lineage = lineagePredecessor(resolver, value); traced = true; }
             if (nodeId !== lineage) {
                 // Same positive and negative links: the same prompt whichever stage this is (#381).
-                if (sameConditioning(resolver, origin, nodeId)) continue;
+                if (sameConditioning(resolver, origin, nodeId) && alone(resolver, nodeId)) continue;
                 throw new Unresolved(MULTISTAGE_UNATTRIBUTED_REASON);
             }
             earlier = nodeId;

web/js/workspace/local-resolver.mjs

@@ -403,7 +403,8 @@ class GraphResolver {
         let prefix = pyGet(node.get('inputs'), 'filename_prefix');
         if (isLink(prefix)) {
             try { prefix = this.text(prefix, 'string')[0]; } catch (error) {
-                if (error instanceof Unresolved || error instanceof Diverging) return false;
+                // An unfinished scan anchors nothing (never a guess): work-limit ends the match scan.
+                if (error instanceof Diverging || (error instanceof Unresolved && error.code !== 'work-limit')) return false;
                 throw error;
             }
         }