lvkit 0.8.3__tar.gz → 0.8.4__tar.gz

{lvkit-0.8.3 → lvkit-0.8.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lvkit
-Version: 0.8.3
+Version: 0.8.4
 Summary: Understand and convert LabVIEW VIs to Python without a LabVIEW license
 Project-URL: Repository, https://github.com/pragmatest-dev/lvkit
 Project-URL: Issues, https://github.com/pragmatest-dev/lvkit/issues

{lvkit-0.8.3 → lvkit-0.8.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "lvkit"
-version = "0.8.3"
+version = "0.8.4"
 description = "Understand and convert LabVIEW VIs to Python without a LabVIEW license"
 readme = "README.md"
 requires-python = ">=3.10"

{lvkit-0.8.3 → lvkit-0.8.4}/src/lvkit/__init__.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-__version__ = "0.8.3"
+__version__ = "0.8.4"
 
 # The public API is exposed LAZILY (PEP 562 module ``__getattr__``): the graph /
 # parser / structure stacks (networkx, pydantic, pylabview, PIL — ~230 ms) load

{lvkit-0.8.3 → lvkit-0.8.4}/src/lvkit/cache_paths.py

@@ -111,6 +111,35 @@ def _slug(path: Path) -> str:
     return f"{tail}-{h}"
 
 
+# The fixed short stem every MANAGED-cache artifact (extract/render/diff) uses
+# instead of the real VI's filename stem — the second Windows MAX_PATH axis
+# alongside the bounded ``vi-<hash>`` slot below. Owned by this module (the
+# single source of the cache-layout policy); ``extractor.py`` and
+# ``output_cache.py`` import it rather than repeating the literal.
+MANAGED_ARTIFACT_STEM = "vi"
+
+
+def _vi_slot(rel: Path) -> str:
+    """A per-VI cache dir name that is ALWAYS bounded, whatever the source tree's
+    depth: ``vi-`` + 16 hex of a sha256 of the owner-relative path.
+
+    Owned namespaces used to hang a VI's cache under ``<rel.parent>`` — the full
+    source-directory hierarchy reproduced beneath the cache root. A deep repo (or
+    a long VI filename) then pushed the final cache path past Windows' MAX_PATH
+    even with a short ``LVKIT_CACHE_DIR``, because BOTH the depth and the source
+    stem were unbounded inputs (the failure this replaces). Collapsing the whole
+    owner-relative path to one fixed-width hash segment removes the depth axis;
+    fixed short artifact names inside the slot remove the stem axis. The path is
+    keyed on the FULL ``rel`` (parent + filename), so every source VI maps to its
+    own slot and sibling VIs never collide. The real source path is NOT lost — it
+    is recorded as the ``source`` field of each slot's ``.meta.json`` sidecar
+    (see ``extractor._write_cache_meta`` / ``output_cache._write``). The
+    separators are normalized to ``/`` so the same VI hashes identically
+    regardless of how its path was spelled on this platform."""
+    key = rel.as_posix()
+    return "vi-" + hashlib.sha256(key.encode("utf-8")).hexdigest()[:16]
+
+
 def kind_fingerprint(kind: str) -> str:
     """The 8-hex build-compatibility tag stamped into a cache path for ``kind``.
 
@@ -215,14 +244,20 @@ def classify(vi_path: Path, kind: str) -> tuple[Path, str, str]:
     """Map ``vi_path`` to ``(cache_dir, source_label, namespace)`` for one
     artifact ``kind`` (``"extract"`` | ``"render"`` | ``"diff"``).
 
-    ``cache_dir`` is ``<cache>/<ns>/<slug>/<kind>/<fp>/<rel-parent>`` — project-
+    ``cache_dir`` is ``<cache>/<ns>/<slug>/<kind>/<fp>/vi-<hash>`` — project-
     first: the VI's identity (namespace + slug) is named ONCE and the ``kind``
-    hangs off it, so one project's whole cache is a single subtree and sibling VIs
-    of the same kind + build share a dir. ``<fp>`` is the per-kind build tag
-    (:func:`kind_fingerprint`) so two incompatible lvkit builds get separate slots
-    instead of clobbering each other. ``namespace`` is ``"projects"``,
+    hangs off it, so one project's whole cache is a single subtree. ``<fp>`` is
+    the per-kind build tag (:func:`kind_fingerprint`) so two incompatible lvkit
+    builds get separate slots instead of clobbering each other. ``vi-<hash>``
+    (:func:`_vi_slot`) is a bounded per-VI slot standing in for the owner-relative
+    directory hierarchy, so an arbitrarily deep source tree can never push the
+    cache path past Windows' MAX_PATH; the artifact names inside it are fixed and
+    short (``vi_BDHb.xml`` / ``vi.<ext>``) for the same reason. ``source_label``
+    stays the REAL owner-relative path (``str(rel)``) so the true source is
+    recorded in each slot's ``.meta.json``. ``namespace`` is ``"projects"``,
     ``"shared"``, or ``"adhoc"`` — callers path-address the first two and
-    content-address ``adhoc`` (its paths never repeat).
+    content-address ``adhoc`` (its paths never repeat; its dir is already a single
+    bounded ``_slug`` segment).
     """
     resolved = vi_path.resolve()
     cache = global_cache_root()
@@ -237,7 +272,7 @@ def classify(vi_path: Path, kind: str) -> tuple[Path, str, str]:
         rel = _rel_under(resolved, vilib)
         if rel is not None:
             _note_owner(vilib)
-            d = cache / "shared" / "vilib" / _slug(vilib) / kind / fp / rel.parent
+            d = cache / "shared" / "vilib" / _slug(vilib) / kind / fp / _vi_slot(rel)
             return d, str(rel), "shared"
 
     userlib = _userlib_root
@@ -245,7 +280,8 @@ def classify(vi_path: Path, kind: str) -> tuple[Path, str, str]:
         rel = _rel_under(resolved, userlib)
         if rel is not None:
             _note_owner(userlib)
-            d = cache / "shared" / "userlib" / _slug(userlib) / kind / fp / rel.parent
+            slug = _slug(userlib)
+            d = cache / "shared" / "userlib" / slug / kind / fp / _vi_slot(rel)
             return d, str(rel), "shared"
 
     project = _project_root_for(resolved)
@@ -253,7 +289,7 @@ def classify(vi_path: Path, kind: str) -> tuple[Path, str, str]:
         proj_abs = project.resolve()
         rel = resolved.relative_to(proj_abs)
         _note_owner(proj_abs)
-        d = cache / "projects" / _slug(proj_abs) / kind / fp / rel.parent
+        d = cache / "projects" / _slug(proj_abs) / kind / fp / _vi_slot(rel)
         return d, str(rel), "projects"
 
     # adhoc has NO owner (not a project, not a library) -> no identity slug to
@@ -474,7 +510,10 @@ def write_meta(vi_path: Path, meta_path: Path, **extra: object) -> None:
 # source/fingerprint change — that is handled by the <fp> path level). A mismatch
 # triggers a one-time drop of the derived namespaces in cleanup_legacy_cache.
 #   "2": project-first with a per-kind <fp> level and <tail>-<hash8> slugs.
-_LAYOUT_VERSION = "2"
+#   "3": owned VIs sit in a bounded per-VI ``vi-<hash>`` slot with fixed short
+#        artifact names (was the reproduced ``<rel.parent>`` hierarchy + source
+#        stem), so a deep source tree can't overflow Windows MAX_PATH.
+_LAYOUT_VERSION = "3"
 
 
 def cleanup_legacy_cache() -> None:

{lvkit-0.8.3 → lvkit-0.8.4}/src/lvkit/extractor.py

@@ -34,6 +34,7 @@ install_pylabview_patches()
 # pylabview). Re-exported here so long-standing callers of ``extractor.X`` (e.g.
 # ``graph.core`` -> ``extractor.set_extraction_roots``) keep working unchanged.
 from lvkit.cache_paths import (  # noqa: E402
+    MANAGED_ARTIFACT_STEM,
     _slug,
     classify,
     cleanup_legacy_cache,
@@ -179,7 +180,7 @@ def _make_read_po(**overrides: object) -> argparse.Namespace:
     return argparse.Namespace(**opts)
 
 
-def _extract_in_process(vi_path: Path, output_dir: Path, vi_stem: str) -> None:
+def _extract_in_process(vi_path: Path, output_dir: Path, artifact_stem: str) -> None:
     """Extract a VI to XML in-process, matching ``readRSRC -i <vi> -x``.
 
     pylabview places each block's sidecar XML (``_BDHb.xml`` etc.) in
@@ -190,17 +191,21 @@ def _extract_in_process(vi_path: Path, output_dir: Path, vi_stem: str) -> None:
     request concurrency. This avoids the per-call interpreter boot + pylabview
     re-import that the subprocess path pays on every extraction.
 
+    ``artifact_stem`` names the produced files — the caller's real VI stem for a
+    caller-owned ``output_dir``, or the fixed ``MANAGED_ARTIFACT_STEM`` in the
+    managed cache; it is NOT necessarily ``vi_path.stem``.
+
     Mirrors the option set that ``readRSRC.main()`` builds for the ``-x``
     (extract) subcommand via argparse.
     """
-    xml_path = output_dir / f"{vi_stem}.xml"
+    xml_path = output_dir / f"{artifact_stem}.xml"
     po = _make_read_po(
         rsrc=str(vi_path),
         xml=str(xml_path),
         textcp="mac_roman",
         raw_connectors=False,
         keep_names=False,
-        filebase=vi_stem,
+        filebase=artifact_stem,
         list=False,
         dump=False,
         extract=True,
@@ -214,8 +219,8 @@ def _extract_in_process(vi_path: Path, output_dir: Path, vi_stem: str) -> None:
     with open(xml_path, "wb") as xml_fh:
         tree.write(xml_fh, encoding="utf-8", xml_declaration=True)
     for path in output_dir.iterdir():
-        belongs_to_vi = path.name == f"{vi_stem}.xml" or path.name.startswith(
-            f"{vi_stem}_"
+        belongs_to_vi = path.name == f"{artifact_stem}.xml" or path.name.startswith(
+            f"{artifact_stem}_"
         )
         if path.suffix == ".xml" and belongs_to_vi:
             normalize_extracted_xml(path)
@@ -249,15 +254,24 @@ def extract_vi_xml(
     """
     vi_path = Path(vi_path).resolve()
 
-    if output_dir is None:
+    # A caller-supplied output_dir is caller-owned, so keep the real source stem
+    # in the artifact names there. The MANAGED cache (output_dir is None) uses a
+    # FIXED short stem instead: a long source filename would otherwise overflow
+    # the cache path once a ``_BDHb.xml`` suffix is appended — the second Windows
+    # MAX_PATH axis, paired with the bounded per-VI slot dir (cache_paths._vi_slot).
+    # The real source name/path is preserved for callers: the graph loader keys
+    # every node on the source path (never on this stem), and the ``source`` field
+    # of the ``.meta.json`` records the real owner-relative path.
+    managed = output_dir is None
+    if managed:
         output_dir = _cache_target(vi_path)
     output_dir.mkdir(parents=True, exist_ok=True)
 
-    vi_stem = vi_path.stem
-    bd_xml = output_dir / f"{vi_stem}_BDHb.xml"
-    fp_xml = output_dir / f"{vi_stem}_FPHb.xml"
-    main_xml = output_dir / f"{vi_stem}.xml"
-    meta_path = output_dir / f"{vi_stem}.meta.json"
+    artifact_stem = MANAGED_ARTIFACT_STEM if managed else vi_path.stem
+    bd_xml = output_dir / f"{artifact_stem}_BDHb.xml"
+    fp_xml = output_dir / f"{artifact_stem}_FPHb.xml"
+    main_xml = output_dir / f"{artifact_stem}.xml"
+    meta_path = output_dir / f"{artifact_stem}.meta.json"
 
     # Cache hit: XML present and the recorded content-hash (or mtime/size
     # fast-path) still matches the VI. The extraction-code compatibility check is
@@ -316,15 +330,15 @@ def extract_vi_xml(
     tmp_dir = Path(tempfile.mkdtemp(prefix=".x-", dir=_staging_root()))
     try:
         try:
-            _extract_in_process(vi_path, tmp_dir, vi_stem)
+            _extract_in_process(vi_path, tmp_dir, artifact_stem)
         except Exception as exc:
             raise RuntimeError(
                 f"pylabview extraction failed for {vi_path.name}: {exc}"
-                f"{_windows_long_path_hint(tmp_dir / f'{vi_stem}_BDHb.xml')}"
+                f"{_windows_long_path_hint(tmp_dir / f'{artifact_stem}_BDHb.xml')}"
             ) from exc
 
-        if not (tmp_dir / f"{vi_stem}_BDHb.xml").exists():
-            raise RuntimeError(f"Block diagram XML not found: {vi_stem}_BDHb.xml")
+        if not (tmp_dir / f"{artifact_stem}_BDHb.xml").exists():
+            raise RuntimeError(f"Block diagram XML not found: {artifact_stem}_BDHb.xml")
 
         # Publish every produced artifact atomically (same filesystem as the
         # temp dir), then meta.json last so its appearance marks the cache valid.

{lvkit-0.8.3 → lvkit-0.8.4}/src/lvkit/graph/loading.py

@@ -496,8 +496,10 @@ class LoadingMixin:
 
         for member in lib.members:
             if member.member_type == "VI":
-                member_name = Path(member.url).name
-                if member_name.lower().endswith(".ctl"):
+                member_url = Path(member.url)
+                member_name = member_url.name
+                member_suffix = member_url.suffix.lower()
+                if member_suffix == ".ctl":
                     # .ctl members are type definitions, not loadable VIs
                     typedef_qname = lib_qname + ":" + member_name
                     ctl_path = lvlib_path.parent / member.url
@@ -528,7 +530,7 @@ class LoadingMixin:
                             caller=lib_key,
                             rel="owns",
                         )
-                else:
+                elif member_suffix == ".vi":
                     member_qname = lib_qname + ":" + member_name
                     vi_path = lvlib_path.parent / member.url
                     if not vi_path.exists():
@@ -558,6 +560,21 @@ class LoadingMixin:
                             caller=lib_key,
                             rel="owns",
                         )
+                else:
+                    # A member the library XML declares Type="VI" but whose URL
+                    # is neither .vi nor .ctl -- a source-metadata anomaly, not
+                    # a code entity. No node, no stub (a stub means "a VI we
+                    # expect to resolve later", which is wrong here): warn and
+                    # move on rather than sending a non-VI file to load_vi
+                    # (which raises ValueError and would abort the whole load).
+                    logger.warning(
+                        'library %s declares member %r as Type="VI" but its '
+                        "URL %r is not a loadable .vi or .ctl file — skipping "
+                        "it.",
+                        lvlib_path.name,
+                        member.name,
+                        member.url,
+                    )
             elif member.member_type == "LVClass":
                 class_name = Path(member.url).name
                 class_path = lvlib_path.parent / member.url
@@ -1220,6 +1237,7 @@ class LoadingMixin:
         main_xml: Path | None,
         search_paths: list[Path],
         visited: set[str],
+        *,
         source_dir: Path | None = None,
         source_override: Path | None = None,
         mode: LoadMode = LoadMode.FULL,
@@ -1251,6 +1269,9 @@ class LoadingMixin:
                 bd_xml=bd_xml,
                 fp_xml=fp_xml if fp_xml and fp_xml.exists() else None,
                 main_xml=main_xml if main_xml and main_xml.exists() else None,
+                # Pin the parser's identity (name, source_path, warnings) to the
+                # real source path, not the fixed ``vi_BDHb.xml`` cache name.
+                source_override=source_override,
                 layout=self._want_layout,
             )
         )
@@ -1260,7 +1281,19 @@ class LoadingMixin:
         fp = vi.front_panel
         conpane = vi.connector_pane
 
-        unqualified_name = bd_xml.name.replace("_BDHb.xml", ".vi")
+        # The VI's real unqualified name comes from its SOURCE path when we have
+        # one (``source_override``), NOT from the extracted BD XML filename: the
+        # managed extraction cache names every artifact ``vi_BDHb.xml`` (a bounded
+        # fixed name — see ``extractor.extract_vi_xml``), so deriving the name from
+        # the XML would make every VI ``vi.vi``. The source path is authoritative
+        # and is threaded here for the top-level VI (``load_vi``) and every SubVI
+        # dependency (``_leaf_load_vi``). Only a raw ``*_BDHb.xml`` handed in
+        # directly (no source path) falls back to the XML-derived name.
+        unqualified_name = (
+            source_override.name
+            if source_override is not None
+            else bd_xml.name.replace("_BDHb.xml", ".vi")
+        )
         # own_qname is this VI's (possibly NON-unique) qualified name — kept only
         # for the self-dependency compare below and the qname reverse index. It
         # is NOT the identity: two on-disk copies (a source VI + its stripped
@@ -1826,6 +1859,10 @@ class LoadingMixin:
                 search_paths=search_paths,
                 visited=set(),
                 source_dir=resolved.parent,
+                # ``resolved`` is this SubVI's real source ``.vi`` path — pin the
+                # VI's identity (key + unqualified name) to it, never to the
+                # fixed-name ``vi_BDHb.xml`` in the extraction cache.
+                source_override=resolved,
                 mode=child_mode,
             )
             if loaded_name:

{lvkit-0.8.3 → lvkit-0.8.4}/src/lvkit/graph/parallel_parse.py

@@ -47,18 +47,27 @@ PARALLEL_THRESHOLD = 50
 # process-pool scheduling/pickling overhead across many small XML files.
 _BATCH_SIZE = 20
 
-_ParseItem = tuple[Path, Path | None, Path | None]
+# (vi_path, bd_xml, fp_xml, main_xml): vi_path is the REAL source .vi, carried so
+# the worker can pin the parser's identity to it — the managed cache names BD XML
+# ``vi_BDHb.xml`` (a bounded fixed name), so parsing without the real path would
+# label every VI ``vi.vi`` (see parse_vi's source_override).
+_ParseItem = tuple[Path, Path, Path | None, Path | None]
 
 
 def _parse_batch(items: list[_ParseItem]) -> dict[str, ParsedVI]:
-    """Worker entry point: parse a batch of (bd_xml, fp_xml, main_xml)
-    triples. Runs in a worker process. A single unparseable VI is skipped,
+    """Worker entry point: parse a batch of (vi_path, bd_xml, fp_xml, main_xml)
+    tuples. Runs in a worker process. A single unparseable VI is skipped,
     not fatal to the rest of the batch -- the caller's serial path parses it
     (and reports its error, same as today) when it finds no cache entry."""
     out: dict[str, ParsedVI] = {}
-    for bd_xml, fp_xml, main_xml in items:
+    for vi_path, bd_xml, fp_xml, main_xml in items:
         try:
-            out[str(bd_xml)] = parse_vi(bd_xml=bd_xml, fp_xml=fp_xml, main_xml=main_xml)
+            out[str(bd_xml)] = parse_vi(
+                bd_xml=bd_xml,
+                fp_xml=fp_xml,
+                main_xml=main_xml,
+                source_override=vi_path,
+            )
         except Exception:
             logger.debug("parallel parse: skipping %s", bd_xml, exc_info=True)
     return out
@@ -93,7 +102,7 @@ def parallel_parse_directory(
         except Exception:
             # Extraction failure -- let the serial path hit (and report) it.
             continue
-        resolved.append((bd_xml, fp_xml, main_xml))
+        resolved.append((vi_path, bd_xml, fp_xml, main_xml))
 
     if not resolved:
         return {}

{lvkit-0.8.3 → lvkit-0.8.4}/src/lvkit/output_cache.py

@@ -92,13 +92,17 @@ def _ext_for(fmt: str) -> str:
 # ── path resolution ─────────────────────────────────────────────────────────
 
 
-def _render_paths(input_path: Path, fmt: str) -> tuple[Path, Path, bool]:
-    """``(body_path, meta_path, is_adhoc)`` for a render of ``input_path``.
+def _render_paths(input_path: Path, fmt: str) -> tuple[Path, Path, str, bool]:
+    """``(body_path, meta_path, source_label, is_adhoc)`` for a render of
+    ``input_path``.
 
     Path-addressed for project/shared VIs; flat content-addressed for adhoc.
+    ``source_label`` is ``classify()``'s real owner-relative path (or, for
+    adhoc, the bare filename) — the caller writes it into the cache entry's
+    meta so the fixed ``vi.<ext>`` body name doesn't lose which VI it is.
     """
     ext = _ext_for(fmt)
-    d, _, ns = cache_paths.classify(input_path, "render")
+    d, source_label, ns = cache_paths.classify(input_path, "render")
     if ns == "adhoc":
         # Flat content-addressed pool, but still per-build: the <fp> keeps two
         # lvkit builds from colliding on the same <sha>.<ext> (classify's dir is
@@ -111,8 +115,12 @@ def _render_paths(input_path: Path, fmt: str) -> tuple[Path, Path, bool]:
         )
         base = f"{cache_paths.sha256_file(input_path)}.{ext}"
     else:
-        base = f"{input_path.stem}.{ext}"
-    return d / base, d / f"{base}.meta.json", ns == "adhoc"
+        # classify's dir is now a bounded per-VI slot (vi-<hash>), so the source
+        # stem in the filename is both redundant AND a MAX_PATH hazard (a long VI
+        # name overflows the path) — use a fixed short base. The slot holds one
+        # source VI, so ``vi.<ext>`` is unique per format.
+        base = f"{cache_paths.MANAGED_ARTIFACT_STEM}.{ext}"
+    return d / base, d / f"{base}.meta.json", source_label, ns == "adhoc"
 
 
 def _diff_ext(fmt: str) -> str:
@@ -121,17 +129,20 @@ def _diff_ext(fmt: str) -> str:
 
 def _diff_paths(
     before_path: Path, after_path: Path, fmt: str
-) -> tuple[Path, Path, str, bool]:
-    """``(body_path, meta_path, before_sha, is_adhoc)`` for a diff.
+) -> tuple[Path, Path, str, str, bool]:
+    """``(body_path, meta_path, before_sha, source_label, is_adhoc)`` for a diff.
 
     Path-addressed by the AFTER (working-tree) VI — the side lvkit is handed as a
     real path — with the before-content hash and the format in the filename
     (lvkit is git-agnostic; the before side arrives only as bytes). Flat
-    content-addressed when even the after side is adhoc.
+    content-addressed when even the after side is adhoc. ``source_label`` is the
+    AFTER VI's real owner-relative path (or, for adhoc, its bare filename) — the
+    caller writes it into the cache entry's meta so the fixed ``vi.<sha>.<ext>``
+    body name doesn't lose which VI it is.
     """
     ext = _diff_ext(fmt)
     before_sha = cache_paths.sha256_file(before_path)
-    d, _, ns = cache_paths.classify(after_path, "diff")
+    d, source_label, ns = cache_paths.classify(after_path, "diff")
     if ns == "adhoc":
         after_sha = cache_paths.sha256_file(after_path)
         d = (
@@ -142,8 +153,12 @@ def _diff_paths(
         )
         base = f"{before_sha[:16]}_{after_sha[:16]}.{ext}"
     else:
-        base = f"{after_path.stem}.{before_sha[:16]}.{ext}"
-    return d / base, d / f"{base}.meta.json", before_sha, ns == "adhoc"
+        # classify's dir is a bounded per-VI slot (vi-<hash>) holding one AFTER
+        # VI, so the after-stem in the filename is redundant AND a MAX_PATH
+        # hazard — a fixed short base plus the before-content hash still
+        # distinguishes every (before, format) pair.
+        base = f"{cache_paths.MANAGED_ARTIFACT_STEM}.{before_sha[:16]}.{ext}"
+    return d / base, d / f"{base}.meta.json", before_sha, source_label, ns == "adhoc"
 
 
 # ── read / write ────────────────────────────────────────────────────────────
@@ -200,7 +215,7 @@ def diff_slot(before_path: Path, after_path: Path, fmt: str) -> Path:
 
 def lookup_render(input_path: Path, fmt: str, options: str, version: str) -> str | None:
     """Return cached render output for ``input_path`` if fresh, else ``None``."""
-    body_path, meta_path, _ = _render_paths(input_path, fmt)
+    body_path, meta_path, _, _ = _render_paths(input_path, fmt)
     return _read_if_fresh(
         input_path,
         body_path,
@@ -217,7 +232,7 @@ def store_render(
     input_path: Path, fmt: str, options: str, version: str, body: str
 ) -> Path:
     """Cache ``body`` as the render of ``input_path``; return the slot path."""
-    body_path, meta_path, _ = _render_paths(input_path, fmt)
+    body_path, meta_path, source_label, _ = _render_paths(input_path, fmt)
     _write(
         body_path,
         meta_path,
@@ -228,6 +243,9 @@ def store_render(
             "options": options,
             "kind": "render",
             "text_encoding": labview_text_encoding(),
+            # The fixed ``vi.<ext>`` body name carries no source info by
+            # itself — record the real path (mirrors extraction's meta.json).
+            "source": source_label,
         },
     )
     return body_path
@@ -237,7 +255,7 @@ def lookup_diff(
     before_path: Path, after_path: Path, fmt: str, options: str, version: str
 ) -> str | None:
     """Return cached diff output for the ``(before, after)`` pair if fresh."""
-    body_path, meta_path, before_sha, _ = _diff_paths(before_path, after_path, fmt)
+    body_path, meta_path, before_sha, _, _ = _diff_paths(before_path, after_path, fmt)
     return _read_if_fresh(
         after_path,
         body_path,
@@ -260,7 +278,9 @@ def store_diff(
     body: str,
 ) -> Path:
     """Cache ``body`` as the diff of ``(before, after)``; return the slot path."""
-    body_path, meta_path, before_sha, _ = _diff_paths(before_path, after_path, fmt)
+    body_path, meta_path, before_sha, source_label, _ = _diff_paths(
+        before_path, after_path, fmt
+    )
     _write(
         body_path,
         meta_path,
@@ -272,6 +292,9 @@ def store_diff(
             "before_sha": before_sha,
             "kind": "diff",
             "text_encoding": labview_text_encoding(),
+            # The fixed ``vi.<sha>.<ext>`` body name carries no source info by
+            # itself — record the AFTER VI's real path (mirrors extraction).
+            "source": source_label,
         },
     )
     return body_path

{lvkit-0.8.3 → lvkit-0.8.4}/src/lvkit/parser/metadata.py

@@ -506,7 +506,7 @@ def parse_iuse_from_libd(libd_path: Path) -> dict[str, str]:
 
 
 def _decode_pth0_components(
-    data: bytes, pth0_offset: int, end: int
+    data: bytes | memoryview, pth0_offset: int, end: int
 ) -> tuple[list[str], int]:
     """Decode one ``PTH0`` record's pascal-string path components ->
     ``(tokens, next_idx)``.
@@ -557,7 +557,7 @@ def _decode_pth0_components(
         idx += 1
         if idx + ln > end:
             return [], pth0_offset
-        tokens.append(decode_labview_text(data[idx : idx + ln]))
+        tokens.append(decode_labview_text(bytes(data[idx : idx + ln])))
         idx += ln
     return tokens, idx
 

{lvkit-0.8.3 → lvkit-0.8.4}/src/lvkit/parser/vi.py

@@ -134,6 +134,7 @@ def parse_vi(
     bd_xml: Path | str | None = None,
     fp_xml: Path | str | None = None,
     main_xml: Path | str | None = None,
+    source_override: Path | str | None = None,
     layout: bool = False,
 ) -> ParsedVI:
     """Parse a VI file into all components.
@@ -146,6 +147,11 @@ def parse_vi(
         bd_xml: Path to *_BDHb.xml (for direct XML parsing)
         fp_xml: Path to *_FPHb.xml (optional)
         main_xml: Path to main *.xml (optional)
+        source_override: the VI's real source path, when the caller already
+            knows it and ``bd_xml`` lives under a fixed cache name (e.g.
+            ``vi_BDHb.xml``) that can't itself supply it. Pins the parsed VI's
+            name/``source_path``/warnings to this path instead of deriving them
+            from ``bd_xml``'s filename. Takes precedence over ``vi_path``.
         layout: also decode block-diagram GEOMETRY (node/terminal/wire bounds)
             from the same parsed heap and attach it as ``ParsedVI.layout``. Off
             by default — codegen needs no positions. Rendering passes True so
@@ -180,9 +186,17 @@ def parse_vi(
             )
             fp_xml = None
 
-    # Derive source .vi path. Prefer the explicit vi_path argument since BD XML
-    # may now live in a temp cache dir rather than next to the source file.
-    if vi_path is not None:
+    # Derive source .vi path. Prefer an explicit real source path — the caller
+    # passes ``source_override`` (the graph loader / parallel pre-parse) or
+    # ``vi_path`` — because the BD XML now lives in the managed cache under a
+    # bounded FIXED name (``vi_BDHb.xml``; see ``extractor.extract_vi_xml``).
+    # Deriving identity from that filename would mislabel every VI ``vi.vi`` (its
+    # name, ``metadata.source_path``, and every warning), so the source path is
+    # authoritative. ``source_override`` is NOT ``.exists()``-gated: the real .vi
+    # need not sit beside the cached XML.
+    if source_override is not None:
+        source_path_str = str(Path(source_override).resolve())
+    elif vi_path is not None:
         source_path_str = str(Path(vi_path).resolve())
     else:
         source_path = bd_xml.with_name(bd_xml.name.replace("_BDHb.xml", ".vi"))
@@ -1450,7 +1464,7 @@ def _decode_default_data(
     return None
 
 
-def _walk_path(data: bytes) -> tuple[str | None, int]:
+def _walk_path(data: bytes | memoryview) -> tuple[str | None, int]:
     """Walk a ``PTH0`` path DefaultData blob ONCE -> ``(value, bytes_consumed)``.
 
     Delegates the pascal-string component decode to
@@ -1460,7 +1474,9 @@ def _walk_path(data: bytes) -> tuple[str | None, int]:
     cluster stays aligned with the following field. Returns ``(None, 0)``
     when ``data`` is not a ``PTH0`` blob.
     """
-    if not data.startswith(b"PTH0"):
+    # An equality slice (not ``.startswith``, which memoryview lacks) works for
+    # both ``bytes`` and ``memoryview`` callers.
+    if data[:4] != b"PTH0":
         return None, 0
     parts, idx = _decode_pth0_components(data, 0, len(data))
     return (f'Path("{"/".join(parts)}")' if parts else None), idx
@@ -1505,7 +1521,9 @@ def _decode_numeric_default(data: bytes) -> str | None:
     return None
 
 
-def _decode_element(data: bytes, elem_type: LVType | None) -> tuple[str | None, int]:
+def _decode_element(
+    data: bytes | memoryview, elem_type: LVType | None
+) -> tuple[str | None, int]:
     """Decode a single element and return (value, bytes_consumed).
 
     Handles all LabVIEW types recursively: primitives, enums,
@@ -1521,6 +1539,14 @@ def _decode_element(data: bytes, elem_type: LVType | None) -> tuple[str | None,
     if not elem_type or len(data) == 0:
         return None, 0
 
+    # A memoryview instead of bytes so the ARRAY/CLUSTER branches' recursive
+    # ``data[idx:]`` slices below are non-copying subviews -- an array/cluster
+    # element decode used to re-copy the whole remaining payload bytes object
+    # on every recursive call, making a large array's decode O(N^2) (a
+    # 65,160,056-byte NumInt32 array default effectively hung parse_vi()).
+    if isinstance(data, bytes):
+        data = memoryview(data)
+
     underlying = elem_type.underlying_type or ""
     kind = elem_type.kind
 
@@ -1531,7 +1557,7 @@ def _decode_element(data: bytes, elem_type: LVType | None) -> tuple[str | None,
         str_len = int.from_bytes(data[:4], "big")
         if len(data) < 4 + str_len:
             return None, 0
-        string_val = decode_labview_text(data[4 : 4 + str_len])
+        string_val = decode_labview_text(bytes(data[4 : 4 + str_len]))
         escaped = string_val.replace("\\", "\\\\").replace("'", "\\'")
         return f"'{escaped}'", 4 + str_len
 

{lvkit-0.8.3 → lvkit-0.8.4}/tests/conftest.py

@@ -29,6 +29,30 @@ def pytest_collection_modifyitems(config, items):
             item.add_marker(skip)
 
 
+@pytest.fixture(autouse=True)
+def _sanitize_git_env(monkeypatch):
+    """Strip git's repo-locating env vars so a test's ``git -C <sample repo>``
+    subprocess resolves THAT repo, not whatever the ambient environment points at.
+
+    Under the pre-commit hook the suite runs with ``GIT_DIR`` / ``GIT_WORK_TREE`` /
+    ``GIT_INDEX_FILE`` (and friends) exported, pointing at the lvkit repo. A child
+    ``git -C <other repo> show`` then INHERITS them, they take precedence over
+    ``-C``, git looks the ref up in the wrong repo, and the call fails with exit
+    128 (yielding an empty / unreadable VI). That flake appears ONLY under
+    pre-commit — never in a bare ``pytest`` run — so it is invisible until commit
+    time. Clearing these makes ``-C`` authoritative for every git-extracting test
+    (test_diff, test_class_field_walkup, …) in one place."""
+    for var in (
+        "GIT_DIR",
+        "GIT_WORK_TREE",
+        "GIT_INDEX_FILE",
+        "GIT_OBJECT_DIRECTORY",
+        "GIT_COMMON_DIR",
+        "GIT_PREFIX",
+    ):
+        monkeypatch.delenv(var, raising=False)
+
+
 @pytest.fixture(autouse=True)
 def _hermetic_cache(tmp_path_factory, monkeypatch):
     """Point the extraction cache at a per-test tmp dir so no test ever writes