meltygui 0.1.0__py3-none-any.whl

meltygui/code/chain_converters.py

@@ -0,0 +1,2111 @@
+"""
+Chain-compatible converter nodes for the unified render pipeline.
+
+Each function is a @render_func that:
+  - Owns its own file I/O (no external load_data / save_data)
+  - Manages pending UI (Load / Save / Revert buttons) via draw_state
+  - Returns (changed, value) like every other chain node
+
+These are NEW functions — the old converters in file_converters.py
+and libcst_conversion.py stay untouched for backward compat.
+"""
+import inspect
+from meltygui.core.diagnostics.notifications import lag_traced
+
+import os
+import pickle
+import sys
+import threading
+import time
+import tokenize
+import types
+from pathlib import PosixPath, Path
+
+import meltygui_imgui as imgui
+import libcst as cst
+
+from meltygui.core.melty import FileWatch
+from meltygui.core.melty import Melty
+from meltygui.core.runtime.background import Background
+from meltygui.state.new_core_model import Pin
+from meltygui.state.new_core_model import Anchor
+from meltygui.core.runtime.toggles import Toggles
+from meltygui.core.windowing.glfw_utils import request_render
+from meltygui.core.windowing.glfw_utils import print_stack_trace
+from meltygui.core.conversion.cache_tree import UNSET_VALUE
+from meltygui.core.conversion.path_finder import Pending
+from meltygui.core.conversion.path_finder import PendingState
+from meltygui.core.core_render import render_func
+from meltygui.code.fileref import Address
+from meltygui.code.fileref import to_address
+from meltygui.code.fileref import update_address_cache
+from meltygui.code.fileref import _evict_linecache
+from meltygui.code.fileref import shift_sibling_linenos
+from meltygui.code.file_converters import _detect_newline
+from meltygui.code.file_converters import _split_lines
+from meltygui.code.file_converters import _recompile
+from meltygui.code.file_converters import _recompile_class
+from meltygui.code.file_converters import _recompile_module
+from meltygui.code.libcst_conversion import cst_module_to_dict
+from meltygui.code.libcst_conversion import dict_to_cst_module
+from meltygui.code.libcst_conversion import GeneralParse
+from meltygui.code.libcst_conversion import CallParse
+from meltygui.code.libcst_conversion import CodeLine
+from meltygui.code.libcst_conversion import ClassParse
+from meltygui.code.libcst_conversion import FunctionParse
+from meltygui.code.libcst_conversion import NO_DEFAULT
+from meltygui.core.diagnostics.perf_trace import trace as _ptrace
+from meltygui.core.diagnostics.perf_trace import span as _pspan
+from meltygui.view.header_view import draw_header
+from meltygui.core.rendering.core_decoration import defaults
+
+
+# ╔══════════════════════════════════════════════════════════════════════════════╗
+# ║  Load node: class → cst.Module                                              ║
+# ╚══════════════════════════════════════════════════════════════════════════════╝
+
+def _load_span(ref: Address) -> str:
+    """Read the line span from disk."""
+    data = ref.path.read_bytes()
+    newline = _detect_newline(data)
+    try:
+        text = data.decode("utf-8")
+    except UnicodeDecodeError:
+        text = data.decode("latin-1")
+    lines = _split_lines(text)
+    return newline.join(lines[ref.start:ref.end])
+
+
+@render_func(use_cache=True)
+def chain_cls_load(input_value, draw_state=None):
+    """Load node: class → cst.Module.
+
+    - Resolves Address from the class on first call
+    - Watches file mtime for external changes
+    - Shows Load / Revert buttons when file changes on disk
+    - Returns (True, cst.Module) when loaded, (False, cached) otherwise
+    """
+    # ── Resolve ref on first encounter ────────────────────────
+    if draw_state._address is None:
+        ref = to_address(input_value)
+        if ref is None:
+            return False, input_value
+        draw_state._address = ref
+        draw_state._original_input_ref = input_value
+
+    ref = draw_state._address
+
+    # ── First load ────────────────────────────────────────────
+    if not hasattr(draw_state, '_loaded_text') or draw_state._loaded_text is None:
+        text = _load_span(ref)
+        draw_state._loaded_text = text
+        draw_state._loaded_cst = cst.parse_module(text)
+        draw_state.mark_file_current()
+        return True, draw_state._loaded_cst
+
+    imgui.text("chain_cls_load: ")
+
+    # ── File change detection ─────────────────────────────────
+    if draw_state.is_file_stale():
+        # Refresh address from cache (another view may have changed line count)
+        fresh_ref = to_address(input_value)
+        if fresh_ref is not None:
+            draw_state._address = fresh_ref
+            ref = fresh_ref
+
+        imgui.text("File changed on disk")
+        if imgui.button("Load##chain_load"):
+            text = _load_span(ref)
+            draw_state._loaded_text = text
+            draw_state._loaded_cst = cst.parse_module(text)
+            draw_state.mark_file_current()
+            return True, draw_state._loaded_cst
+
+        imgui.same_line()
+        if imgui.button("Revert##chain_load"):
+            # Return the last loaded cst - no file I/O
+            draw_state.mark_file_current()
+            return True, draw_state._loaded_cst
+
+    # ── Steady state ──────────────────────────────────────────
+    return False, draw_state._loaded_cst
+
+
+# ╔══════════════════════════════════════════════════════════════════════════════╗
+# ║  Save chain: cst.Module → class (save to disk + hotswap)                     ║
+# ╚══════════════════════════════════════════════════════════════════════════════╝
+
+@render_func(interrupt_source_for=Path)
+def path_to_address(input_value: Path):
+    """Job of interrupt source is to return True when the input has changed on disk"""
+    address = Address(input_value)
+    return False, address
+
+
+@render_func()
+def function_to_address(input_value: types.FunctionType, draw_state, changed=False):
+    """Extract Address from a function object."""
+
+    unwrapped = inspect.unwrap(input_value)
+    source_file = inspect.getfile(unwrapped)
+    FileWatch.register_draw_state(draw_state, Path(source_file))
+
+    # inspect.getsourcelines reads + tokenizes the whole file (and _evict_linecache
+    # forces a fresh read), so it ran every frame while typing. Cache the resolved
+    # Address and re-resolve only when the input or the file's mtime changes:
+    # typing doesn't write the file, so it's a cache hit; a save bumps mtime and
+    # we re-resolve once with fresh line numbers.
+    try:
+        mtime = Path(source_file).stat().st_mtime
+    except OSError:
+        mtime = None
+    cached = getattr(draw_state, '_addr_cache', None)
+    if cached is not None and cached[0] is input_value and cached[1] == mtime:
+        return changed, cached[2]
+
+    _evict_linecache(source_file)
+    try:
+        source_lines, start_lineno = inspect.getsourcelines(unwrapped)
+    except (OSError, TypeError, tokenize.TokenError, SyntaxError) as e:
+        print(f"Could not get source lines for {input_value.__name__} in {source_file}: {e}")
+        return changed, None
+
+    address = Address(Path(source_file), start_lineno - 1,
+                      start_lineno - 1 + len(source_lines), source=input_value,
+                      watcher_ds=draw_state)
+    draw_state._addr_cache = (input_value, mtime, address)
+    return changed, address
+
+
+@render_func()
+def module_to_address(input_value: types.ModuleType, draw_state, changed=False):
+    if changed:
+        source_file = Path(input_value.__file__)
+        FileWatch.register_draw_state(draw_state, source_file)
+        if changed:
+            pass
+
+        return changed, Address(source_file, source=input_value, watcher_ds=draw_state)
+    else:
+        return changed, None
+
+
+########################################### CHAIN START
+@render_func()
+def class_to_address(input_value: type, draw_state, changed=False):
+    # Resolve on EVERY call (guarded by the mtime cache), like function_to_address
+    # - NOT gated on `changed`. Gating let the cached span go stale after a sibling
+    # edit shifted the class's lines, so a save wrote to the wrong range. A save
+    # bumps mtime, so the next render re-resolves fresh line numbers.
+    if not isinstance(input_value, type) or input_value.__module__ in ('builtins', '_collections_abc'):
+        return changed, None
+    # A runtime-generated bubbling class has no source of its own - resolve its base.
+    from meltygui.core.conversion.bubbling import base_of_bubbling
+    input_value = base_of_bubbling(input_value)
+    try:
+        import inspect
+        source_file = inspect.getfile(input_value)
+        FileWatch.register_draw_state(draw_state, Path(source_file))
+
+        # Cache the getsourcelines result by (input, file mtime) so typing
+        # doesn't re-read+tokenize the file; a save bumps mtime and we re-resolve.
+        try:
+            mtime = Path(source_file).stat().st_mtime
+        except OSError:
+            mtime = None
+        cached = getattr(draw_state, '_addr_cache', None)
+        if cached is not None and cached[0] is input_value and cached[1] == mtime:
+            return changed, cached[2]
+
+        _evict_linecache(source_file)
+        source_lines, start_lineno = inspect.getsourcelines(input_value)
+        address = Address(Path(source_file), start_lineno - 1,
+                          start_lineno - 1 + len(source_lines), source=input_value,
+                          watcher_ds=draw_state)
+        draw_state._addr_cache = (input_value, mtime, address)
+        return changed, address
+    except (TypeError, OSError, tokenize.TokenError, SyntaxError):
+        return changed, None
+
+
+@render_func()
+def class_to_address_incl_overrides(input_value: type, draw_state, changed=False):
+    """Like class_to_address, but extends the span UPWARD over a contiguous
+    leading `# [...]` override comment immediately above the class (which may
+    be split across several `#` lines).
+
+    getsourcelines starts at `class X:`, so a comment above it falls outside the
+    span — meaning a module-level override comment would never round-trip and the
+    code_comment lens would re-add/duplicate it. Pulling the comment into the span
+    (loaded as the module header) makes add/update/delete stable.
+
+    Resolves on EVERY call (guarded by the mtime cache), like function_to_address
+    — NOT gated on `changed`. Gating let the cached span go stale after another
+    edit shifted the class's lines, so the whole-class-span save wrote to the
+    wrong range (duplicated/dropped lines, failed delete). A save bumps mtime, so
+    the next render re-resolves fresh line numbers."""
+    if not isinstance(input_value, type) or input_value.__module__ in ('builtins', '_collections_abc'):
+        return changed, None
+    try:
+        from meltygui.code.libcst_conversion import _parse_override_comment
+        source_file = inspect.getfile(input_value)
+        FileWatch.register_draw_state(draw_state, Path(source_file))
+        try:
+            mtime = Path(source_file).stat().st_mtime
+        except OSError:
+            mtime = None
+        cached = getattr(draw_state, '_addr_cache', None)
+        if cached is not None and cached[0] is input_value and cached[1] == mtime:
+            return changed, cached[2]
+
+        _evict_linecache(source_file)
+        source_lines, start_lineno = inspect.getsourcelines(input_value)
+        start0 = start_lineno - 1
+        end0 = start0 + len(source_lines)
+
+        data = Path(source_file).read_bytes()
+        newline = _detect_newline(data)
+        try:
+            file_lines = _split_lines(data.decode("utf-8"))
+        except UnicodeDecodeError:
+            file_lines = _split_lines(data.decode("latin-1"))
+        # Walk up over any contiguous `#` lines above the class, then take the
+        # longest tail of that run that parses as ONE override comment - a
+        # single `# [...]` line or one split across several `#` lines (each
+        # line alone doesn't parse, joined they do). Plain comments above the
+        # override stay outside the span.
+        ext_start = start0
+        j = start0 - 1
+        while j >= 0 and file_lines[j].lstrip().startswith("#"):
+            j -= 1
+        for k in range(j + 1, start0):
+            joined = "\n".join(l.strip() for l in file_lines[k:start0])
+            if _parse_override_comment(joined) is not None:
+                ext_start = k
+                break
+
+        address = Address(Path(source_file), ext_start, end0,
+                          source=input_value, watcher_ds=draw_state)
+        draw_state._addr_cache = (input_value, mtime, address)
+        return changed, address
+    except (TypeError, OSError, tokenize.TokenError, SyntaxError):
+        return changed, None
+
+
+# ── Cst-dict cache (span parse results) ───────────────────────
+# load_cst_dict's parse (cst.parse_module + cst_module_to_dict, ~230ms for a
+# 2k-line span) is the biggest first-load cost with a few code_file_io views open.
+# Cache one finished GeneralParse per span, with the same shape as the symbol
+# store in libcst_conversion.py:
+#   - restart-in-place: adopted through sys._cst_dict_store (sys is shared
+#     across re-execs, and across the src./lsd. module-name dupes)
+#   - full process restart: pickled to ~/.lsd/cst_dict_cache.pkl on shutdown
+#     (FileWatch.shutdown, next to the symbol-cache flush). A stale pickle
+#     after a crash just means one slow first parse - acceptable.
+# Entries are pickled BYTES, not live objects: edits mutate a GeneralParse in
+# place, so serving a shared object would alias changes onto one dict and let
+# edited state pose as the disk parse. loads() on a hit (~25ms) hands every
+# consumer a fresh copy, and the blob is dumped BEFORE the Address is stamped -
+# address.source is a live function/class and doesn't pickle by reference; the
+# hit path re-stamps the caller's live Address instead. Invalidation is the
+# file's mtime (cheap, content-free - no hash).
+_CST_DICT_PICKLE = Path.home() / ".lsd" / "cst_dict_cache.pkl"
+_CST_DICT_PICKLE_VERSION = 1
+
+
+def _load_cst_dict_store() -> dict:
+    store = getattr(sys, "_cst_dict_store", None)
+    if isinstance(store, dict):
+        _ptrace("cst_cache: adopted live store (restart-in-place)",
+                entries=len(store.get("entries", ())))
+        return store                      # restart-in-place / module dupe: adopt
+    entries = {}
+    with _pspan("cst_cache: warm-start load") as _sp:
+        try:                              # fresh process: warm-start from disk
+            with open(_CST_DICT_PICKLE, "rb") as f:
+                payload = pickle.load(f)
+            if payload.get("version") == _CST_DICT_PICKLE_VERSION:
+                entries = payload["entries"]
+        except Exception as e:
+            _sp.add(failed=type(e).__name__)  # missing/corrupt → cold start
+        _sp.add(entries=len(entries))
+    store = {"entries": entries}
+    sys._cst_dict_store = store
+    return store
+
+
+# (resolved_path, start, end) -> (mtime, pickled GeneralParse bytes)
+_cst_dict_cache: dict = _load_cst_dict_store()["entries"]
+
+
+class DiskSpanText(str):
+    """A span's text EXACTLY as read from disk, stamped with the file mtime it
+    was read at and its span key (TypeCodec.load's plain-disk path). Provenance
+    for the cst-dict cache: every string operation (slice, concat, splice)
+    returns a plain str, so text still carrying `_disk_mtime` is guaranteed
+    pristine disk content — the chain parse cache can trust it with NO content
+    comparison, and an edited buffer can never be served a disk-keyed entry.
+    Carrying the span key here (rather than relying on `jump_to`) matters: the
+    code-host chain only receives jump_to on an Index pulse, so the text itself
+    is the only reliable address carrier on the parse path.
+
+    `_codec` (stamped by TypeCodec.load) carries the codec that loaded this
+    text, so a consumer rendering it outside the loader's subtree (the
+    open-files editor) re-establishes the codec context — core_render's
+    codec block reads it as the last-resort active codec."""
+    __slots__ = ("_disk_mtime", "_disk_span",   # _disk_span = (realpath, start, end)
+                 "_codec")                      # the codec class that loaded this text
+
+
+def _parser_tag():
+    """Which parser a cached gp came from — part of every cst-dict cache key,
+    so flipping Toggles.TextEditor.melty_syntax never serves the OTHER
+    parser's parse (a libcst gp reverses through libcst, a core_syntax gp
+    through its text residual — both work, but the toggle should be seen)."""
+    return "meltygui" if Toggles.TextEditor.melty_syntax else "libcst"
+
+
+def chain_parse_cache_has(span_key, disk_mtime):
+    """O(1): would chain_parse_cache_get hit for this pristine buffer? Lets the
+    dispatch site inline a first parse that is really just a ~26ms loads —
+    skipping the async path's frame-hop tax — while a genuine parse stays on
+    the worker."""
+    if span_key is None or disk_mtime is None:
+        return False
+    cached = _cst_dict_cache.get((*span_key, "chain", _parser_tag()))
+    return cached is not None and cached[0] == disk_mtime
+
+
+def chain_parse_cache_get(span_key, disk_mtime):
+    """Cached GeneralParse for a PRISTINE disk buffer (see DiskSpanText), or
+    None. `span_key` is the text's `_disk_span`. Validity is entry-mtime == the
+    mtime the buffer was read at — no stat, no content compare; a fresh copy is
+    served per hit (pickle.loads). The gp is served address-less, exactly like
+    a live chain parse without jump_to (`file=<no address>`)."""
+    key = (*span_key, "chain", _parser_tag())
+    cached = _cst_dict_cache.get(key)
+    if cached is None or cached[0] != disk_mtime:
+        if cached is not None:
+            _ptrace("cst_cache: chain miss (mtime)", file=Path(span_key[0]).name)
+        return None
+    try:
+        with _pspan("cst_cache: chain hit loads", file=Path(span_key[0]).name,
+                    kb=len(cached[1]) // 1024):
+            gp = pickle.loads(cached[1])
+    except Exception:
+        _cst_dict_cache.pop(key, None)    # stale class shape etc. → reparse
+        return None
+    gp.file_path = Path(span_key[0])
+    return gp
+
+
+def chain_parse_cache_put(span_key, disk_mtime, gp):
+    """Store a chain-produced GeneralParse (parse of pristine disk text only —
+    callers gate on DiskSpanText provenance and a clean parse). The address is
+    detached for the dump (live source objects don't pickle) and restored."""
+    if not isinstance(gp, dict):
+        return
+    key = (*span_key, "chain",
+           "meltygui" if gp.get("__origin__") is not None else "libcst")
+    # Detach what a fresh session re-derives anyway: the live address (source
+    # objects don't pickle) and the attached symbol index (~40% of the blob -
+    # _ensure_symbol_index re-attaches it from the symbol-usage cache in ~1ms
+    # on the first render of a served parse).
+    saved_addr = getattr(gp, "address", None)
+    saved_sym = getattr(gp, "symbol_usage", None)
+    saved_usages = gp.pop("__symbol_usages__", None)
+    # The incremental-merge value memo keys on live node ids - meaningless
+    # (and sizeable) after an unpickle. The stmt tables STAY: they are plain
+    # line data, so a warm-started gp merges incrementally right away.
+    saved_memo = getattr(gp, "_value_memo", None)
+    try:
+        gp.address = None
+        gp.symbol_usage = [None]
+        if saved_memo is not None:
+            gp._value_memo = None
+        with _pspan("cst_cache: chain dumps", file=Path(span_key[0]).name, min_ms=5.0):
+            blob = pickle.dumps(gp, protocol=pickle.HIGHEST_PROTOCOL)
+    except Exception:
+        return                            # unpicklable node → just skip caching
+    finally:
+        gp.address = saved_addr
+        gp.symbol_usage = saved_sym
+        if saved_memo is not None:
+            gp._value_memo = saved_memo
+        if saved_usages is not None:
+            gp["__symbol_usages__"] = saved_usages
+    _cst_dict_cache[key] = (disk_mtime, blob)
+
+
+def _cst_cache_key(ref: Address):
+    """(key, mtime) for a span Address, or (None, None) when uncacheable."""
+    if ref.path is None:
+        return None, None
+    try:
+        resolved = os.path.realpath(str(ref.path))
+        mtime = os.stat(resolved).st_mtime
+    except OSError:
+        return None, None
+    return (resolved, ref.start, ref.end), mtime
+
+
+def _harvest_live_span_parses():
+    """Re-cache the LIVE code hosts' held parses under the FINAL disk state.
+    chain_parse_cache_put otherwise only fires on pristine-disk loads, so any
+    file edited during the session keeps its stale launch-mtime entry and
+    cold-parses (~250ms+ for a big span) on every boot. At shutdown — called
+    AFTER apply_all_saves flushed pending edits — a clean, error-free held gp
+    corresponds to the just-written disk content; re-key it to the current
+    mtime so the next launch hits. Any coordinate drift just yields a
+    harmless miss (mtime/key won't match), never a wrong serve."""
+    try:
+        from meltygui.code.new_converters import _code_host_cache
+        from meltygui.code.new_converters import host_code_state
+        from meltygui.code.new_converters import ModesState
+    except Exception:
+        return
+    stored = 0
+    for _key, pair in list(_code_host_cache.items()):
+        try:
+            sh, dh = pair
+            gp = dh._held()
+            if not isinstance(gp, dict) or (gp.get("__cst__") is None
+                                            and gp.get("__origin__") is None):
+                continue
+            cs = host_code_state(sh)
+            addr = getattr(cs, "address", None)
+            if (addr is None or getattr(addr, "path", None) is None
+                    or getattr(cs, "_save_refused", False)):
+                continue
+            # _pending_save is stale here BY TIMING, not by state: the
+            # apply_all_saves that runs just before this harvest already wrote
+            # the pending edits, but the flag is normally cleared when the file
+            # watcher reports the self-write - an event that never gets
+            # called during shutdown. Trust the queue instead: only a save
+            # that SURVIVED apply_all_saves (SaveConflict, still pending)
+            # and disk does not hold this buffer. Skipping on the flag made
+            # every actively-edited file miss the cache on every boot - the
+            # recurring multi-second cold parse of exactly the file being
+            # worked on.
+            if getattr(cs, "_pending_save", False):
+                from meltygui.editor.pending_save import PendingSave
+                _path = str(addr.path)
+                if any(str(getattr(a, "path", None)) == _path
+                       for a in PendingSave.pending_saves):
+                    continue
+            wds = getattr(dh, "_wrapper_draw_state", None)
+            ms = next((v for v in (getattr(wds, "misc", None) or {}).values()
+                       if isinstance(v, ModesState)), None)
+            if ms is not None and ms.last_error is not None:
+                continue          # held/errored gp - predates the buffer
+            span_key, mtime = _cst_cache_key(addr)
+            if span_key is None:
+                continue
+            chain_parse_cache_put(span_key, mtime, gp)
+            stored += 1
+        except Exception:
+            continue
+    _ptrace("cst_cache: harvested live hosts at shutdown", stored=stored)
+
+
+def save_cst_dict_cache():
+    """Atomic pickle of the span cache. Entries are already address-free bytes,
+    so this is a cheap dict-of-bytes dump. Called from FileWatch.shutdown
+    (AFTER apply_all_saves — the harvest keys on final disk mtimes)."""
+    _harvest_live_span_parses()
+    try:
+        # Prune stale entries before persisting: a blob whose stored mtime no
+        # longer matches its file's current mtime can never hit again (the
+        # file changed - and if the span also moved, its replacement lives
+        # under a different key). One stat per file path at shutdown.
+        file_mtimes = {}
+        live = {}
+        for key, (entry_mtime, blob) in dict(_cst_dict_cache).items():
+            path = key[0]
+            if path not in file_mtimes:
+                try:
+                    file_mtimes[path] = os.stat(path).st_mtime
+                except OSError:
+                    file_mtimes[path] = None
+            if file_mtimes[path] == entry_mtime:
+                live[key] = (entry_mtime, blob)
+        with _pspan("cst_cache: save pickle", entries=len(live),
+                    pruned=len(_cst_dict_cache) - len(live)):
+            _CST_DICT_PICKLE.parent.mkdir(parents=True, exist_ok=True)
+            tmp = _CST_DICT_PICKLE.with_suffix(".tmp")
+            with open(tmp, "wb") as f:
+                pickle.dump({"version": _CST_DICT_PICKLE_VERSION,
+                             "entries": live}, f)
+            os.replace(tmp, _CST_DICT_PICKLE)
+    except Exception:
+        pass
+
+
+@render_func(background=True)
+def load_cst_module(input_value: Address):
+
+    file_label = input_value.path.name if input_value.path else "?"
+    key, mtime = _cst_cache_key(input_value)
+    if key is not None:
+        key = (*key, _parser_tag())
+        cached = _cst_dict_cache.get(key)
+        if cached is not None and cached[0] == mtime:
+            try:
+                with _pspan("cst_cache: hit loads", file=file_label,
+                            kb=len(cached[1]) // 1024):
+                    general_parse = pickle.loads(cached[1])
+                general_parse.address = input_value
+                general_parse.file_path = input_value.path
+                return True, general_parse
+            except Exception:
+                _cst_dict_cache.pop(key, None)  # changed class shape etc. → reparse
+                _ptrace("cst_cache: hit blob failed, reparsing", file=file_label)
+        else:
+            _ptrace("cst_cache: miss", file=file_label,
+                    reason="no entry" if cached is None else "mtime")
+
+    with _pspan("cst_cache: parse", file=file_label,
+                span=(input_value.start, input_value.end)):
+        text = _load_span(input_value)
+        if Toggles.TextEditor.melty_syntax:
+            general_parse = cst_module_to_dict(text)        # core_syntax (str input)
+        else:
+            general_parse = cst_module_to_dict(cst.parse_module(text))
+    general_parse.file_path = input_value.path
+    if key is not None:
+        try:
+            with _pspan("cst_cache: dumps", file=file_label, min_ms=5.0):
+                _cst_dict_cache[key] = (mtime, pickle.dumps(
+                    general_parse, protocol=pickle.HIGHEST_PROTOCOL))
+        except Exception:
+            pass                          # unpicklable node → just skip caching
+    general_parse.address = input_value
+
+    if Toggles.slow_down_threads:
+        for i in range(5):
+            import time
+            time.sleep(0.1)
+            print(f"Simulating slow load... {i + 1}/5")
+
+    return True, general_parse
+
+
+########################
+# draw_collection
+########################
+
+# Last successful recompile time per Address, for the "fresh" indicator next
+# to the file-load button in address_to_general_parse. Keyed by Address: the
+# same Address object flows through the chain (address → general_parse →
+# address), so the store side (general_parse_to_address) and the display side
+# (address_to_general_parse) agree on the key.
+_last_compile_times: dict = {}
+
+
+def record_compile(address):
+    """Stamp `address` as compiled just now."""
+    _last_compile_times[address] = time.time()
+
+
+def get_compile_time(address):
+    """Last compile time for `address`, or None if never compiled this session."""
+    return _last_compile_times.get(address)
+
+
+@render_func(background=False)
+def do_recompile(input_value, code_str, file_path, changed=False):
+    """Dispatch recompile to the right handler based on source type."""
+    if isinstance(input_value, type):
+        _recompile_class(input_value, code_str, str(file_path))
+    elif isinstance(input_value, types.FunctionType):
+        _recompile(input_value, code_str, str(file_path))
+    elif isinstance(input_value, types.ModuleType):
+        _recompile_module(input_value, code_str, str(file_path))
+    else:
+        print(f"Unknown source type {type(input_value).__name__}, skipping recompile")
+    return True, None
+
+
+def _import_stmt_end(lines, i):
+    """Index of the LAST line of the (possibly multi-line) import statement that
+    starts at line i — following backslash continuations and unclosed parens, so
+    callers never split a continued import."""
+    stmt = lines[i]
+    while i + 1 < len(lines) and (
+            stmt.rstrip().endswith("\\") or stmt.count("(") > stmt.count(")")):
+        i += 1
+        stmt += "\n" + lines[i]
+    return i, stmt
+
+
+def _import_bound_name(stmt):
+    """The local name an import statement binds: `import x` → x, `import x as
+    y` → y, `from m import x [as y]` → x/y. Best-effort tokens, '' on noise."""
+    toks = stmt.replace(",", " ").split()
+    if "as" in toks:
+        i = toks.index("as")
+        return toks[i + 1] if i + 1 < len(toks) else ""
+    if toks[:1] == ["from"] and "import" in toks:
+        i = toks.index("import")
+        return toks[i + 1].split(".")[0] if i + 1 < len(toks) else ""
+    if toks[:1] == ["import"] and len(toks) > 1:
+        return toks[1].split(".")[0]
+    return ""
+
+
+def _ensure_import_lines(lines, module, name=None):
+    """If the import's bound name isn't already imported in `lines`, insert the
+    statement after the file's leading import block. Two call shapes:
+    (lines, module, name) inserts `from module import name` (the legacy
+    @defaults path); (lines, stmt) with name=None inserts the full statement
+    verbatim (`import json`, `import numpy as np`, `from x import y` — the
+    editor's missing-import quick-fix). Returns
+    (lines, inserted_count, insert_idx) — insert_idx is the 0-indexed line the
+    import landed on (None when nothing was inserted), so the caller can shift
+    co_firstlineno of every code object below it.
+
+    Best-effort textual scan (no parse — this runs inside the save write). Treats
+    the run of leading import/comment/blank/docstring lines as the import block
+    and inserts after it. Continuation-aware (backslash + parens) so it never
+    inserts in the middle of a multi-line import."""
+    if name is None:
+        stmt_text = module
+        name = _import_bound_name(stmt_text)
+        if not name:
+            return lines, 0, None
+    else:
+        stmt_text = f"from {module} import {name}"
+    # ── Dedup: is `name` already imported? (join continuations before checking) ──
+    i = 0
+    while i < len(lines):
+        s = lines[i].strip()
+        if s.startswith("import ") or s.startswith("from "):
+            end, stmt = _import_stmt_end(lines, i)
+            syms = stmt.split("import", 1)[1] if "import" in stmt else ""
+            for ch in "(),\\\n":
+                syms = syms.replace(ch, " ")
+            if name in [t.split(".")[0] for t in syms.split()]:
+                return lines, 0, None
+            i = end + 1
+            continue
+        i += 1
+
+    # ── Find the insert point: end of the leading import block ──────────────────
+    insert_idx = 0
+    i = 0
+    in_doc = None          # triple-quote delimiter while inside a module docstring
+    seen_code = False
+    while i < len(lines):
+        s = lines[i].strip()
+        if in_doc is not None:                       # inside a multi-line docstring
+            insert_idx = i + 1
+            if in_doc in s:
+                in_doc = None
+            i += 1
+            continue
+        if s == "" or s.startswith("#"):
+            i += 1
+            continue
+        if not seen_code and (s.startswith('"""') or s.startswith("'''")):
+            q = s[:3]
+            seen_code = True
+            insert_idx = i + 1
+            if not (len(s) > 3 and s.count(q) >= 2):  # not a one-line docstring
+                in_doc = q
+            i += 1
+            continue
+        if s.startswith("import ") or s.startswith("from "):
+            seen_code = True
+            end, _ = _import_stmt_end(lines, i)       # skip past continuations
+            insert_idx = end + 1
+            i = end + 1
+            continue
+        break  # first real code - stop scanning the import block
+    new_lines = list(lines)
+    new_lines.insert(insert_idx, stmt_text)
+    return new_lines, 1, insert_idx
+
+
+@render_func(background=True)
+def _do_save(input_value, code_str, ensure_import=None):
+    """Queue the edited span into the PendingSave cache — the deferred write.
+
+    Was a synchronous disk splice + sibling-lineno shift. Now every chain save
+    routes here and DEFERS to PendingSave exactly like code_file_io: the
+    structured editor's Save button / Ctrl+S, every code lens (class_var /
+    decoration / code_comment all end their chain in general_parse_to_address),
+    and the caller node. The splice/write/sibling-shift happen once at
+    apply_all_saves, through the codec — which also performs the ensure_import
+    insert and the span-conflict guard that this used to do inline.
+
+    The codec is the SPAN-replacement codec for the address's live source
+    (class / function / module) — never CallerCodec, since the chain hands us a
+    full-span code_str, not a bare call expression. TypeCodec (plain span splice)
+    is the fallback when the source type isn't separately registered."""
+    from meltygui.editor.pending_save import PendingSave
+    from meltygui.code.new_codecs import type_to_codec
+    from meltygui.code.new_codecs import TypeCodec
+    source = input_value.source
+    codec = next((type_to_codec[k] for k in type(source).__mro__ if k in type_to_codec),
+                 TypeCodec) if source is not None else TypeCodec
+    PendingSave.queue_save(input_value, codec, data=code_str, ensure_import=ensure_import)
+    return True, input_value
+
+
+@render_func(background=True)
+def dict_to_cst(input_value, changed=False):
+    back_to_cst = dict_to_cst_module(input_value)
+    if Toggles.slow_down_threads:
+        for i in range(5):
+            import time
+            time.sleep(0.1)
+            print(f"Simulating slow load... {i + 1}/5")
+
+    return False, back_to_cst
+
+
+# ╔══════════════════════════════════════════════════════════════════════════════╗
+# ║  Live apply - cst_dict edits drive the live object ahead of save/recompile    ║
+# ╚══════════════════════════════════════════════════════════════════════════════╝
+# The responsive-preview layer in front of the real hotswap: when an edit flows
+# back through a chain (general_parse_to_address) down the cache route
+# (draw_code_tabs_from_cache), plain values land on the LIVE object immediately.
+# The recompile (Ctrl+Enter / Run) still owns code, new names, and source truth.
+
+def _usable_parse_entry(k, v):
+    """A parsed entry that can land on a live object as-is: a real identifier
+    key (Comment keys aren't), public, and a plain VALUE — not a nested parse
+    dict and not a CodeLine (a str SUBCLASS holding unparsed source text, not
+    the value)."""
+    if not isinstance(k, str) or not k.isidentifier() or k.startswith("_"):
+        return False
+    return not isinstance(v, (dict, CodeLine))
+
+
+def _differs(cur, v):
+    try:
+        return not (cur is v or cur == v)
+    except Exception:
+        return True  # incomparable (e.g. ndarray) - treat as different
+
+
+def _is_funcdef_parse(v):
+    """A nested funcdef parse (method / function child dict).
+
+    Now a FunctionParse by TYPE (cst_funcdef_to_dict emits one). The 'parameters'/
+    'locals' key heuristic is kept as a fallback for any GeneralParse not produced
+    by that converter — CallParse holds call KWARGS under the same dict shape, so
+    it stays explicitly excluded from the heuristic branch."""
+    return isinstance(v, FunctionParse) or (
+        isinstance(v, GeneralParse) and not isinstance(v, CallParse)
+        and ("parameters" in v or "locals" in v))
+
+
+def _is_classdef_parse(v):
+    """A nested classdef parse (a class child dict, e.g. Toggles.InvalidateTracker).
+
+    Now a ClassParse by TYPE (cst_classdef_to_dict emits one). The __cst__ ClassDef
+    check is kept as a fallback for any GeneralParse not produced by that converter.
+    Either way this is precise where the funcdef key heuristic is not, so it's
+    checked FIRST by callers."""
+    return isinstance(v, ClassParse) or (
+        isinstance(v, GeneralParse) and isinstance(v.get("__cst__"), cst.ClassDef))
+
+
+def _raw_function(obj):
+    """The plain FunctionType behind a member: through decorator wrappers
+    (inspect.unwrap), static/classmethod descriptors, and bound methods.
+    None when there's no real function (a property, a non-callable, ...)."""
+    if isinstance(obj, (staticmethod, classmethod)):
+        obj = obj.__func__
+    if inspect.ismethod(obj):
+        obj = obj.__func__
+    try:
+        obj = inspect.unwrap(obj)
+    except Exception:
+        return None
+    return obj if isinstance(obj, types.FunctionType) else None
+
+
+def _apply_param_defaults(raw, params) -> bool:
+    """Land edited parameter defaults on the live function's __defaults__ /
+    __kwdefaults__ — the same members the real hotswap patches, so a later
+    recompile simply re-asserts them. The parse maps every param name (NO_DEFAULT
+    for default-less ones); only names that exist in the live default sets are
+    touched, so an added/removed parameter still needs the recompile."""
+    try:
+        sig = inspect.signature(raw)
+    except (TypeError, ValueError):
+        return False
+    applied = False
+
+    pos = [p for p in sig.parameters.values()
+           if p.kind in (p.POSITIONAL_ONLY, p.POSITIONAL_OR_KEYWORD)]
+    defaults = list(raw.__defaults__ or ())
+    offset = len(pos) - len(defaults)
+    if offset >= 0:
+        changed_pos = False
+        for i, p in enumerate(pos[offset:]):
+            v = params.get(p.name, NO_DEFAULT)
+            if isinstance(v, type(NO_DEFAULT)) or not _usable_parse_entry(p.name, v):
+                continue
+            if _differs(defaults[i], v):
+                defaults[i] = v
+                changed_pos = True
+        if changed_pos:
+            raw.__defaults__ = tuple(defaults)
+            applied = True
+
+    kwd = raw.__kwdefaults__
+    if kwd:
+        new_kwd = dict(kwd)
+        changed_kw = False
+        for name, cur in kwd.items():
+            v = params.get(name, NO_DEFAULT)
+            if isinstance(v, type(NO_DEFAULT)) or not _usable_parse_entry(name, v):
+                continue
+            if _differs(cur, v):
+                new_kwd[name] = v
+                changed_kw = True
+        if changed_kw:
+            raw.__kwdefaults__ = new_kwd
+            applied = True
+    return applied
+
+
+# Instructions that read a co_consts slot (3.12): a slot referenced by more
+# than one of these is shared (the compiler dedups equal literals) and is
+# never patched.
+_CONST_REF_OPS = {"LOAD_CONST", "RETURN_CONST", "KW_NAMES"}
+
+
+def _const_like(v):
+    if isinstance(v, (int, float, complex, str, bytes, bool, type(None))):
+        return True
+    if isinstance(v, (tuple, frozenset)):
+        return all(_const_like(x) for x in v)
+    return False
+
+
+def _apply_const_locals(raw, locals_) -> bool:
+    """Patch `name = <literal>` body assignments straight into co_consts via
+    code.replace — no compile, the code object's identity lineage stays intact.
+
+    Conservative by construction; a swap happens ONLY when the binding is
+    unambiguous in the bytecode:
+      • the name is stored exactly once in the function (a reassigned name —
+        `x` + `x#1` keys — or a computed value drops out), and
+      • that store is fed directly by LOAD_CONST, and
+      • the const slot is referenced by exactly one instruction in the whole
+        code object — the compiler dedups equal literals, so `x = 2.0` and
+        `foo(2.0)` can share a slot, and patching it would silently change
+        the other use.
+    Everything ambiguous waits for the real recompile."""
+    import dis
+    code = raw.__code__
+    store_idx = {}    # local name -> co_consts index (None = multi/computed)
+    ref_counts = {}   # co_consts index -> referencing-instruction count
+    prev = None
+    try:
+        for ins in dis.get_instructions(code):
+            if ins.opname in _CONST_REF_OPS and ins.arg is not None:
+                ref_counts[ins.arg] = ref_counts.get(ins.arg, 0) + 1
+            if ins.opname == "STORE_FAST":
+                if ins.argval in store_idx:
+                    store_idx[ins.argval] = None
+                elif prev is not None and prev.opname == "LOAD_CONST":
+                    store_idx[ins.argval] = prev.arg
+                else:
+                    store_idx[ins.argval] = None
+            prev = ins
+    except Exception:
+        return False
+
+    consts = list(code.co_consts)
+    changed = False
+    for k, v in locals_.items():
+        if not _usable_parse_entry(k, v) or not _const_like(v):
+            continue
+        idx = store_idx.get(k)
+        if idx is None or ref_counts.get(idx, 0) != 1:
+            continue
+        if not _differs(consts[idx], v):
+            continue
+        consts[idx] = v
+        changed = True
+    if changed:
+        try:
+            raw.__code__ = code.replace(co_consts=tuple(consts))
+        except Exception:
+            return False
+    return changed
+
+
+def _apply_function_parse(fn, parsed) -> bool:
+    """Live-apply a funcdef parse: parameter defaults + constant locals."""
+    raw = _raw_function(fn)
+    if raw is None or not isinstance(parsed, dict):
+        return False
+    applied = False
+    params = parsed.get("parameters")
+    if isinstance(params, dict):
+        applied |= _apply_param_defaults(raw, params)
+    locals_ = parsed.get("locals")
+    if isinstance(locals_, dict):
+        applied |= _apply_const_locals(raw, locals_)
+    return applied
+
+
+def _apply_class_parse(cls, parsed) -> bool:
+    """Live-apply a classdef parse: plain class vars via setattr, method child
+    dicts via the function path (param defaults + constant locals), and NESTED
+    classes by RECURSING onto the live nested class.
+
+    The recursion is what lets an edit to a class nested inside `cls` (e.g.
+    Toggles.InvalidateTracker.invalidate_stack_trace) land on the live object in
+    place — its plain vars and method defaults apply immediately, the same
+    responsive preview the top-level class gets, instead of waiting for the full
+    recompile. Structural changes (new/removed members) still need the recompile,
+    exactly as at the top level.
+
+    `__init__` self-assignments surface as fields too but fail the hasattr
+    check (instance attrs, not class vars); decorators / CallParse stay nested
+    dicts and are skipped."""
+    applied = False
+    for k, v in parsed.items():
+        if not isinstance(k, str) or not k.isidentifier() or k.startswith("_"):
+            continue
+        # Nested class FIRST: a classdef parse carries an unambiguous cst.ClassDef
+        # marker, whereas _is_funcdef_parse is a key heuristic that a class member
+        # literally named `parameters`/`locals` would trip.
+        if _is_classdef_parse(v):
+            member = inspect.getattr_static(cls, k, None)
+            if isinstance(member, type) and _apply_class_parse(member, v):
+                applied = True
+                # The outer invalidate (live_apply_edits) keys off `cls`, so it
+                # never reaches a tile drawn from the nested class - trigger it
+                # here, the same way live_apply_edits repaints its outer source.
+                if Melty.cache is not None:
+                    Melty.cache.invalidate_up_by_obj(member, max_depth=10)
+            continue
+        if _is_funcdef_parse(v):
+            member = inspect.getattr_static(cls, k, None)
+            if member is not None:
+                applied |= _apply_function_parse(member, v)
+            continue
+        if isinstance(v, (dict, CodeLine)):
+            continue
+        if not hasattr(cls, k):
+            continue
+        try:
+            cur = getattr(cls, k)
+            if cur is v or cur == v:
+                continue
+        except Exception:
+            pass  # incomparable (e.g. ndarray) - fall through and set
+        try:
+            setattr(cls, k, v)
+            applied = True
+        except Exception:
+            pass
+    return applied
+
+
+def _apply_module_parse(mod, parsed) -> bool:
+    """Live-apply a module parse: dispatch each top-level entry on the LIVE
+    object — classes through the class path, functions through the function
+    path, plain existing globals via setattr."""
+    applied = False
+    for k, v in parsed.items():
+        if not isinstance(k, str) or not k.isidentifier() or k.startswith("_"):
+            continue
+        if k not in mod.__dict__:
+            continue
+        live = mod.__dict__[k]
+        if isinstance(v, GeneralParse) and not isinstance(v, CallParse):
+            if isinstance(live, type):
+                applied |= _apply_class_parse(live, v)
+            elif _is_funcdef_parse(v):
+                applied |= _apply_function_parse(live, v)
+            continue
+        if isinstance(v, (dict, CodeLine)):
+            continue
+        try:
+            if not _differs(live, v):
+                continue
+            setattr(mod, k, v)
+            applied = True
+        except Exception:
+            pass
+    return applied
+
+
+@lag_traced("live_apply_edits", 50)
+def live_apply_edits(source, gp) -> None:
+    """Entry point: drive the LIVE source object from its edited cst_dict.
+
+    `gp` is the module-shaped parse of the edited span — a class/function span
+    keys its parse under __name__; a module span IS the parse. Unknown source
+    types (CallSite, Decorations, None) no-op. On apply, repaint cached views
+    drawn from the source (same invalidation the real recompile does)."""
+    if not isinstance(gp, dict):
+        return
+    applied = False
+    if isinstance(source, type):
+        inner = gp.get(source.__name__)
+        if isinstance(inner, dict):
+            applied = _apply_class_parse(source, inner)
+    elif isinstance(source, types.FunctionType):
+        inner = gp.get(source.__name__)
+        if isinstance(inner, dict):
+            applied = _apply_function_parse(source, inner)
+    elif isinstance(source, types.ModuleType):
+        applied = _apply_module_parse(source, gp)
+    if applied and Melty.cache is not None:
+        if isinstance(source, types.FunctionType):
+            Melty.cache.invalidate_up_by_func(source, max_depth=10)
+        else:
+            Melty.cache.invalidate_up_by_obj(source, max_depth=10)
+
+
+def _live_apply_class_vars(cls: type, gp: dict) -> None:
+    """Back-compat alias — the class entry of live_apply_edits."""
+    live_apply_edits(cls, gp)
+
+
+from meltygui.view.code_view import run_button
+
+
+@render_func(use_cache=True, selectable=False)
+def address_to_general_parse(input_value: Address, pending=False, unique=None, changed=False, draw_state=None, auto_load=True, load=False):
+    """Load node: class → cst.Module.
+
+    - Resolves Address from the class on first call
+    - Watches file mtime for external changes
+    - Shows Load / Revert buttons when file changes on disk
+    - Returns (True, cst.Module) when loaded, (False, cached) otherwise
+    """
+    if draw_state.frame_count < 2 and auto_load:
+        load = True
+
+    from meltygui.view.control_view import button
+    file_name = input_value.path.name if input_value.path is not None else "Unknown file"
+    folder_icon = ""
+    # if button(f"{folder_icon} {file_name}", height=30, value=0.4, saturation=1.5)[0]:
+    #     from meltygui.utils.jump_to_code import open_in_intellij
+    #     line_number = input_value.start + 1 if input_value.start is not None else None
+    #     threading.Thread(
+    #         target=open_in_intellij,
+    #         args=(str(input_value.path),),
+    #         kwargs={"line_number": line_number},
+    #         daemon=True,
+    #     ).start()
+
+    # Last-compiled indicator: shows the wall-clock time of the most recent
+    # recompile for this file (Ctrl+Enter or the do_recompile button).
+    compile_time = get_compile_time(input_value)
+    if compile_time is not None:
+        check_icon = ""
+        imgui.same_line()
+        imgui.align_text_to_frame_padding()
+        imgui.text_colored(f"{check_icon} compiled {time.strftime('%H:%M:%S', time.localtime(compile_time))}",
+                           0.55, 0.8, 0.55, 1.0)
+
+    if pending or changed:
+        clicked, result = run_button(load_cst_module, with_kwargs={"input_value": input_value},
+                                     clicked=load, name=f"load_cst_module{unique}")
+        if clicked:
+            return result
+
+    # ── Steady state ──────────────────────────────────────────
+    return False, None
+
+@render_func(use_cache=True, selectable=False)
+def general_parse_to_address(input_value: GeneralParse=None, pending=False, draw_state=None, unique=None,
+                             changed=False, recompile=False, save=False, s_key_pressed=None,
+                             enter_key_pressed=None, ensure_import=None):
+    """GeneralParse dict → Address. Handles recompile and save for any source type.
+
+    ensure_import=(module, name) is forwarded to _do_save so a synthesized
+    decorator (e.g. @defaults) gets its import inserted in the same write."""
+    address = input_value.address
+    if not isinstance(address, Address):
+        imgui.text_colored("Saving unavailable...\ninput_value.address is not set",
+                           1.0, 0.0, 0.0)
+        return False, None
+    source = address.source
+
+    # Edits drive the live object immediately (live preview): class vars,
+    # function arg defaults, constant locals, module globals. The
+    # recompile/hotswap below still owns code, new names, and source truth.
+    if changed and source is not None:
+        live_apply_edits(source, input_value)
+
+    # Latch the save intent across the background dict_to_cst latency. An edit
+    # (focus Add/Delete, a single color pick) sets changed=True for ONE frame -
+    # which lands exactly on dict_to_cst's Pending and is gone by the time the
+    # conversion completes, so the save was just dropped. Hold the intent until
+    # _do_save actually completes, then clear it.
+    if changed:
+        draw_state._lens_save_pending = True
+    save_pending = getattr(draw_state, '_lens_save_pending', False)
+
+    # Ctrl+Enter fires HERE (before this frame's dict→Cst conversion while the Run
+    # button fires below (after it). They used to read different sources - the
+    # stale loaded `input_value.source` vs the freshly materialized `code_str` -
+    # so Ctrl+Enter hotswapped the on-disk version. Unify them on ONE source: the
+    # PendingSave cache. The materialized edit is written through to it below, and
+    # every trigger reads from it via `_edited_source`, falling back to the passed
+    # value only when the cache is cold (never edited / just loaded).
+    from meltygui.editor.pending_save import PendingSave
+    from meltygui.code.new_codecs import type_to_codec
+    codec = next((type_to_codec[k] for k in type(source).__mro__ if k in type_to_codec), None) \
+        if source is not None else None
+
+    def _edited_source(fallback):
+        cached = PendingSave.pending_text_for(address)
+        return cached if cached is not None else fallback
+
+    show_recompile = True
+    show_save = not save or pending or changed or save_pending
+
+    save_hotkey = s_key_pressed and s_key_pressed.ctrl
+    if save_hotkey:
+        _do_save(address, code_str=_edited_source(input_value.source))
+        Melty.cache.invalidate_up(draw_state.parent_window._tile_id, max_depth=10)
+
+    # Ctrl+Enter: hotswap the edited code without writing to disk. Mirrors the
+    # Ctrl+S save hotkey above, but routes through do_recompile instead.
+    recompile_hotkey = enter_key_pressed and enter_key_pressed.ctrl
+    if recompile_hotkey and source is not None:
+        do_recompile(input_value=source, code_str=_edited_source(input_value.source), file_path=address.path)
+        record_compile(address)
+        Melty.cache.invalidate_up(draw_state.parent_window._tile_id, max_depth=10)
+
+    # Skip expensive dict→CST conversion when neither block will execute
+    if not show_recompile and not show_save:
+        return False, address
+
+    convert_finished, back_to_cst = dict_to_cst(input_value=input_value, changed=changed)
+    if isinstance(back_to_cst, Pending):
+        if back_to_cst.state == PendingState.ERROR:
+            # Conversion failed (e.g. unparseable edit) - give up the latch so it
+            # doesn't spin requesting renders forever.
+            draw_state._lens_save_pending = False
+        elif save_pending:
+            # Still converting. Keep the latch + keep frames coming so the save
+            # fires the moment the (background) code_str lands.
+            request_render()
+        return False, back_to_cst
+    code_str = back_to_cst.code
+    # Write the freshly materialized edit through to the PendingSave cache so the
+    # next Ctrl+Enter / Run / load all read THIS source instead of disk. Only while
+    # an edit is active (never from plain view), keyed by address so it refreshes the
+    # entry in place. _do_save below still writes to disk this frame, so the
+    # eventual apply_all_saves flush of this entry is an idempotent no-op.
+    if codec is not None and (changed or save_pending):
+        PendingSave.queue_save(address, codec, data=code_str, ensure_import=ensure_import)
+    if show_recompile:
+        if source is not None:
+            from meltygui.core.rendering.mode import Mode
+            recompiled, _ = run_button(do_recompile, clicked=recompile and pending, name=f"do_recompile{unique}",
+                        with_kwargs={"input_value": address.source,
+                                 "code_str": _edited_source(code_str),
+                                 "file_path": address.path}, layer_offset=1, pin_to_clip=Pin.CLIP,
+                                       parent_anchor=Anchor.BOTTOM_LEFT,
+                                       tint=(0.3, 0.4, 0.6))
+            if recompiled:
+                record_compile(address)
+                # Refresh the cached file path node so its compiled indicator updates.
+                Melty.cache.invalidate_up(draw_state.parent_window._tile_id, max_depth=10)
+
+            imgui.dummy(1,1)
+    if show_save:
+        if source is not None:
+            clicked, result = run_button(_do_save, with_kwargs={"input_value": address,
+                                         "code_str": code_str,
+                                         "ensure_import": ensure_import},
+                                         clicked=save or save_pending)
+            # We reached a real code_str and dispatched the write to the background
+            # thread, which writes regardless of further pumping. Clear the latch
+            # on dispatch (not on completion) so an errored/never-completing save
+            # can't spin the latch forever; Background invalidates on completion.
+            draw_state._lens_save_pending = False
+            if clicked:
+                if draw_state.parent_window is not None:
+                    Melty.cache.invalidate_up(draw_state.parent_window._tile_id, max_depth=10)
+                return True, address
+    return False, address
+
+
+# ╔══════════════════════════════════════════════════════════════════════════════╗
+# ║                                focus: a reversible lens node                                      ║
+# ╚══════════════════════════════════════════════════════════════════════════════╝
+
+def _focus_get(obj, key):
+    return obj.get(key) if isinstance(obj, dict) else getattr(obj, key, None)
+
+
+def _focus_set(obj, key, value):
+    if isinstance(obj, dict):
+        obj[key] = value
+    else:
+        setattr(obj, key, value)
+
+
+@render_func(use_cache=False, show_bg=False, selectable=False, is_tree=False, with_header=draw_header)
+def focus(input_value, path=(), default=None, kind=None, draw_state=None, unique=None, changed=False, **kwargs):
+    """Descend a STATIC key `path` into `input_value` to a single leaf, render
+    that leaf with its normal renderer (draw_tuple, for a tint), and write any
+    edit back into the container *in place*.
+
+    This is the one primitive that turns the existing reversible converter pairs
+    (class_to_address ↔ address_to_class, address_to_general_parse ↔
+    general_parse_to_address) into full read/write lenses: drop `focus` where
+    `draw_collection` would sit in a chain and it edits just the focused leaf.
+
+    Contract — identical to every other chain node: returns (changed, value).
+      - read   : leaf exists → render the picker; (False, input_value) until edited.
+      - write  : on a picker edit, mutate container[path] and return (True, input_value)
+                 so a downstream save node runs once.
+      - add    : leaf missing → show a "+ Add" button; clicking creates the leaf
+                 (and any missing intermediate dicts) with `default` and returns
+                 (True, input_value), so the same save node persists the new value
+                 (e.g. writes a fresh `# [tint=(...)]` comment for a code source).
+
+    `path` is a constant supplied by the lens definition — it is NEVER stored in
+    draw_state (which is GC'd on a short TTL). The only transient thing is
+    `input_value`, the container reference flowing through the chain; it lives for
+    this frame only. The reverse direction works because we keep the parent
+    container in the value — the same move Address makes by carrying `.source`.
+
+    Handles dict-key and attribute access uniformly, so the same node focuses aj
+    GeneralParse dict (code-comment / decoration tint), a draw_state, or a data
+    class instance.
+    """
+    from meltygui.view.collection_view import draw_tuple
+    from meltygui.view.control_view import button
+
+    changed, new_value = False, input_value
+    if not path:
+        imgui.text_colored("focus: empty path", 1.0, 0.4, 0.0)
+        return False, input_value
+
+    leaf_key = path[-1]
+
+    # Walk to the leaf's parent; note where (if anywhere) the chain breaks so the
+    # add path knows it many containers to create.
+    parent = input_value
+    reachable = True
+    for key in path[:-1]:
+        nxt = _focus_get(parent, key)
+        if nxt is None:
+            reachable = False
+            break
+        parent = nxt
+
+    leaf = _focus_get(parent, leaf_key) if reachable else None
+
+    # Clean label: the lens name + a plain target name - the class for code
+    # lenses, the enclosing fn for the caller, the data class for an instance.
+    # No internal keys (__overrides__ etc.); the "where" lives in the jump button.
+    if len(path) > 1:
+        target = str(path[0])                        # class name (code lenses)
+    elif isinstance(input_value, dict):
+        _a = input_value.get("__address__")
+        target = getattr(getattr(_a, "source", None), "__name__", None) \
+            if isinstance(_a, Address) else None     # caller's enclosing fn
+    elif input_value is not None and type(input_value).__name__ != "DrawState":
+        target = type(input_value).__name__          # data instance class
+    else:
+        target = None
+    base = kind or str(draw_state.name)
+    label = f"{base} · {target}" if target else base
+
+    imgui.same_line()
+    imgui.text(label)
+
+    # Code-jump button - open the source where this lens's value lives. The call
+    # dict carries __address__; a GeneralParse carries .address. Live other values
+    # (draw_state / instance) have no source location, so no button is shown.
+    _addr = input_value.get("__address__") if isinstance(input_value, dict) else None
+    if _addr is None:
+        _addr = getattr(input_value, "address", None)
+
+    if isinstance(_addr, Address) and _addr.path is not None:
+        _line = (_addr.start or 0) + 1
+        imgui.same_line()
+        if button(f"{_addr.path.name}:{_line}##{unique}", height=24, name=f"jump{base}{leaf_key}{unique}")[0]:
+            import threading
+            from meltygui.utils.jump_to_code import open_in_intellij
+            threading.Thread(target=open_in_intellij, args=(str(_addr.path),),
+                             kwargs={"line_number": _line}, daemon=True).start()
+
+    # ── Present: the reusable picker (every lens funnels through this) ─────────
+    if leaf is not None:
+        tint_changed, new_tint = draw_tuple(leaf, with_header=draw_header, name=f"{unique}{leaf_key}_tuple_{unique}")
+        if tint_changed:
+            _focus_set(parent, leaf_key, new_tint)
+            changed, new_value = True, input_value  # hand the mutated container to the save node
+        # Delete: drop this source's override so it stops winning. For a dict
+        # (code/caller) the key is popped → dict_to_cst() removes it from source on
+        # save; for a live attr it's set to None. Return changed so the save side
+        # persists the removal, same as an edit.
+        imgui.same_line()
+
+        delete_icon = ""
+        if button(f"{delete_icon}##{unique}", name=f"{leaf_key}_delete_{unique}", height=26)[0]:
+            if isinstance(parent, dict):
+                parent.pop(leaf_key, None)
+            else:
+                _focus_set(parent, leaf_key, None)
+            changed, new_value = True, input_value
+    else:
+
+        # ── Not present: offer to add it ───────────────────────────────────────────────
+        if button(f"##{leaf_key}{unique}", name=f"{leaf_key}_add_{unique}", height=26)[0]:
+            node = input_value
+            for key in path[:-1]:           # create missing intermediate containers
+                child = _focus_get(node, key)
+                if child is None:
+                    child = {}
+                    _focus_set(node, key, child)
+                node = child
+            try:
+                _focus_set(node, leaf_key, default if default is not None else (0.485, 0.61, 0.76))
+                changed, new_value = True, input_value
+
+            except Exception as e:
+                print_stack_trace(exception=e)
+                print("Error setting value in focus node:", e)
+                changed, new_value = False, input_value
+
+    return changed, new_value
+
+
+# ╔══════════════════════════════════════════════════════════════════════════════╗
+# ║  Caller kwarg lens nodes: edit a kwarg literal at the call site                ║
+# ╚══════════════════════════════════════════════════════════════════════════════╝
+#
+# These let the context menu edit `draw_text(..., tint=(1,0,1))` by parsing the
+# CALLER's statement. The call site comes from draw_state._call_site - the
+# (filename, lineno) resolved once (via caller_site) when frames were grabbed on
+# menu-open in core_render; never re-walked from the live stack. Reuses the
+# existing cst_call_to_dict / dict_to_cst_call converters (the same ones that
+# parse @decorator(...) calls).
+
+_DISPATCH_SKIP = ("core_render.py",)  # the render_func wrapper lives here
+
+
+def _is_dispatch_frame(filename, func_name):
+    """True if a frame is render-dispatch machinery to skip when resolving call
+    sites — the render_func wrapper, Melty.draw / draw_any re-dispatch, or a
+    user-configured shell in Toggles.ignore_call_from (matched by func name, any
+    file). Shared by caller_site and caller_sites so both filter identically."""
+    base = filename.rsplit("/", 1)[-1].rsplit("\\", 1)[-1]
+    if base in _DISPATCH_SKIP:                                  # render_func wrapper
+        return True
+    # Func-name-specific (NOT whole file): new_core_view.py / meltygui.py also hold
+    # real user app code, so only their dispatch frames are skipped.
+    if base == "meltygui.py" and func_name == "draw":             # Melty.draw re-dispatch
+        return True
+    if base == "new_core_view.py" and func_name == "draw_any":  # draw_any dispatch
+        return True
+    # User-configurable wrapper/dispatch shells (RenderFuncs._draw, the user_*
+    # render shells).
+    if func_name in Toggles.ignore_call_from:
+        return True
+    return False
+
+
+def caller_sites(frames):
+    """Every real caller (filename, lineno), innermost-first, with the render-
+    dispatch machinery and Toggles.ignore_call_from shells filtered out — the
+    chain of user draw_x(...) calls that produced this view, from the nearest
+    caller outward. draw_context_menu draws one code_file_io per entry.
+
+    Returning just (filename, lineno) tuples is critical: the frames list carries
+    each frame's f_locals (the whole AppModel, tensors, cyclic refs). Feeding that
+    into draw_any/render_func would hash/compare it and hang."""
+    if not frames:
+        return []
+    # frames is outermost-first; keep innermost-first so the list runs from the
+    # nearest caller outward.
+    return [(entry[0], entry[1]) for entry in reversed(frames)
+            if not _is_dispatch_frame(entry[0], entry[2])]
+
+
+def caller_site(frames):
+    """The nearest real caller (filename, lineno) — the first entry of
+    caller_sites, or None. The lens root (caller_arg) reads this for a single
+    cheap-to-hash tuple; see caller_sites for the filtering rationale."""
+    sites = caller_sites(frames)
+    return sites[0] if sites else None
+
+
+def call_stack_frames(frames):
+    """The WHOLE call stack as lightweight (filename, lineno, func_name) tuples,
+    innermost-first and UNFILTERED. draw_context_menu renders the full stack and
+    decides PER-FRAME (via _is_dispatch_frame) whether to show a plain label
+    (machinery / ignored shell) or an editable code_file_io (a real call site) —
+    so the filtering lives in the render, not here.
+
+    Carries func_name (for the filter decision and the view's name) on top of what
+    caller_sites returns, but still drops the frame's f_locals / source-line, so
+    it stays cheap to hold and hash (see caller_sites)."""
+    if not frames:
+        return []
+    return [(entry[0], entry[1], entry[2]) for entry in reversed(frames)]
+
+
+def caller_func_name(call_stack):
+    """The func_name of the nearest real caller in a cached _call_stack (the
+    innermost non-dispatch frame) — the function whose body holds the draw_x(...)
+    call, matching caller_site's (filename, lineno). None if no real caller.
+
+    Operates on the already-cached _call_stack tuples (filename, lineno,
+    func_name), so it never touches the live stack."""
+    for filename, lineno, func_name in call_stack:
+        if not _is_dispatch_frame(filename, func_name):
+            return func_name
+    return None
+
+
+def caller_chain(call_stack):
+    """Every real caller in a cached _call_stack, innermost-first, dispatch
+    machinery and Toggles.ignore_call_from shells filtered out — one
+    (filename, lineno, func_name) per user draw_x(...) call up the stack
+    (caller, caller's caller, ...). The N-step generalization of caller_site /
+    caller_func_name: those return the head of this list.
+
+    Operates on the already-cached _call_stack tuples, so it never re-walks the
+    live stack — a drag re-renders with parents skipped, which would shift every
+    site (see the capture note in core_render)."""
+    return [(filename, lineno, func_name)
+            for filename, lineno, func_name in (call_stack or ())
+            if not _is_dispatch_frame(filename, func_name)]
+
+
+def _first_call(module):
+    """The outermost cst.Call in a parsed statement (don't descend into nested
+    calls), or None."""
+    found = {}
+
+    class _V(cst.CSTVisitor):
+        def visit_Call(self, node):
+            if 'c' not in found:
+                found['c'] = node
+            return False  # outermost only
+
+    module.visit(_V())
+    return found.get('c')
+
+
+def _modules_for_file(target_path):
+    """EVERY live module whose __file__ resolves to target_path, most-populated
+    first. One file can sit in sys.modules under two names (the src./non-src
+    dual identity), and one of the twins can be a barely-populated stub that
+    never executed its body — sorting by vars() size puts the real, executed
+    module ahead of the stub so callers that take the first match resolve
+    against actual functions.
+
+    Filters on basename before the (syscall-heavy) Path.resolve() so we don't
+    stat every module in sys.modules — that loop was a measurable chunk of the
+    tint-tab open cost."""
+    import sys
+    target_name = target_path.name
+    found = []
+    for m in list(sys.modules.values()):
+        f = getattr(m, "__file__", None)
+        if not f:
+            continue
+        if f.rsplit("/", 1)[-1].rsplit("\\", 1)[-1] != target_name:
+            continue
+        try:
+            if Path(f).resolve() == target_path:
+                found.append(m)
+        except (OSError, ValueError):
+            continue
+    found.sort(key=lambda m: len(vars(m)), reverse=True)
+    return found
+
+
+def _module_for_file(target_path):
+    """The live module object whose __file__ resolves to target_path, or None —
+    the most-populated twin when the file is imported under several names."""
+    mods = _modules_for_file(target_path)
+    return mods[0] if mods else None
+
+
+# (filename, lineno, mtime) -> resolved function object (or None). Keyed on mtime
+# so a hotswap/edit of the file invalidates the entry; the sys.modules walk +
+# co_firstlineno scan is otherwise repeated every time the caller row is shown.
+_ENCLOSING_FN_CACHE = {}
+
+# str(path) -> resolved Path. Session-stable; resolve() is ~30 syscall/GIL
+# round-trips per _enclosing_function(), per frame under the live-view
+# overlay (the other half of the 2026-07-31 render-thread realpath samples).
+_RESOLVED_PATH_CACHE = {}
+
+
+def _resolved(path_str):
+    got = _RESOLVED_PATH_CACHE.get(path_str)
+    if got is None:
+        if len(_RESOLVED_PATH_CACHE) > 4096:
+            _RESOLVED_PATH_CACHE.clear()
+        got = _RESOLVED_PATH_CACHE[path_str] = Path(path_str).resolve()
+    return got
+
+
+# str(path) -> (mtime, monotonic checked). The stat below runs per visible
+# FunctionDef per frame via the live-view overlay's _scope_function (~12% of
+# draw_text in profiling); a short TTL keeps the mtime-keyed invalidation in
+# _ENCLOSING_FN_CACHE while collapsing the per-frame stat storm. An edit is
+# picked up within the TTL, same effect as a debounced reparse.
+_MTIME_TTL_CACHE = {}
+_MTIME_TTL_S = 0.25
+
+
+def _stat_mtime_ttl(target):
+    now = time.monotonic()
+    key = str(target)
+    got = _MTIME_TTL_CACHE.get(key)
+    if got is not None and now - got[1] < _MTIME_TTL_S:
+        return got[0]
+    try:
+        mtime = target.stat().st_mtime
+    except OSError:
+        mtime = None
+    if len(_MTIME_TTL_CACHE) > 4096:
+        _MTIME_TTL_CACHE.clear()
+    _MTIME_TTL_CACHE[key] = (mtime, now)
+    return mtime
+
+
+def _enclosing_function(filename, lineno):
+    """The live function object whose `def` encloses (filename, lineno) — the
+    nearest def at or above the line, walking module + class scopes. Lets the
+    caller lens hotswap that function after a literal in its body is edited.
+    Returns None for closures/nested funcs not reachable from module vars."""
+    try:
+        target = _resolved(str(filename))
+    except (OSError, ValueError):
+        return None
+    mtime = _stat_mtime_ttl(target)
+    cache_key = (str(target), lineno, mtime)
+    if cache_key in _ENCLOSING_FN_CACHE:
+        return _ENCLOSING_FN_CACHE[cache_key]
+    # Walk EVERY module twin for the file (src./non-src dual identity): the
+    # first might be an unexecuted stub whose vars hold no functions.
+    modules = _modules_for_file(target)
+    if not modules:
+        _ENCLOSING_FN_CACHE[cache_key] = None
+        return None
+    best = {"fn": None, "line": -1}
+
+    def consider(fn):
+        inner = inspect.unwrap(fn)
+        code = getattr(inner, "__code__", None)
+        if code is None:
+            return
+        try:
+            same = _resolved(code.co_filename) == target
+        except (OSError, ValueError):
+            same = code.co_filename == str(target)
+        if same and code.co_firstlineno <= lineno and (
+                code.co_firstlineno > best["line"]
+                # Tie (same def line): the fn-run path's parked exec twin
+                # (`_fnrun_live_<name>`, __fnrun_exec__) that the object runs
+                # publish to and prune on - it must win over the module's
+                # real function, which comes earlier in the module dict, or
+                # the lens reads one store while runs fill it.
+                or (code.co_firstlineno == best["line"]
+                    and getattr(inner, "__fnrun_exec__", False)
+                    and not getattr(best["fn"], "__fnrun_exec__", False))):
+            best["line"] = code.co_firstlineno
+            best["fn"] = inner
+
+    seen = set()
+
+    def walk(scope):
+        # Descend only into classes DEFINED in the file's modules: an imported
+        # class can be self-referential (ctypes.c_ubyte.__ctype_be__ → c_ubyte -
+        # `from OpenGL.GL import *` puts it in filter.py's namespace) and recursed
+        # to the stack limit (09-04). `seen` is the backstop for cycles between
+        # own classes; foreign classes hold no def from this file anyway.
+        if id(scope) in seen:
+            return
+        seen.add(id(scope))
+        for val in list(vars(scope).values()):
+            if isinstance(val, types.FunctionType):
+                consider(val)
+            elif isinstance(val, (staticmethod, classmethod)):
+                f = getattr(val, "__func__", None)
+                if isinstance(f, types.FunctionType):
+                    consider(f)
+            elif isinstance(val, type) and getattr(val, "__module__", None) in module_names:
+                walk(val)
+
+    module_names = {getattr(m, "__name__", None) for m in modules}
+
+    for module in modules:
+        walk(module)
+    _ENCLOSING_FN_CACHE[cache_key] = best["fn"]
+    return best["fn"]
+
+
+def _resolve_call_address(input_value):
+    """(filename, lineno) -> Address of the enclosing call STATEMENT, with the
+    enclosing function attached as .source.
+
+    Plain function (no imgui, no draw_state) so it can run on a Background thread.
+    Uses the stdlib `ast` module (C-accelerated) to find the outermost Call
+    covering the line, so multi-line calls round-trip as one statement.
+
+    NOTE: do NOT use libcst's MetadataWrapper+PositionProvider here. That pass is
+    pure-Python and O(whole file); on a large caller file (new_core_view.py) it
+    took ~1.1s AND, being CPU-bound, held the GIL — starving the render thread for
+    the duration (an 800ms+ frame stall). ast.parse + ast.walk does the same span
+    lookup in single-digit ms because the parse is in C. The small per-statement
+    span is re-parsed with libcst downstream (address_to_call_parse), where the
+    cost is bounded by the statement, not the file."""
+    import ast
+    filename, lineno = input_value
+    path = Path(filename)
+    address = Address(path, lineno - 1, lineno)  # line default
+    try:
+        src_text = path.read_text(encoding='utf-8')
+        tree = ast.parse(src_text, filename=str(path))
+        best_key = None
+        best_node = None
+        for node in ast.walk(tree):
+            if not isinstance(node, ast.Call):
+                continue
+            start = node.lineno
+            end = getattr(node, 'end_lineno', None) or start
+            if start <= lineno <= end:
+                key = (start, -end)  # outermost wins
+                if best_key is None or key < best_key:
+                    best_key = key
+                    best_node = node
+        if best_node is not None:
+            s = best_node.lineno
+            e = best_node.end_lineno or s
+            address = Address(path, s - 1, e)
+            # Column span (UTF-8 byte offsets, per ast) of the call WITHIN its
+            # line span. Lets the save / address_to_call_parse extract just the
+            # call expression even when it's embedded in a larger statement
+            # (e.g. `if ... or button(...):`) and splice the edit back without
+            # disturbing the surrounding prefix/suffix.
+            address._call_cols = (best_node.col_offset, best_node.end_col_offset)
+            # Capture the surrounding prefix/suffix here, while the file is known-
+            # valid (ast just parsed it), so CallerCodec.save has them BEFORE any
+            # save and independent of when load runs. They're intra-line fragments
+            # (no newline), so the '\n' split is newline-agnostic.
+            try:
+                span_lines = _split_lines(src_text)[s - 1:e]
+                pre, _call, suf = _split_span_at_call(
+                    span_lines, best_node.col_offset, best_node.end_col_offset, '\n')
+                address._call_prefix = pre
+                address._call_suffix = suf
+            except Exception:
+                pass
+    except Exception as ex:
+        print(f"_resolve_call_address: could not resolve call span in {filename}:{lineno}: {ex}")
+
+    # Enclosing function = recompile hint (None → save-only).
+    address.source = _enclosing_function(filename, lineno)
+    return address
+
+
+@render_func()
+def caller_to_address(input_value, draw_state, changed=False):
+    """(filename, lineno) -> Address spanning the call STATEMENT at the call site.
+
+    The actual resolution (full-file libcst parse + PositionProvider + enclosing
+    function lookup) runs on a Background thread via _resolve_call_address — never
+    on the UI thread — and is cached by (filename, lineno, mtime). Returns
+    (changed, None) while the background resolve is pending; the caller row fills
+    in once it lands. Input is the lightweight site from caller_site() — never the
+    raw frames (which carry f_locals)."""
+    if not input_value or len(input_value) != 2:
+        return changed, None
+    filename, lineno = input_value
+    path = Path(filename)
+    # Register the watch on THIS draw_state so _do_save's set_hashed_content
+    # (called with address._watcher_ds = this draw_state) actually opens the
+    # self-write suppress window; otherwise our own write bounces back as an
+    # external change. Idempotent: register_draw_state returns early if already
+    # registered.
+    FileWatch.register_draw_state(draw_state, path)
+    try:
+        mtime = path.stat().st_mtime
+    except OSError:
+        mtime = None
+    cached = getattr(draw_state, '_caller_addr_cache', None)
+    if cached is not None and cached[0] == (filename, lineno) and cached[1] == mtime:
+        return changed, cached[2]
+
+    parent_tile = (draw_state._parent._tile_id
+                   if draw_state._parent is not None else draw_state._tile_id)
+    result = Background.run(
+        _resolve_call_address,
+        user_id=str(draw_state.unique) + "|caller_addr",
+        func_kwargs={"input_value": (filename, lineno)},
+        invalidate_id=parent_tile,
+        on_frame=Melty.frame_count,
+    )
+    if isinstance(result, tuple) and len(result) == 2 and isinstance(result[1], int):
+        result = result[0]
+    if not isinstance(result, Address):
+        return changed, None  # still resolving on the background thread
+
+    result._watcher_ds = draw_state
+    draw_state._caller_addr_cache = ((filename, lineno), mtime, result)
+    return changed, result
+
+
+def _split_span_at_call(span_lines, sc, ec, newline):
+    """Split a call's line span into (prefix, call_text, suffix) at the call's
+    column offsets. `sc`/`ec` are UTF-8 byte offsets (ast convention) into the
+    first/last line, so slice in bytes and decode — correct even when the line
+    has multi-byte chars before/inside the call (e.g. font-icon literals)."""
+    first = span_lines[0].encode("utf-8")
+    last = span_lines[-1].encode("utf-8")
+    prefix = first[:sc].decode("utf-8")
+    suffix = last[ec:].decode("utf-8")
+    if len(span_lines) == 1:
+        call_text = first[sc:ec].decode("utf-8")
+    else:
+        middle = span_lines[1:-1]
+        call_text = newline.join(
+            [first[sc:].decode("utf-8")] + middle + [last[:ec].decode("utf-8")])
+    return prefix, call_text, suffix
+
+
+@render_func(use_cache=True)
+def address_to_call_parse(input_value, draw_state=None, changed=False, load=False):
+    """Address(call statement) -> dict of the call's kwargs via cst_call_to_dict.
+
+    Carries the enclosing span module + address on the dict (dunder keys, ignored
+    by focus and by dict_to_cst_call's edit scan) so the save node can write back.
+    Re-parses only when the file's mtime changes; otherwise returns the cached
+    dict so focus renders every frame."""
+    if not isinstance(input_value, Address):
+        return changed, None
+    address = input_value
+    try:
+        mtime = address.path.stat().st_mtime
+    except OSError:
+        mtime = None
+    cached = getattr(draw_state, '_call_dict_cache', None)
+    if cached is not None and cached[0] == (address.start, address.end) and cached[1] == mtime:
+        return False, cached[2]
+    try:
+        # Extract JUST the call expression from its line span using the column
+        # offsets resolved by _resolve_call_address. parse_module rejects a span
+        # that's indented or only part of a statement (e.g. `if c or button(...):`
+        # gets "expected INDENT"); slicing out the bare call sidesteps both. The
+        # prefix/suffix around the call on its first/last line are kept so the
+        # save node can splice the edit back without disturbing them.
+        data = address.path.read_bytes()
+        newline = _detect_newline(data)
+        try:
+            text = data.decode("utf-8")
+        except UnicodeDecodeError:
+            text = data.decode("latin-1")
+        span_lines = _split_lines(text)[address.start:address.end]
+        cols = getattr(address, "_call_cols", None)
+        if cols is not None and span_lines:
+            call_prefix, call_text, call_suffix = _split_span_at_call(
+                span_lines, cols[0], cols[1], newline)
+        else:
+            # No column info (ast found no embedded call, line fallback). Treat
+            # the dedented span as the call; nothing to slice around it.
+            import textwrap
+            call_text = textwrap.dedent(newline.join(span_lines))
+            call_prefix = call_suffix = ""
+        span_module = cst.parse_module(call_text)
+    except Exception as ex:
+        print(f"address_to_call_parse: parse failed for {address.path}: {ex}")
+        return False, cached[2] if cached else None
+    call_node = _first_call(span_module)
+    if call_node is None:
+        return False, None
+    converter = Melty._converters.get((cst.Call, dict))
+    d = converter(call_node)
+    d["__call_module__"] = span_module
+    d["__address__"] = address
+    d["__call_prefix__"] = call_prefix
+    d["__call_suffix__"] = call_suffix
+
+    # Human label for the picker/buttons: called-name @ file:line (enclosing fn).
+    func_node = call_node.func
+    if isinstance(func_node, cst.Name):
+        call_name = func_node.value
+    elif isinstance(func_node, cst.Attribute):
+        call_name = func_node.attr.value
+    else:
+        call_name = "call"
+    fn = getattr(address, "source", None)
+    fn_name = getattr(fn, "__name__", None)
+    line_no = (address.start or 0) + 1
+    suffix = f" ({fn_name})" if fn_name else ""
+    d["__label__"] = f"{call_name}  {address.path.name}:{line_no}{suffix}"
+
+    draw_state._call_dict_cache = ((address.start, address.end), mtime, d)
+    return True, d
+
+
+def _build_call_code(d):
+    """Edited call-kwargs dict -> the full line-span source, with the rebuilt call
+    spliced back between its original prefix/suffix.
+
+    Plain + synchronous: rebuilding one call statement (dict_to_cst_call +
+    deep_replace of a tiny span module) is microseconds, unlike the class chain's
+    whole-module reconstruction. It is NOT a background node — that was the bug:
+    as a background node it returned Pending on the edit frame, so the save branch
+    was skipped and the edit lost; and Background.run deep-hashed the CST-laden
+    dict on the UI thread every frame.
+
+    The call was parsed in isolation (just the expression), so new_module.code is
+    the bare call. We re-attach the prefix (indentation + any leading `if … or `)
+    and suffix (`[0]:`, etc.) captured at parse time, so an embedded call splices
+    back into its statement untouched. Continuation lines keep their original
+    absolute indentation (preserved through the round-trip)."""
+    span_module = d.get("__call_module__")
+    old_call = d.get("__cst__")
+    converter = Melty._converters.get((dict, cst.Call))
+    new_call = converter(d)
+    new_module = span_module.deep_replace(old_call, new_call)
+    code = new_module.code.rstrip("\r\n")
+    return d.get("__call_prefix__", "") + code + d.get("__call_suffix__", "")
+
+
+@render_func(background=True)
+def recompile_caller_fn(input_value, changed=False):
+    """Hotswap the enclosing function from its full, post-save source on disk.
+
+    The save side writes the edited literal into the file; this reads the whole
+    enclosing `def` back (fresh — linecache evicted) and reuses the function
+    hotswap (_recompile) so the edit goes live. Recompiling just the statement
+    span wouldn't redefine anything, which is why this loads the full function."""
+    address = input_value
+    fn = getattr(address, "source", None)
+    if not isinstance(fn, types.FunctionType):
+        return False, None
+    unwrapped = inspect.unwrap(fn)
+    _evict_linecache(str(address.path))
+    try:
+        src_lines, _start = inspect.getsourcelines(unwrapped)
+    except (OSError, TypeError, tokenize.TokenError, SyntaxError) as e:
+        print(f"recompile_caller_fn: could not read source for {unwrapped.__name__}: {e}")
+        return False, None
+    _recompile(unwrapped, "".join(src_lines), str(address.path))
+    return True, fn
+
+
+@render_func(use_cache=True, selectable=False)
+def call_dict_to_save(input_value, draw_state=None, unique=None, changed=False,
+                      recompile=False, save=False, s_key_pressed=None):
+    """Edited call-kwargs dict -> write the call statement back to source.
+
+    Disk writes go through run_button(_do_save) (background), like
+    general_parse_to_address — never a synchronous/inline write. The statement
+    code is assembled synchronously (it's a single tiny statement, unlike the
+    class chain's whole-module reconstruction, so it doesn't need a background
+    node) and only on save. Saving fires once per edit (changed) or on Ctrl+S; the
+    file mtime bump then makes address_to_call_parse re-parse a fresh dict.
+
+    The recompile button hotswaps the enclosing function (address.source, set by
+    caller_to_address) from its full post-save source — so it only appears when
+    that function resolved; otherwise this is save-only (shows on next load)."""
+    d = input_value
+    if not isinstance(d, dict):
+        return False, d
+    address = d.get("__address__")
+    if not isinstance(address, Address):
+        imgui.text_colored("Saving unavailable...\nno call address", 1.0, 0.0, 0.0)
+        return False, None
+    source = address.source
+
+    # Recompile button (async). It reads the enclosing function's FULL post-save
+    # source itself, so it does not need the statement code - show it whenever a
+    # source resolved, independent of edits.
+    if source is not None:
+        run_button(recompile_caller_fn, clicked=recompile, name=f"recompile_caller{unique}",
+                   with_kwargs={"input_value": address})
+        imgui.dummy(1, 1)
+
+    # Save - ALWAYS async, through run_button(_do_save) (_do_save is
+    # @render_func(background=True)), exactly like general_parse_to_address. Never a
+    # bare _do_save(...) - that wrote to disk synchronously. Fires on an edit
+    # (save) or Ctrl+S. The statement code is assembled synchronously (pure
+    # CST→string, no disk I/O) and only when saving: doing it every frame
+    # deep-hashed the CST on the UI thread, and as a background node it returned
+    # Pending on the edit frame and dropped the save.
+    save_hotkey = bool(s_key_pressed and s_key_pressed.ctrl)
+    if changed or save_hotkey:
+        run_button(_do_save, clicked=(save or save_hotkey), name=f"do_save{unique}",
+                   with_kwargs={"input_value": address, "code_str": _build_call_code(d)})
+        if Melty.cache is not None and draw_state.parent_window is not None:
+            Melty.cache.invalidate_up(draw_state.parent_window._tile_id, max_depth=10)
+        return True, address
+    return False, address
+
+
+@render_func(use_cache=True)
+def address_to_class(input_value, changed=False, draw_state=None):
+    pass
+
+
+@render_func(use_cache=True)
+def address_to_function(input_value, changed=False, draw_state=None):
+    pass
+
+
+@render_func(use_cache=True)
+def address_to_module(input_value, changed=False, draw_state=None):
+    pass
+
+
+@render_func(use_cache=True)
+def cst_to_address(input_value, changed=False, draw_state=None):
+    pass
+
+
+@render_func(use_cache=True)
+def general_parse_to_str(input_value, changed=False, draw_state=None):
+    """Convert cst.Module → source string. Pure converter, no UI."""
+    if isinstance(input_value, GeneralParse):
+        return changed, input_value.source
+    else:
+        return False, None
+
+
+@render_func(background=True)
+def parse_source_to_general(input_value):
+    """Parse an edited source string back into a GeneralParse, on a background
+    thread. cst.parse_module + cst_module_to_dict are O(buffer); running them
+    inline on str_to_general_parse blocked every keystroke. Mirrors CODE_UI's
+    load_cst_module. A syntax error mid-edit raises here and surfaces as a
+    PendingState.ERROR (Background.run catches it)."""
+    if Toggles.TextEditor.melty_syntax:
+        return True, cst_module_to_dict(str(input_value))   # core_syntax (str input)
+    cst_module = cst.parse_module(str(input_value))
+    return True, cst_module_to_dict(cst_module)
+
+
+# Wait this long after the last edit before parsing. A full-buffer parse is
+# CPU-bound Python (cst.parse_module + cst_module_to_dict), so doing it per
+# keystroke blocks the next frame whether it runs inline or on a GIL-bound
+# pool thread. The parse only feeds save/round-trip, not the displayed text, so
+# deferring it until typing settles keeps keystrokes smooth.
+_PARSE_DEBOUNCE_S = 0.1
+
+
+def _blank_line_variant(last_good, cur):
+    """`cur` with the single line that differs from `last_good` blanked, or
+    None when the texts aren't a one-line-apart pair (different line counts,
+    zero or 2+ differing lines). The one differing line during live typing is
+    the line being edited — blanking it usually restores a parseable buffer
+    while keeping every OTHER line's content and, crucially, line NUMBERS
+    intact (so usage sites / tints resolve unshifted)."""
+    if not last_good or not cur:
+        return None
+    a = last_good.split("\n")
+    b = cur.split("\n")
+    if len(a) != len(b):
+        return None
+    diff = -1
+    for i, (la, lb) in enumerate(zip(a, b)):
+        if la != lb:
+            if diff != -1:
+                return None
+            diff = i
+    if diff == -1:
+        return None
+    b[diff] = ""
+    return "\n".join(b)
+
+
+def _blank_line_reparse(draw_state, input_str):
+    """Mid-edit syntax-error recovery: when the edit differs from the last
+    successfully parsed text by exactly one line, reparse with that line
+    blanked. Returns the repaired parse when it lands, else None (no one-line
+    variant, background job still running, or the variant is broken too —
+    e.g. the blanked line was a block header). The variant is derived once
+    per input string; the parse itself rides the normal background node and
+    its completion wakes the view."""
+    if getattr(draw_state, '_blank_variant_key', None) != input_str:
+        draw_state._blank_variant_key = input_str
+        draw_state._blank_variant = _blank_line_variant(
+            getattr(draw_state, '_last_propagated_str', None), input_str)
+    patched = draw_state._blank_variant
+    if patched is None:
+        return None
+    _c, parse = parse_source_to_general(input_value=patched)
+    if isinstance(parse, Pending) or parse is None:
+        return None
+    return parse
+
+
+@render_func(use_cache=True)
+def str_to_general_parse(input_value, reference=None, changed=False, draw_state=None):
+    input_str = str(input_value)
+    has_ref = isinstance(reference, GeneralParse)
+
+    # Debounce the parse: while the text is still changing (or hasn't been
+    # stable for _PARSE_DEBOUNCE_S), keep showing the prior parse and don't
+    # touch the UI. request_render keeps frames coming until the timer elapses.
+    # Skipped during app startup (global frame_count) AND while the view itself
+    # is loading (its own draw_state.frame_count) so a freshly opened text view
+    # parses immediately instead of waiting out the debounce window.
+    if Melty.frame_count >= 3 and draw_state.frame_count >= 3:
+        if input_str != getattr(draw_state, '_parse_pending_str', None):
+            draw_state._parse_pending_str = input_str
+            draw_state._parse_pending_at = time.monotonic()
+            request_render()
+            return False, reference if has_ref else None
+        if (input_str != getattr(draw_state, '_last_propagated_str', None)
+                and time.monotonic() - getattr(draw_state, '_parse_pending_at', 0.0) < _PARSE_DEBOUNCE_S):
+            request_render()
+            return False, reference if has_ref else None
+
+    # Parse the edited text back to a parse tree off the main thread.
+    # `reference` is the chain's cached prior parse for this position; we keep
+    # it flowing while the background parse is pending or the edit is unstable,
+    # so downstream save/recompile always get a valid (last-good) parse.
+    _c, general_parse = parse_source_to_general(input_value=input_str)
+
+    if isinstance(general_parse, Pending) or general_parse is None:
+        if isinstance(general_parse, Pending) and general_parse.state == PendingState.ERROR:
+            # Incomplete/invalid syntax mid-edit: before falling back to the
+            # stale reference wholesale, try a one-line repair - if only the
+            # line being typed changed since the last good parse, a variant
+            # with that line blanked usually parses, so usage data / tints on
+            # every other line survive the broken keystrokes. changed stays
+            # False: the repaired parse is display/context only, it must
+            # not propagate into a save or recompile.
+            repaired = _blank_line_reparse(draw_state, input_str)
+            imgui.text_colored("Error parsing code", 1.0, 0.0, 0.0)
+            if repaired is not None:
+                repaired.source = input_str   # keep the REAL edited text live
+                if has_ref:
+                    repaired.address = reference.address
+                return False, repaired
+            # Keep the edited text live on the stale reference.
+            if has_ref:
+                reference.source = input_str
+        # Background still running (or nothing changed): keep the previous parse.
+        return False, reference if has_ref else None
+
+    if not has_ref:
+        draw_state._last_propagated_str = input_str   # blank-line-repair baseline
+        return False, general_parse
+    general_parse.address = reference.address
+    # Propagate changed=True once, on the frame a new parse first lands, so
+    # downstream save/recompile can notice it without re-firing every frame.
+    fresh = getattr(draw_state, '_last_propagated_str', None) != input_str
+    draw_state._last_propagated_str = input_str
+    return fresh, general_parse