lvkit 0.8.2__tar.gz → 0.8.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lvkit
-Version: 0.8.2
+Version: 0.8.3
 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.2 → lvkit-0.8.3}/pyproject.toml

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

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

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-__version__ = "0.8.2"
+__version__ = "0.8.3"
 
 # 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.2 → lvkit-0.8.3}/src/lvkit/graph/builders/operations.py

@@ -99,6 +99,12 @@ class PrimitiveBuildHandler(NodeBuildHandler):
         if isinstance(node, (PropertyNode, InvokeNode, EventRegNode)):
             prim_kwargs["object_name"] = node.object_name
             prim_kwargs["object_method_id"] = node.object_method_id
+            # Property/Invoke nodes share the SAME implicit-binding fields
+            # (task #51/#55) -- EventRegNode has neither, so it's excluded
+            # here rather than duplicating this pair per elif branch below.
+            if isinstance(node, (PropertyNode, InvokeNode)):
+                prim_kwargs["bound_control_uid"] = node.bound_control_uid
+                prim_kwargs["bound_control_type"] = node.bound_control_type
             if isinstance(node, PropertyNode):
                 prim_kwargs["properties"] = [
                     PropertyDef(name=p.get("name", "")) if isinstance(p, dict) else p
@@ -107,8 +113,6 @@ class PrimitiveBuildHandler(NodeBuildHandler):
                 prim_kwargs["property_value_terminal_ids"] = [
                     ctx.qid(uid) for uid in node.dco_terminal_uids
                 ]
-                prim_kwargs["bound_control_uid"] = node.bound_control_uid
-                prim_kwargs["bound_control_type"] = node.bound_control_type
             elif isinstance(node, InvokeNode):
                 prim_kwargs["method_name"] = node.method_name
                 prim_kwargs["method_code"] = node.method_code

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

@@ -647,13 +647,14 @@ class LoadingMixin:
         search_paths: list[Path] | None = None,
         owner_chain: list[str] | None = None,
     ) -> str:
-        """Load a .lvclass file. Returns the dep_graph qname it was
-        registered under (``cls_qname``, built from the ON-DISK file's own
-        stem casing) — the CALLER may have referenced this class under a
-        different casing (a type reference's recorded casing can differ
-        from the file's actual casing), so callers that add dep_graph edges
-        or aliases must use this return value, never re-derive/assume the
-        qname themselves (see ``_load_dependency``'s ``.lvclass`` branch).
+        """Load a .lvclass file. Returns the dep-graph KEY (the resolved
+        ``.lvclass`` path) it was registered under — mirrors ``load_lvlib``/
+        ``load_typedef``: callers add ownership/reference edges to THIS key,
+        never to the qname (``cls_qname``, built from the ON-DISK file's own
+        stem casing — the CALLER may have referenced this class under a
+        different casing, e.g. a type reference's recorded casing can differ
+        from the file's actual casing, so the qname alone isn't a safe edge
+        target; see ``_load_dependency``'s ``.lvclass`` branch).
 
         ``MINIMAL`` is an INTERFACE load: add the class's private-data fields
         (and its parent chain's, via walk-up — nMux field indices run into the
@@ -686,7 +687,9 @@ class LoadingMixin:
         # walks follow it by IDENTITY (a name can hit duplicates; a path
         # can't). None when the parent isn't on disk.
         parent = cls.parent_class
-        parent_file, parent_intended = self._resolve_parent(cls, lvclass_path)
+        parent_file, parent_intended = self._resolve_parent(
+            cls, lvclass_path, search_paths
+        )
         # The parent's KEY is its recorded path whether or not the file is staged
         # yet — so progressive (web) staging can NAME + fetch a not-yet-present
         # parent (an ``.exists()`` gate would drop the whole inherited surface).
@@ -832,6 +835,18 @@ class LoadingMixin:
             try:
                 pd_fields = private_data_from_lvclass_xml(lvclass_path)
             except Exception:
+                # Intentional hard best-effort boundary, not a narrowable
+                # set: private_data_from_lvclass_xml decodes a possibly
+                # malformed/legacy embedded RSRC container through
+                # pylabview's OWN VI-resource parser (parse_flattened_
+                # private_data -> lv_rsrc.VI(...).parseData()), whose
+                # exception surface on untrusted/old-format binary data
+                # isn't a documented closed set (struct/index/value/key
+                # errors and more have all been observed from that parser
+                # elsewhere) -- this docstring's own contract is "a
+                # malformed/older embedded control must never break class
+                # loading", so any failure here degrades to "no fields
+                # recovered", never propagates.
                 logger.debug(
                     "flattened private-data recovery failed for %s",
                     lvclass_path,
@@ -841,23 +856,119 @@ class LoadingMixin:
             fields = [private_data_field_to_cluster_field(f) for f in pd_fields]
         return fields
 
+    def _resolve_vilib_class_ref(
+        self,
+        parent_name: str,
+        path_tokens: list[str],
+        lvclass_path: Path,
+        search_paths: list[Path],
+    ) -> tuple[Path | None, Path | None]:
+        """Resolve a ``<vilib>``-rooted class reference's TOKENS (already
+        split — ``path_tokens[0] == "<vilib>"``) -> ``(parent_file,
+        parent_intended)``, via ``ParsedDependencyRef.resolve_against`` — the
+        EXACT SAME machinery a SubVI/type ``<vilib>`` dependency already
+        resolves through (``_resolve_dependency_path``), never a new
+        resolver. Shared by BOTH ``<vilib>``-rooted sources ``_resolve_parent``
+        can see (a plain-XML ``Parent`` Item's URL, and the binary
+        ``ParentClassLinkInfo``'s own recorded path — issue #84's #F1
+        correction: the URL case was previously naively joined, leaving a
+        literal ``<vilib>`` path component that never exists).
+
+        A configured ``vilib_root`` gives an exact, scan-free hit; otherwise
+        ``<vilib>`` maps onto ``search_paths`` (this loader's already-
+        configured SubVI roots) the same way, with ``_find_file``'s existing
+        bounded per-search-path lookup (used for every other unresolved
+        dependency) actually LOCATING the file when it's nested deeper than
+        a direct join reaches (e.g. actor-framework vendors ``Actor.lvclass``
+        under an extra ``Core/`` level the recorded path itself doesn't
+        record — LabVIEW's own vi.lib layout has no such prefix).
+        ``parent_intended`` is still produced via pure path math even when
+        no local file is found (one of ``vilib_root``/``search_paths[0]``),
+        so progressive/web staging can NAME + fetch it — never
+        ``.exists()``-gated away, same contract as the method-path code in
+        ``load_lvclass`` above."""
+        parent_file: Path | None = None
+        parent_intended: Path | None = None
+        dep_ref = ParsedDependencyRef(
+            name=parent_name + ".lvclass", path_tokens=path_tokens
+        )
+        candidate = dep_ref.resolve_against(
+            lvclass_path,
+            vilib_root=self._vilib_root,
+            userlib_root=self._userlib_root,
+            instrlib_root=self._instrlib_root,
+        )
+        if candidate is not None:
+            parent_intended = candidate
+            if candidate.exists():
+                parent_file = candidate
+        # Both the search_paths glob AND the search_paths[0]-as-vilib_root
+        # intended-path fallback are skipped once EITHER parent_file OR
+        # parent_intended is already known -- no point globbing when the
+        # exact vilib_root candidate already resolved, and no point
+        # recomputing parent_intended once parent_file has resolved (it's
+        # only ever consulted as parent_file's own fallback, never both).
+        if parent_file is None and parent_intended is None and search_paths:
+            parent_file = self._find_file(
+                parent_name + ".lvclass", search_paths, lvclass_path.parent
+            )
+        if parent_file is None and parent_intended is None and search_paths:
+            # No configured vilib_root — map <vilib> onto the first search
+            # root instead, so an absent parent still gets a deterministic
+            # (pure path math, no scan) intended path for web staging to
+            # name.
+            parent_intended = dep_ref.resolve_against(
+                lvclass_path, vilib_root=search_paths[0]
+            )
+        return parent_file, parent_intended
+
     def _resolve_parent(
-        self, cls: LVClass, lvclass_path: Path
+        self, cls: LVClass, lvclass_path: Path, search_paths: list[Path]
     ) -> tuple[Path | None, Path | None]:
         """The parent class's file (when present) and its INTENDED path
         (present or not) -> ``(parent_file, parent_intended)``.
 
         PREFERS the parent's own recorded URL (a DIRECT relative path — the
         parent commonly lives in a sibling subtree an up-tree walk can't
-        reach, e.g. ``../../Layer/Layer.lvclass``); falls back to a walk-up
-        by name only when no URL was recorded. Both None when the class has
-        no parent (or its parent is the root ``LabVIEW Object``).
+        reach, e.g. ``../../Layer/Layer.lvclass``) — UNLESS that URL is
+        itself ``<vilib>``-rooted (``cls.is_vilib_parent``, e.g.
+        ``"/<vilib>/ActorFramework/Actor/Actor.lvclass"``, verified against
+        Event Receiver Actor.lvclass's real ``Parent`` Item — a LEADING
+        SLASH, the marker, then forward-slash path components, NOT a normal
+        relative path), in which case it's tokenized and resolved via
+        ``_resolve_vilib_class_ref`` like any other vi.lib reference (issue
+        #84's #F1 correction — the naive join used to leave a literal
+        ``<vilib>`` path component that never exists).
+
+        When there's no URL but the parent's binary link record is
+        ``<vilib>``-rooted (``cls.parent_link_path``, issue #84 — e.g.
+        ``["<vilib>", "ActorFramework", "Actor", "Actor.lvclass"]``),
+        resolves it the SAME way via ``_resolve_vilib_class_ref``.
+
+        A NON-vilib link record (the "in-repo" PTH0 shape — no recorded
+        URL, parent lives elsewhere in the same tree) is deliberately left
+        to the existing bare-name walk-up below — ``resolve_against``'s
+        generic (non-``<vilib>``) branch reads leading EMPTY tokens as
+        ``..`` hops, a shape not verified against a real in-repo PTH0
+        record, so this stays scoped to what issue #84 actually asked for
+        rather than risking the already-working walk-up.
+
+        Falls back to a bare-name walk-up (``_walk_up_find`` —
+        filesystem-only, no search_paths, so it can't reach a cross-subtree
+        or vi.lib parent) when NEITHER a URL nor a resolved vilib link path
+        was found. Both None when the class has no parent (or its parent is
+        the root ``LabVIEW Object``).
         """
         parent = cls.parent_class
         parent_file: Path | None = None
         parent_intended: Path | None = None
         if parent and parent != "LabVIEW Object":
-            if cls.parent_url:
+            if cls.parent_url and cls.is_vilib_parent:
+                tokens = [t for t in cls.parent_url.split("/") if t]
+                parent_file, parent_intended = self._resolve_vilib_class_ref(
+                    parent, tokens, lvclass_path, search_paths
+                )
+            elif cls.parent_url:
                 # LabVIEW ``.lvclass`` URLs are relative to the class FILE
                 # treated as a directory (members read ``../X.vi``), so
                 # resolve against ``lvclass_path`` itself — that absorbs the
@@ -865,6 +976,10 @@ class LoadingMixin:
                 parent_intended = (lvclass_path / cls.parent_url).resolve()
                 if parent_intended.exists():
                     parent_file = parent_intended
+            elif cls.is_vilib_parent and cls.parent_link_path:
+                parent_file, parent_intended = self._resolve_vilib_class_ref(
+                    parent, cls.parent_link_path, lvclass_path, search_paths
+                )
             if parent_file is None and parent_intended is None:
                 parent_file = self._walk_up_find(
                     lvclass_path.parent, parent + ".lvclass"
@@ -1639,19 +1754,19 @@ class LoadingMixin:
             owner_chain = parts[:-1] if len(parts) > 1 else None
             # MINIMAL: field-load the class (no method bodies) — enough for
             # by-name field names. FULL: load its whole method tree for codegen.
-            loaded_qname = self.load_lvclass(
+            loaded_key = self.load_lvclass(
                 resolved,
                 mode,
                 search_paths=search_paths,
                 owner_chain=owner_chain,
             )
             if caller_qname:
-                self._dep_graph.add_edge(caller_qname, loaded_qname)
+                self._dep_graph.add_edge(caller_qname, loaded_key)
             # See the walk-up branch above: alias rather than let a
             # differently-cased reference create a second, empty dep_graph
             # node that shadows the real (populated) one.
-            if qualified_name != loaded_qname:
-                self._qualified_aliases[qualified_name] = loaded_qname
+            if qualified_name != loaded_key:
+                self._qualified_aliases[qualified_name] = loaded_key
         elif leaf.endswith(".lvlib"):
             lib_key = self.load_lvlib(resolved, mode, search_paths=search_paths)
             if caller_qname:

{lvkit-0.8.2 → lvkit-0.8.3}/src/lvkit/graph/models.py

@@ -158,17 +158,18 @@ class PrimitiveNode(GraphNode):
     # reference terminal, but this structural id list always can. See
     # ``op_walk.correlate_property_terminals``.
     property_value_terminal_ids: list[str] = []
-    # Property node only: the BOUND front-panel control's own ddo uid (RAW,
-    # unqualified -- not this node's own qualified id) when this property
-    # node is IMPLICIT (permanently tied to a specific control, e.g. GTR's
-    # "Abort" boolean property node) -- "" for an EXPLICIT one (identity from
-    # a wired reference). See ``parser.node_types.PropertyNode``'s class
-    # docstring for the full heap discriminator (a direct ``<ddo>`` child +
-    # a ``<label>`` naming the control, both absent when explicit).
+    # Property/Invoke node only: the BOUND front-panel control's own ddo uid
+    # (RAW, unqualified -- not this node's own qualified id) when this node
+    # is IMPLICIT (permanently tied to a specific control, e.g. GTR's
+    # "Abort" boolean property node or its "Test Hierarchy Tree" invoke
+    # node) -- "" for an EXPLICIT one (identity from a wired reference). See
+    # ``parser.node_types.PropertyNode``/``InvokeNode``'s class docstrings
+    # for the full heap discriminator (a direct ``<ddo>`` child + a
+    # ``<label>`` naming the control, both absent when explicit).
     bound_control_uid: str = ""
     # The bound control's reconstructed LVType (``parser.fp_heap_type.
     # reconstruct_control_lvtype``, resolved at PARSE time against the
-    # front-panel heap -- see ``parser.vi._resolve_property_node_bound_types``).
+    # front-panel heap -- see ``parser.vi._resolve_bound_control_types``).
     # None for an explicit node, or an implicit one whose control class isn't
     # modeled by that reconstructor.
     bound_control_type: LVType | None = None

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

@@ -406,7 +406,7 @@ def parse_polymorphic_info(root: ET.Element) -> dict[str, Any]:
 
     # Check for AllowPolyTypeAdapt flag - this indicates a polymorphic wrapper
     # VIs that call polymorphic VIs have PolyVI TypeDesc but AllowPolyTypeAdapt="0"
-    exec2 = root.find(".//LVSR//Execution2")
+    exec2 = root.find(".//LVSR/Section/Execution2")
     if exec2 is None or exec2.get("AllowPolyTypeAdapt") != "1":
         # Also check for selector-based polymorphic (ShowPolySelector)
         if exec2 is None or exec2.get("ShowPolySelector") != "1":
@@ -515,11 +515,26 @@ def _decode_pth0_components(
     ``end`` bounds how far the decode may read (exclusive) -- either
     ``len(data)`` for a whole-file scan or a caller-defined record boundary.
     Reads the component count at ``pth0_offset+10:+12`` (guarded to
-    ``0 < ncomp <= 64`` -- a sanity bound against a garbage length), then
-    decodes each component as a pascal string (1-byte length prefix + native
-    text). Returns ``([], pth0_offset)`` if the record is truncated (would read
-    past ``end``) or the count is out of range -- a partial token list is never
-    returned, so a truncated record reads as "no components" to every caller.
+    ``0 <= ncomp <= 64`` -- a sanity bound against a garbage length; ``0`` is
+    a REAL, legitimate value -- LabVIEW's own encoding for an empty/unset
+    Path, e.g. ``PTH0 00 00 00 04 00 00 00 00`` -- never rejected as
+    "truncated": see issue #91, where treating ncomp==0 as an error made
+    ``_walk_path`` return ``consumed=0`` for a genuinely empty path, which
+    left the CALLER's byte offset stuck. For a cluster field, every
+    subsequent field then decoded from that stale offset -- e.g. GTR's SMUI
+    cluster's ``TestMethods``/``TestProjectClasses`` arrays (variable-size,
+    confirmed by their type descriptor's ``FixedSize="0xFFFFFF"`` sentinel,
+    never a fixed bound) read a residual `"PTH0"` tag as their 4-byte
+    element count once an earlier empty ``Open Path``/``Test Project``
+    field desynced them -- a real leading count IS present and correct once
+    alignment holds), then decodes each component as a pascal string
+    (1-byte length prefix + native text). Returns ``([], pth0_offset)`` if
+    the record is truncated (would read past ``end``) or the count is out
+    of range -- a partial token list is never returned, so a truncated
+    record reads as "no components" to every caller. An empty path
+    (``ncomp==0``) is NOT truncated -- it returns ``([], pth0_offset + 12)``,
+    the byte offset just past its magic+length+ncomp fields (see the
+    12-byte-record math above), so the caller's alignment stays correct.
     ``next_idx`` is the byte offset just past the last decoded component --
     the single source of both the decoded tokens AND the consumed-byte count,
     shared by every caller that needs to keep reading past this record (e.g.
@@ -529,8 +544,10 @@ def _decode_pth0_components(
     if pth0_offset + 12 > end:
         return [], pth0_offset
     ncomp = int.from_bytes(data[pth0_offset + 10 : pth0_offset + 12], "big")
-    if not (0 < ncomp <= 64):
+    if not (0 <= ncomp <= 64):
         return [], pth0_offset
+    if ncomp == 0:
+        return [], pth0_offset + 12
     idx = pth0_offset + 12
     tokens: list[str] = []
     for _ in range(ncomp):

{lvkit-0.8.2 → lvkit-0.8.3}/src/lvkit/parser/node_types.py

@@ -60,18 +60,6 @@ class ArrayBuildNode(ParsedNode):
     pass  # No extra fields yet
 
 
-@dataclass
-class ArrayInitNode(ParsedNode):
-    """Initialize Array node (class="aInit").
-
-    Builds an N-dimensional array from an element value and one size input per
-    dimension. Terminals (element + dimension sizes → array) carry on the base
-    ParsedNode; no extra fields.
-    """
-
-    pass
-
-
 @dataclass
 class FormulaNode(ParsedNode):
     """A Formula Node (class="fBox") with an embedded C-like script.
@@ -498,17 +486,6 @@ class ArrayBuildHandler(NodeTypeHandler):
         return ArrayBuildNode(**common)
 
 
-class ArrayInitHandler(NodeTypeHandler):
-    """Handler for Initialize Array nodes (class="aInit")."""
-
-    xml_class = "aInit"
-    display_name = "Initialize Array"
-
-    def parse(self, elem: ET.Element) -> ArrayInitNode:
-        common = self._extract_common(elem)
-        return ArrayInitNode(**common)
-
-
 class WhileLoopHandler(NodeTypeHandler):
     """Handler for While Loop nodes (class="whileLoop")."""
 
@@ -687,6 +664,17 @@ class InvokeNode(ParsedNode):
     sides of a row, but only wireable sides get a real type. See the
     render layer (``render/nodes.py:_invoke_node_glyph``), which is where
     that Void check happens (type resolution isn't available at parse time).
+
+    Like ``PropertyNode``, an Invoke Node draws in one of two forms
+    depending on whether it is permanently bound to a specific front-panel
+    control (IMPLICIT) or takes its identity from a wired reference
+    (EXPLICIT) -- the SAME heap discriminator: an IMPLICIT node carries a
+    direct ``<ddo uid="...">`` CHILD (a sibling of its own ``<termList>``,
+    never a part of it) naming the bound control, plus a ``<label>``
+    showing that control's NAME instead of the generic node name (verified
+    on GTR's "Test Hierarchy Tree" invoke node, uid 11387, bound-control ddo
+    uid 12, ``<methName>"Custom Item Symbols.Revert Symbols"``). An EXPLICIT
+    node has neither.
     """
 
     object_name: str = ""
@@ -694,6 +682,18 @@ class InvokeNode(ParsedNode):
     method_name: str = ""
     method_code: int = 0
     row_terminal_uids: list[str] = field(default_factory=list)
+    # The BOUND control's own ddo uid (see class docstring) -- "" for an
+    # EXPLICIT invoke node (no such binding). The sole discriminator: never
+    # inferred from the label text or from wiring (those only corroborate).
+    bound_control_uid: str = ""
+    # The bound control's reconstructed LVType (via
+    # ``fp_heap_type.reconstruct_control_lvtype`` on ``bound_control_uid``'s
+    # ddo in the FRONT-PANEL heap -- resolved by ``_parse_block_diagram``,
+    # which has both heaps, never by ``render/`` reading heap XML itself).
+    # None for an explicit node, OR an implicit one whose control class this
+    # reconstructor doesn't model (see that function's own docstring) --
+    # never a guessed color in either case.
+    bound_control_type: LVType | None = None
 
 
 @dataclass
@@ -788,6 +788,12 @@ class InvokeNodeHandler(NodeTypeHandler):
             meth_code = int(meth_code_text)
         except ValueError:
             meth_code = 0
+        # An IMPLICIT invoke node's DIRECT <ddo> CHILD (a sibling of its own
+        # <termList>, never a part of it) names the front-panel control it's
+        # permanently bound to (see InvokeNode's class docstring) -- absent
+        # entirely for an EXPLICIT one.
+        bound_ddo = elem.find("ddo")
+        bound_control_uid = bound_ddo.get("uid", "") if bound_ddo is not None else ""
         return InvokeNode(
             **common,
             object_name=clean_labview_string(elem.findtext("nodeName")),
@@ -795,6 +801,7 @@ class InvokeNodeHandler(NodeTypeHandler):
             method_name=clean_labview_string(elem.findtext("methName")),
             method_code=meth_code,
             row_terminal_uids=_dco_list_terminal_uids(elem),
+            bound_control_uid=bound_control_uid,
         )
 
 
@@ -1319,7 +1326,6 @@ _HANDLERS: list[NodeTypeHandler] = [
     FeedbackSlaveHandler(),
     CpdArithHandler(),
     ArrayBuildHandler(),
-    ArrayInitHandler(),
     WhileLoopHandler(),
     ForLoopHandler(),
     SelectHandler(),

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

@@ -64,7 +64,7 @@ from .models import (
     ParsedWire,
     SelectorTable,
 )
-from .node_types import PropertyNode, parse_node
+from .node_types import InvokeNode, PropertyNode, parse_node
 from .nodes import (
     extract_case_structures,
     extract_constants,
@@ -374,7 +374,7 @@ def _parse_block_diagram(
     root = tree.getroot()
 
     nodes = _extract_nodes(root)
-    _resolve_property_node_bound_types(nodes, fp_xml)
+    _resolve_bound_control_types(nodes, fp_xml)
     constants = extract_constants(root)
     labels = extract_free_labels(root)
     wires = _extract_wires(root)
@@ -615,21 +615,25 @@ def _extract_nodes(root: ET.Element) -> list[ParsedNode]:
     return nodes
 
 
-def _resolve_property_node_bound_types(
+def _resolve_bound_control_types(
     nodes: list[ParsedNode], fp_xml: Path | str | None
 ) -> None:
-    """Resolve each IMPLICIT ``PropertyNode``'s ``bound_control_type`` from
-    the FRONT-PANEL heap (see ``PropertyNode``'s class docstring for the
-    ``bound_control_uid`` discriminator) -- in-place, mutating ``nodes``.
+    """Resolve each IMPLICIT ``PropertyNode``/``InvokeNode``'s
+    ``bound_control_type`` from the FRONT-PANEL heap (see each class's own
+    docstring for the ``bound_control_uid`` discriminator -- the SAME direct
+    ``<ddo>``-child convention for both node kinds) -- in-place, mutating
+    ``nodes``.
 
-    This is the one place render's "implicit vs explicit" property-node
+    This is the one place render's "implicit vs explicit" node-identity
     distinction touches the front-panel heap: done here at PARSE time (this
     module owns both heaps), never in ``render/``, which only ever reads the
     already-decoded graph/``Layout`` (see ``layout.py``'s own module
     docstring). The FP root is parsed at most ONCE per VI, only when at
-    least one property node actually needs it."""
-    bound: list[PropertyNode] = [
-        n for n in nodes if isinstance(n, PropertyNode) and n.bound_control_uid
+    least one node actually needs it."""
+    bound: list[PropertyNode | InvokeNode] = [
+        n
+        for n in nodes
+        if isinstance(n, (PropertyNode, InvokeNode)) and n.bound_control_uid
     ]
     if not bound or not fp_xml:
         return
@@ -637,10 +641,10 @@ def _resolve_property_node_bound_types(
     if not fp_path.exists():
         return
     fp_root = ET.parse(fp_path).getroot()
-    for prop_node in bound:
-        ddo = fp_root.find(f".//*[@uid='{prop_node.bound_control_uid}']")
+    for bound_node in bound:
+        ddo = fp_root.find(f".//*[@uid='{bound_node.bound_control_uid}']")
         if ddo is not None:
-            prop_node.bound_control_type = reconstruct_control_lvtype(ddo)
+            bound_node.bound_control_type = reconstruct_control_lvtype(ddo)
 
 
 def _extract_wires(root: ET.Element) -> list[ParsedWire]:
@@ -1691,11 +1695,24 @@ def _decode_element(data: bytes, elem_type: LVType | None) -> tuple[str | None,
     if underlying in ("LVVariant", "Variant"):
         return "Variant()", len(data)
 
-    # MeasureData (timestamp): 16 bytes (8 int + 8 frac)
+    # MeasureData (timestamp): 16 bytes -- LabVIEW's 128-bit timestamp is an
+    # i64 whole-second count (data[:8]) plus a u64 FRACTION of a second
+    # (data[8:16], fraction = u64/2**64 sec) -- both halves threaded through
+    # so a real (non-epoch) timestamp shows its actual sub-second value
+    # (task #66 follow-up) instead of always truncating to ".000". Emitted
+    # as decimal microseconds (matching datetime.timedelta's own resolution
+    # ceiling -- finer precision would be silently rounded away by the
+    # renderer's timedelta(seconds=...) reconstruction anyway), carrying
+    # into the whole-second count on the (rare) round-up-to-1.0 edge.
     if underlying == "MeasureData":
         if len(data) >= 16:
             secs = int.from_bytes(data[:8], "big", signed=True)
-            return f"Timestamp({secs})", 16
+            frac_u64 = int.from_bytes(data[8:16], "big", signed=False)
+            frac_micros = round(frac_u64 * 1_000_000 / 2**64)
+            if frac_micros >= 1_000_000:
+                secs += 1
+                frac_micros = 0
+            return f"Timestamp({secs}.{frac_micros:06d})", 16
         return "Timestamp(0)", len(data)
 
     return None, 0

{lvkit-0.8.2 → lvkit-0.8.3}/src/lvkit/render/glyphs/nodes/base.py

@@ -410,17 +410,41 @@ def _draw_node_tile(
 # fixed left gutter wide enough for one arrow, so a row's label starts at the
 # same x whether or not that row actually draws a left arrow.
 _ROW_LPAD = 3.0
-
-# Shared drawer-row geometry for PropertyNodeGlyph and InvokeNodeGlyph: a
-# fixed left gutter wide enough for one arrow, so a row's label starts at the
-# same x whether or not that row actually draws a left arrow.
-_ROW_LPAD = 3.0
-_ROW_ARROW_W = 7.0
-
 _ROW_ARROW_W = 7.0
 _ROW_GUTTER = _ROW_ARROW_W + _ROW_LPAD
 
 
+@dataclass(frozen=True)
+class DrawerHeaderGlyphBase:
+    """Common implicit/explicit-binding fields shared by ``PropertyNodeGlyph``
+    and ``InvokeNodeGlyph`` (task #51/#55) -- both draw a HEADER band (see
+    ``draw_drawer_header``) above a DRAWER of named rows, keyed by whether
+    the node is permanently bound to a specific front-panel control:
+
+    - EXPLICIT (``is_implicit=False``): the header names the object CLASS
+      the wired reference is of (``⚙ <class_name>``); the reference/error
+      terminals thread the box edges at the header level, placed by the
+      scene, not drawn here.
+    - IMPLICIT (``is_implicit=True``): the header names the BOUND control
+      itself (``target_name``), and a TYPE-COLOR BAR (``bar_color``) draws
+      under the header instead. No reference terminals thread through.
+
+    Subclasses add only their own row tuple (the drawer's per-row shape
+    differs — a property row is ``(name, is_read)``, an invoke row is
+    ``(name, show_left, show_right)``) plus any glyph-specific fields
+    (``InvokeNodeGlyph``'s ``method``/``return_present``), and their own
+    ``cell_h`` denominator (one header cell + one per row for a property
+    node; header + method + one per param for an invoke node)."""
+
+    class_name: str = ""  # object class shown in the header (e.g. "VI")
+    is_implicit: bool = False
+    target_name: str = ""  # the bound control's own name (implicit only)
+    bar_color: str | None = None  # the bound control's wire color (implicit only)
+    fill_attr: str = "prim_fill"
+    stroke_attr: str = "prim_stroke"
+    text_attr: str = "prim_text"
+
+
 def _draw_drawer_row(
     backend: Backend,
     x1: float,
@@ -466,3 +490,60 @@ def _draw_drawer_row(
             lsize,
             fill=text_fill,
         )
+
+
+def draw_drawer_header(
+    backend: Backend,
+    x1: float,
+    x2: float,
+    y1: float,
+    cell_h: float,
+    *,
+    is_implicit: bool,
+    target_name: str,
+    class_name: str,
+    bar_color: str | None,
+    stroke: str,
+    text_fill: str,
+    lsize: float,
+) -> float:
+    """Shared header band for ``PropertyNodeGlyph``/``InvokeNodeGlyph``: the
+    object class (explicit) or the BOUND CONTROL's own name (implicit) —
+    see either glyph's class docstring for the full implicit/explicit
+    contract — with a divider beneath. For an EXPLICIT node this is the row
+    the reference + error terminals thread through (drawn by the scene, not
+    here); an implicit node has none to thread, and instead draws a
+    TYPE-COLOR BAR (``bar_color``) in a thin band under the header text.
+    Returns ``hy2``, the header band's bottom y (where the caller's own
+    method/property drawer rows start)."""
+    lpad = _ROW_LPAD
+    hy2 = y1 + cell_h
+    if is_implicit and target_name:
+        header = target_name
+    else:
+        header = f"⚙ {class_name}".strip() if class_name else "⚙ class"
+    bar_h = min(5.0, cell_h * 0.3) if is_implicit else 0.0
+    text_cy = y1 + (cell_h - bar_h) / 2
+    backend.text(
+        (x1 + x2) / 2,
+        text_cy + lsize * 0.34,
+        fit_label(header, (x2 - x1) - 2 * lpad, backend, lsize),
+        lsize,
+        fill=text_fill,
+    )
+    if bar_h >= 1.0 and bar_color:
+        # The TYPE-COLOR BAR: a thin band in the bound control's own wire
+        # color, filling most of the header's width — LabVIEW's own cue for
+        # "this node's identity is a specific control of THIS type",
+        # replacing the (absent) reference terminals. Guarded to bar_h>=1.0
+        # (not just >0): the rect's own top/bottom are hy2-bar_h/hy2-1.0, so
+        # a bar_h under 1px would draw with NEGATIVE height (top below
+        # bottom) — an inverted rect — for a very short cell (cell_h below
+        # ~3.3px, since bar_h = min(5.0, cell_h*0.3)).
+        bar_pad = (x2 - x1) * 0.12
+        backend.rect(
+            x1 + bar_pad, hy2 - bar_h, x2 - bar_pad, hy2 - 1.0,
+            fill=bar_color, stroke="none",
+        )
+    backend.line(x1, hy2, x2, hy2, stroke=stroke, stroke_width=1.0)
+    return hy2