pygeomatic 0.2.2__tar.gz → 0.4__tar.gz

{pygeomatic-0.2.2 → pygeomatic-0.4}/.gitignore

@@ -216,3 +216,5 @@ __marimo__/
 
 # Streamlit
 .streamlit/secrets.toml
+examples/agent-output.md
+.claude/settings.local.json

{pygeomatic-0.2.2 → pygeomatic-0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pygeomatic
-Version: 0.2.2
+Version: 0.4
 Summary: Python mirror of the geomatic DSL function library; records calls for deterministic DSL emission
 Project-URL: Homepage, https://github.com/TinyVolt/pygeomatic
 Project-URL: Repository, https://github.com/TinyVolt/pygeomatic

{pygeomatic-0.2.2 → pygeomatic-0.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pygeomatic"
-version = "0.2.2"
+version = "0.4"
 description = "Python mirror of the geomatic DSL function library; records calls for deterministic DSL emission"
 readme = "README.md"
 license = "MIT"

{pygeomatic-0.2.2 → pygeomatic-0.4}/src/pygeomatic/__init__.py

@@ -22,8 +22,12 @@ from .article import (  # noqa: F401
     ArticleResult,
     article_mode,
     compile_article,
+    md,
     run_article,
+    when,
 )
+from . import cond  # noqa: F401  — gm.cond.ge(k, 2), gm.cond.all_(...), ...
+from .cond import Cond, CondError  # noqa: F401
 from .coercions import allow_coercions, coercions_enabled  # noqa: F401
 from .emit import emit, render_command, render_token  # noqa: F401
 from .extensions import (  # noqa: F401
@@ -118,6 +122,8 @@ from .tex import (  # noqa: F401
     rows,
     tex,
 )
+from . import ui  # noqa: F401  — gm.ui.slider(...), gm.ui.checkbox(...), ...
+from .ui import UIError, render_widget_html  # noqa: F401
 
 
 def __getattr__(name: str) -> GNode:
@@ -175,8 +181,8 @@ from .functions.implementations.intersections import (  # noqa: F401
 from .functions.implementations.curve_functions import (  # noqa: F401
     clear_trail,
     evaluate_polynomial,
-    plot,
     plot_inverse,
+    plot_reactive,
     polynomial,
     trail,
 )
@@ -254,7 +260,7 @@ from .functions.implementations.autograd_functions import (  # noqa: F401
     gradient_descent_step,
     minimize,
     param,
-    partial,
+    partial_derivative,
     reevaluate,
     vector_field,
     zero_grad,

{pygeomatic-0.2.2 → pygeomatic-0.4}/src/pygeomatic/article.py

@@ -35,6 +35,8 @@ import subprocess
 import sys
 from contextlib import contextmanager
 from contextvars import ContextVar
+from html import escape
+from inspect import cleandoc
 from dataclasses import dataclass, field
 from typing import Optional, Sequence, Union
 
@@ -42,6 +44,7 @@ import json
 
 from .coercions import allow_coercions
 from .emit import emit, render_command
+from .latex_lint import lint_latex
 from .parse import DslParseError, parse_dsl
 from .store import Store, _article_replay, _auto_create_enabled, current_store
 from .tex import harvest_tex_bindings
@@ -96,6 +99,9 @@ class _Group:
 class _Recorder:
     groups: list[_Group] = field(default_factory=list)
     open: Optional[str] = None
+    # Markdown the CURRENT executable has emitted via gm.md(), in call order.
+    # Reset by _execute before each fence; drained into the fence afterwards.
+    md: list[str] = field(default_factory=list)
 
 
 _recorder: ContextVar[Optional[_Recorder]] = ContextVar(
@@ -137,6 +143,96 @@ def group(name: str):
     rec.groups.append(_Group(name, start, end))
 
 
+def md(text: str) -> None:
+    """Write markdown into the article at the point this block sits.
+
+    A ```pygeomatic block normally contributes only hidden setup commands. This
+    is how it contributes visible prose as well — which is what makes a control
+    reachable, since `f"{r}"` only works inside python:
+
+        r = gm.ui.slider(1, 5, label="radius")
+        gm.md(f"Drag to resize the circle: {r}")
+
+    Calls accumulate in order and land after the block's setup commands.
+    `cleandoc` strips the uniform indentation of a triple-quoted string, so
+    prose written at any indent level reaches markdown flush-left rather than
+    as a code block.
+
+    Deliberately NOT rescanned for `{label}(command)` links: a link has to be
+    executed to produce its DSL, and by the time this text exists all execution
+    has finished. Maths, controls and conditional blocks are all fine.
+    """
+    rec = _recorder.get()
+    if rec is None:
+        raise ArticleError(
+            None, "gm.md() is only usable inside a pygeomatic article block"
+        )
+    if not isinstance(text, str):
+        raise ArticleError(None, f"gm.md() takes a string, got {type(text).__name__}")
+    rec.md.append(cleandoc(text))
+
+
+@contextmanager
+def when(condition):
+    """Show the markdown in this block only while `condition` holds.
+
+    The condition is checked in the READER's browser, against live store nodes,
+    so the prose appears and disappears as they move a control:
+
+        show = gm.ui.checkbox(False, label="Show the proof")
+        with gm.when(show):
+            gm.md("Because $ab=ba$, the map commutes.")
+
+    Only gm.md() output is gated. Commands recorded inside the block go onto
+    the tape as usual — hiding prose must not silently change the scene.
+
+    Blocks nest; an inner block shows only when both conditions hold.
+
+    Do not put command links inside a gated block. Commands are numbered by
+    document position, so hiding one doesn't remove it from the sequence: the
+    reader would be left waiting on a link they cannot see. Prose, maths and
+    controls are all fine.
+    """
+    from .cond import evaluate, node_refs, to_payload
+
+    rec = _recorder.get()
+    if rec is None:
+        raise ArticleError(
+            None, "gm.when() is only usable inside a pygeomatic article block"
+        )
+    payload = to_payload(condition)
+
+    outer = rec.md
+    rec.md = []
+    try:
+        yield
+    finally:
+        inner = [chunk for chunk in rec.md if chunk.strip()]
+        rec.md = outer
+
+    if not inner:
+        raise ArticleError(None, "gm.when() block produced no markdown")
+
+    # Start hidden when the condition is already false, so the block never
+    # flashes on screen before the browser's watcher runs. Values come from the
+    # nodes as they stand right now; an unknown value reads as false.
+    store = current_store()
+    values = {}
+    for node_id in node_refs(payload, set()):
+        node = store.nodes.get(node_id)
+        values[node_id] = getattr(node, "numeric", None) if node else None
+    hidden = "" if evaluate(payload, values) else ' style="display:none"'
+
+    data = json.dumps(payload, separators=(",", ":"), sort_keys=False)
+    body = "\n\n".join(inner)
+    # The blank lines are load-bearing: markdown stops treating a block as raw
+    # HTML at the first blank line, so the prose inside is still formatted
+    # normally (and the raw file still reads correctly on GitHub).
+    rec.md.append(
+        f'<div class="nova-when" data-when=\'{escape(data)}\'{hidden}>\n\n{body}\n\n</div>'
+    )
+
+
 # ---------------------------------------------------------------------------
 # Span scanner
 # ---------------------------------------------------------------------------
@@ -228,6 +324,36 @@ def _scan_spans(text: str) -> list[_Span]:
     return spans
 
 
+def _iter_math(text: str, base_lineno: int):
+    """Yield `(latex_body, lineno)` for each `$…$` / `$$…$$` region in `text` —
+    the inverse of `_scan_spans`' skip rule, so the linter sees exactly the
+    regions the span scanner passes over."""
+    i, n = 0, len(text)
+    while i < n:
+        if text[i] == "$":
+            end = _skip_math_at(text, i)
+            if end is not None:
+                is_block = text[i + 1 : i + 2] == "$"
+                open_ = i + (2 if is_block else 1)
+                close = end - (2 if is_block else 1)
+                yield text[open_:close], base_lineno + text[:i].count("\n")
+                i = end
+                continue
+        i += 1
+
+
+def _lint_math(parts: Sequence[Union["_Prose", "_Fence"]]) -> None:
+    """Fail the compile on undefined KaTeX macros / the `#`-hex footgun in prose
+    math, before any Python runs. Skips code fences (Python / verbatim)."""
+    for part in parts:
+        if isinstance(part, _Fence) or not part.scan:
+            continue
+        for latex, lineno in _iter_math(part.text, part.lineno):
+            problems = lint_latex(latex)
+            if problems:
+                raise ArticleError(lineno, problems[0])
+
+
 # ---------------------------------------------------------------------------
 # Markdown segmentation
 # ---------------------------------------------------------------------------
@@ -339,6 +465,7 @@ class _Executable:
     span: Optional[_Span] = None  # inline only
     start: int = -1  # tape slice [start:end) once executed
     end: int = -1
+    md: str = ""  # markdown this executable emitted via gm.md()
 
 
 def _author_lineno(exc: BaseException, fallback: int) -> int:
@@ -356,7 +483,7 @@ def _execute(executables: list[_Executable], allow: bool) -> tuple[Store, list[_
     """Run the article's Python in one shared store; returns it and the groups."""
     import pygeomatic as gm  # the fully-initialized package, for the namespace
 
-    namespace = {"gm": gm, "group": group}
+    namespace = {"gm": gm, "group": group, "md": md, "when": when}
     rec = _Recorder()
     rec_token = _recorder.set(rec)
     try:
@@ -364,6 +491,7 @@ def _execute(executables: list[_Executable], allow: bool) -> tuple[Store, list[_
             for ex in executables:
                 ex.start = len(store.commands)
                 groups_before = len(rec.groups)
+                rec.md = []
                 # Pad so tracebacks and SyntaxErrors carry article line numbers.
                 padded = "\n" * (ex.lineno - 1) + ex.code
                 try:
@@ -382,11 +510,20 @@ def _execute(executables: list[_Executable], allow: bool) -> tuple[Store, list[_
                         f"{type(err).__name__}: {err}",
                     ) from err
                 ex.end = len(store.commands)
+                ex.md = "\n\n".join(chunk for chunk in rec.md if chunk.strip())
                 if ex.kind == "inline":
                     if len(rec.groups) != groups_before:
                         raise ArticleError(
                             ex.lineno, "group() is not allowed in an inline span"
                         )
+                    if ex.md:
+                        # An inline span is replaced by its commands mid-
+                        # sentence; there is nowhere sensible to put a block of
+                        # prose, so this is a mistake rather than a layout
+                        # choice. Same reasoning as group() above.
+                        raise ArticleError(
+                            ex.lineno, "gm.md() is not allowed in an inline span"
+                        )
                     if ex.end == ex.start:
                         raise ArticleError(
                             ex.lineno,
@@ -412,6 +549,7 @@ def compile_article(markdown: str, *, allow_coercions: bool = False) -> str:
     must already be loaded); use `run_article` for a sandboxed subprocess run.
     """
     parts = _segment(markdown)
+    _lint_math(parts)
 
     # Document-order events: executables (fences, inline spans) and ref spans.
     executables: list[_Executable] = []
@@ -522,9 +660,15 @@ def compile_article(markdown: str, *, allow_coercions: bool = False) -> str:
     nth_fence = 0
     for part in parts:
         if isinstance(part, _Fence):
-            lines = fence_lines[fence_order[nth_fence]]
+            ex_idx = fence_order[nth_fence]
+            lines = fence_lines[ex_idx]
             nth_fence += 1
             out.append("".join(f"{{}}({line})\n" for line in lines))
+            # Prose the block emitted via gm.md() follows its setup commands,
+            # blank-line separated so markdown sees it as its own block.
+            emitted = executables[ex_idx].md
+            if emitted:
+                out.append(f"\n{emitted}\n\n")
             continue
         text = part.text
         for span, new in sorted(

pygeomatic-0.4/src/pygeomatic/cond.py

@@ -0,0 +1,246 @@
+"""gm.cond — conditions over store nodes, for gating markdown with gm.when.
+
+A condition is pure configuration: a small JSON tree naming nodes and constants,
+recorded into the article and evaluated in the browser whenever one of those
+nodes changes. It records no DSL and has no engine command behind it.
+
+    show = gm.ui.checkbox(False, label="Show the proof")
+    with gm.when(show):
+        gm.md("Because $ab=ba$, the map commutes.")
+
+    with gm.when(gm.cond.ge(k, 2)):
+        gm.md("Now the second eigenvector matters.")
+
+**Why a `gm.cond` namespace instead of `k >= 2`.** Overloading comparison
+operators on nodes would collide with geomatic's own comparison commands
+(`\\gt`, `\\lt`, ...), which record DSL and return Bool nodes — the opposite of
+what a condition is. Keeping them apart means `k >= 2` stays available for its
+real meaning. `&`, `|` and `~` ARE overloaded, but only on `Cond` itself, which
+is our own type and has no other reading.
+
+The JSON shape is shared with the browser's `predicate.ts`; keep the two in
+step.
+"""
+
+from __future__ import annotations
+
+from typing import Union
+
+from .nodes import GNode
+
+Operand = Union[GNode, float, int, str, bool]
+
+_ORDERED_OPS = ("ge", "gt", "le", "lt")
+
+
+class CondError(ValueError):
+    """A condition could not be built (bad operand or comparison)."""
+
+
+class Cond:
+    """A built condition. Combine with `&`, `|`, `~`; pass to `gm.when`."""
+
+    __slots__ = ("payload",)
+
+    def __init__(self, payload: dict) -> None:
+        self.payload = payload
+
+    def __and__(self, other: "Cond") -> "Cond":
+        return all_(self, other)
+
+    def __or__(self, other: "Cond") -> "Cond":
+        return any_(self, other)
+
+    def __invert__(self) -> "Cond":
+        return not_(self)
+
+    def __bool__(self):
+        raise CondError(
+            "a condition cannot be used in a python `if` — it describes something "
+            "the READER's browser decides, not something known while compiling. "
+            "Use `with gm.when(...)`. For a compile-time branch, test the plain "
+            "python value instead."
+        )
+
+    def __repr__(self) -> str:
+        return f"Cond({self.payload!r})"
+
+
+def _operand(value: Operand, where: str) -> dict:
+    if isinstance(value, Cond):
+        raise CondError(f"{where}: expected a node or a constant, got a condition")
+    if isinstance(value, GNode):
+        if not value.id:
+            raise CondError(f"{where}: node has no id yet, so it cannot be referenced")
+        return {"node": value.id}
+    if isinstance(value, bool):
+        return {"const": value}
+    if isinstance(value, (int, float)):
+        return {"const": float(value)}
+    if isinstance(value, str):
+        return {"const": value}
+    raise CondError(f"{where}: unsupported operand {value!r}")
+
+
+def _compare(op: str, a: Operand, b: Operand) -> Cond:
+    left = _operand(a, f"gm.cond.{op}")
+    right = _operand(b, f"gm.cond.{op}")
+    if op in _ORDERED_OPS:
+        for side in (left, right):
+            if isinstance(side.get("const"), str):
+                raise CondError(
+                    f"gm.cond.{op} orders numbers; compare text with "
+                    "gm.cond.eq / gm.cond.ne instead"
+                )
+    return Cond({"op": op, "a": left, "b": right})
+
+
+def ge(a: Operand, b: Operand) -> Cond:
+    """a >= b"""
+    return _compare("ge", a, b)
+
+
+def gt(a: Operand, b: Operand) -> Cond:
+    """a > b"""
+    return _compare("gt", a, b)
+
+
+def le(a: Operand, b: Operand) -> Cond:
+    """a <= b"""
+    return _compare("le", a, b)
+
+
+def lt(a: Operand, b: Operand) -> Cond:
+    """a < b"""
+    return _compare("lt", a, b)
+
+
+def eq(a: Operand, b: Operand) -> Cond:
+    """a == b (numbers, text or booleans)"""
+    return _compare("eq", a, b)
+
+
+def ne(a: Operand, b: Operand) -> Cond:
+    """a != b (numbers, text or booleans)"""
+    return _compare("ne", a, b)
+
+
+def _fold(op: str, conds: tuple, name: str) -> Cond:
+    if not conds:
+        raise CondError(f"gm.cond.{name} needs at least one condition")
+    built = []
+    for c in conds:
+        if not isinstance(c, Cond):
+            raise CondError(f"gm.cond.{name}: expected conditions, got {c!r}")
+        built.append(c.payload)
+    folded = built[0]
+    for nxt in built[1:]:
+        folded = {"op": op, "a": folded, "b": nxt}
+    return Cond(folded)
+
+
+def all_(*conds: Cond) -> Cond:
+    """Every condition holds."""
+    return _fold("and", conds, "all_")
+
+
+def any_(*conds: Cond) -> Cond:
+    """At least one condition holds."""
+    return _fold("or", conds, "any_")
+
+
+def not_(c: Cond) -> Cond:
+    """The condition does not hold."""
+    if not isinstance(c, Cond):
+        raise CondError(f"gm.cond.not_: expected a condition, got {c!r}")
+    return Cond({"op": "not", "a": c.payload})
+
+
+def to_payload(condition: Union[Cond, GNode]) -> dict:
+    """The JSON for a condition, or for a bare node used as a truth gate."""
+    if isinstance(condition, Cond):
+        return condition.payload
+    if isinstance(condition, GNode):
+        if not condition.id:
+            raise CondError("node has no id yet, so it cannot gate anything")
+        if condition.type not in ("Bool", "Scalar"):
+            raise CondError(
+                f"a {condition.type} node cannot be a gate on its own — compare it, "
+                f"e.g. gm.cond.eq({condition.id}, ...)"
+            )
+        return {"node": condition.id}
+    raise CondError(
+        f"gm.when() takes a Bool/Scalar node or a gm.cond condition, got {condition!r}"
+    )
+
+
+# ---------------------------------------------------------------------------
+# Compile-time evaluation
+# ---------------------------------------------------------------------------
+
+
+def _truthy(value) -> bool:
+    if value is None:
+        return False
+    if isinstance(value, bool):
+        return value
+    if isinstance(value, (int, float)):
+        return value != 0
+    return bool(value)
+
+
+def evaluate(payload: dict, values: dict) -> bool:
+    """Whether the condition holds for `values` (node id → current value).
+
+    Used only to decide whether a block starts hidden, so the reader never sees
+    it flash before the browser takes over. A node with no known value counts as
+    absent, which reads as false — the safe direction: a block that should have
+    been visible appears a frame later, rather than one that should have been
+    hidden appearing at all.
+
+    Mirrors `evalPredicate` in the browser; keep the two in step.
+    """
+    if "node" in payload:
+        return _truthy(values.get(payload["node"]))
+    op = payload["op"]
+    if op == "not":
+        return not evaluate(payload["a"], values)
+    if op in ("and", "or"):
+        left = evaluate(payload["a"], values)
+        right = evaluate(payload["b"], values)
+        return (left and right) if op == "and" else (left or right)
+
+    def side(operand: dict):
+        return values.get(operand["node"]) if "node" in operand else operand["const"]
+
+    a, b = side(payload["a"]), side(payload["b"])
+    if op == "eq":
+        return a == b
+    if op == "ne":
+        return a != b
+    if a is None or b is None or isinstance(a, str) or isinstance(b, str):
+        return False
+    if op == "ge":
+        return a >= b
+    if op == "gt":
+        return a > b
+    if op == "le":
+        return a <= b
+    return a < b
+
+
+def node_refs(payload: dict, into: set) -> set:
+    """Every node id the condition reads."""
+    if "node" in payload:
+        into.add(payload["node"])
+        return into
+    op = payload["op"]
+    if op == "not":
+        return node_refs(payload["a"], into)
+    if op in ("and", "or"):
+        node_refs(payload["a"], into)
+        return node_refs(payload["b"], into)
+    for operand in (payload["a"], payload["b"]):
+        if "node" in operand:
+            into.add(operand["node"])
+    return into

{pygeomatic-0.2.2 → pygeomatic-0.4}/src/pygeomatic/functions/implementations/autograd_functions.py

@@ -44,7 +44,9 @@ def backprop(node):
     params=[P("target", "Scalar"), P("param", "Any")],
     category=CATEGORY,
 )
-def partial(target, param_node):
+def partial_derivative(target, param_node):
+    # Computes the partial derivative of `target` w.r.t. `param` (NOT
+    # functools.partial). Emits `\partial`.
     # Mirrors the engine: an Array param broadcasts element-wise into an Array
     # of gradient nodes (PointGradient for Point-like elements, ScalarGradient
     # otherwise). Target must be a single Scalar (engine-enforced).

{pygeomatic-0.2.2 → pygeomatic-0.4}/src/pygeomatic/functions/implementations/curve_functions.py

@@ -75,8 +75,11 @@ def clear_trail(trail_id):
     category=CATEGORY,
     is_async=True,
 )
-def plot(x, y):
-    """Record-only: plotting traces the reactive graph in the engine."""
+def plot_reactive(x, y):
+    """Record-only: traces the reactive graph in the engine. `x` and `y` are
+    single Scalar nodes in a reactive relationship (`y = f(x)`); the engine
+    sweeps `x` and traces the curve. NOT matplotlib: do not pass arrays of
+    precomputed samples. Emits `\\plot`."""
     return Plot._new()
 
 

{pygeomatic-0.2.2 → pygeomatic-0.4}/src/pygeomatic/inference.py

@@ -20,10 +20,13 @@ at jump targets, jumps, and any unmodeled opcode, so a name is only inferred
 when the full data flow from the producing instruction to its STORE was
 understood. Anything unclear — attribute/subscript
 targets, expression statements — falls back to the auto-generated id, as does
-an id that is invalid, engine-auto-shaped (`p1`, `num3`, ...), or already
-taken in the store (loops, system defaults; article mode instead reassigns —
-last-write-wins, see article.py). Python underscores translate to
-DSL dashes (`fwd_traj` → `fwd-traj`). An explicit `out=` always wins; calls
+an id that is invalid or engine-auto-shaped (`p1`, `num3`, ...). A taken
+inferred name is no longer filtered out: it flows into `Store.allocate_id`,
+which raises in plain-authoring mode (the duplicate-id guard that catches
+loop reuse) and reassigns last-write-wins in article/macro replay — so the
+inferred-name path and the explicit-`out=` path share one guard. Python
+underscores translate to DSL dashes (`fwd_traj` → `fwd-traj`). An explicit
+`out=` always wins; calls
 originating inside pygeomatic itself (parse replay, macro bodies) are never
 inferred.
 """
@@ -36,7 +39,7 @@ from types import CodeType, FrameType
 from typing import Optional, Union
 from weakref import WeakKeyDictionary
 
-from .store import ENGINE_AUTO_ID_RE, IDENTIFIER_RE, Store, _article_replay
+from .store import ENGINE_AUTO_ID_RE, IDENTIFIER_RE, Store
 
 _STORE_OPS = frozenset({"STORE_NAME", "STORE_FAST", "STORE_GLOBAL", "STORE_DEREF"})
 
@@ -86,6 +89,26 @@ _DUNDER_FRAME_NAMES = frozenset(
     }
 )
 
+# gm.ui widget constructors: each records its node by calling an ordinary
+# geomatic function, so inference must hop their frame to reach the author's
+# assignment (`r = gm.ui.slider(1, 5)` → node id `r`). Kept as an explicit set
+# rather than "any pygeomatic.ui frame" so an unrelated helper in that module
+# can never silently steal a name.
+_UI_FRAME_NAMES = frozenset(
+    {
+        "slider",
+        "checkbox",
+        "dropdown",
+        "radio",
+        "number",
+        "text",
+        # Shared helper behind dropdown/radio: one MORE frame between the
+        # author and the recording call, so it has to be hopped too or those
+        # two would fall back to an auto id while the others named correctly.
+        "_choice",
+    }
+)
+
 # A marker is the offset of the instruction that produced the value; opaque
 # stack entries are None; BUILD_TUPLE groups become lists of entries.
 _Entry = Union[int, None, list]
@@ -202,15 +225,26 @@ def _assignment_targets(code: CodeType) -> tuple[list[int], dict[int, list[str]]
     return [ins.offset for ins in instructions], targets
 
 
+def _is_hoppable(frame: FrameType) -> bool:
+    """True for a pygeomatic-internal frame that stands between the user's
+    expression and the recording wrapper, so inference should look past it."""
+    module = frame.f_globals.get("__name__") or ""
+    name = frame.f_code.co_name
+    if module == "pygeomatic.nodes" and name in _DUNDER_FRAME_NAMES:
+        return True
+    # gm.ui widget constructors call gm.scalar()/gm.text()/... on the author's
+    # behalf, so the recording call happens one frame down inside pygeomatic.ui
+    # — the same situation as an operator dunder. Without this hop
+    # `r = gm.ui.slider(1, 5)` would fall back to an auto id (`num0`) and the
+    # widget could not address its own node.
+    return module == "pygeomatic.ui" and name in _UI_FRAME_NAMES
+
+
 def _hop_dunder_frames(frame: FrameType) -> Optional[FrameType]:
-    """Skip GNode operator-dunder frames so `c = a + b` reads the user frame."""
+    """Skip pygeomatic-internal frames so `c = a + b` and `r = gm.ui.slider(...)`
+    both read the user frame."""
     hops = 0
-    while (
-        frame is not None
-        and hops < 4
-        and (frame.f_globals.get("__name__") or "") == "pygeomatic.nodes"
-        and frame.f_code.co_name in _DUNDER_FRAME_NAMES
-    ):
+    while frame is not None and hops < 4 and _is_hoppable(frame):
         frame = frame.f_back
         hops += 1
     return frame
@@ -254,12 +288,6 @@ def infer_out_names(frame, store: Store) -> list[str]:
                 # p1/num3/... are the engine's internal auto-name space;
                 # claiming one silently clobbers auxiliary nodes on replay.
                 continue
-            if candidate in store.nodes and not _article_replay.get():
-                # Taken (loop reuse, or a system default like T/F) — an
-                # inferred name never reassigns; only an explicit out= may.
-                # Articles are the exception: `s1 = gm.scalar(1)` there means
-                # what the DSL line `s1 = \scalar 1` means — last-write-wins.
-                continue
             candidates.append(candidate)
         return candidates
     except Exception: