@aryacode/dsh-engineering 0.0.0-stage → 0.3.0

package/vendor/mwi/code/engine/motionworks_iec_mcp/eip.py

@@ -0,0 +1,292 @@
+"""EtherNet/IP assembly map: how much of each assembly a project actually uses.
+
+WHY THIS EXISTS
+---------------
+"Is there room for another status word?" is asked every time a diagnostic is added, and answering
+it took several steps in the session that prompted this: the ``%QW`` base, the
+``I.Data[n] = %QW(base + 2n)`` rule, a scan of the project's declarations, and the module's
+``PrimCxnInputSize``/``PrimCxnOutputSize`` attributes in the L5X. Every one of those is a fact
+that can be read, so the answer belongs in one call rather than in a reconstruction.
+
+WHAT IT READS, AND FROM WHERE
+-----------------------------
+Two independent sources, reported separately because they can disagree:
+
+* the **L5X** module definition gives the assembly SIZES, in bytes, as the scanner declares them
+  (``Communications/@PrimCxnInputSize`` and ``PrimCxnOutputSize``);
+* the **MotionWorks project** gives the USED range, because every mapped word and bit is a
+  declared variable carrying an IEC address such as ``%QX21488.0`` or ``%QW21492``.
+
+Neither alone answers the question. Sizes without usage cannot say how much is left; usage
+without sizes cannot say what is left *of*.
+
+ADDRESS ARITHMETIC
+------------------
+The addresses are 16-bit word addresses, and ``.n`` names a bit. Measured on the TopCutter
+interface: ``%IX21488.0`` is ``O.Data[0].0`` and ``%IW21490`` is ``O.Data[1]``, so a data word is
+two address units. The byte width of a word is therefore what turns bytes into words:
+``words = bytes / 2``. The module and the project both use 16-bit ``INT`` elements.
+
+THE ONE THING THIS DOES NOT DO
+------------------------------
+It does not decide that a gap is usable. It reports the first word address that is NOT used and
+the room remaining after it, which is arithmetic over what was read; whether an unused word is
+free to take is a question about the peer's program, and guessing at that is how an interface
+ends up with two things writing the same offset.
+"""
+
+from __future__ import annotations
+
+import re
+import xml.etree.ElementTree as ET
+from pathlib import Path
+
+#: ``%QW21492``, ``%IX21488.0``, ``%IB21488`` — the IEC address forms this understands.
+_ADDRESS = re.compile(
+    r"^%(?P<area>[IQM])(?P<size>[XBWDL])(?P<word>\d+)(?:\.(?P<bit>\d+))?$",
+    re.IGNORECASE,
+)
+
+#: Bits per word, and the byte width of one address unit, for a data word on this interface.
+#: Measured, not assumed: O.Data[n] advances the address by 2, and each element is an INT.
+ADDRESS_UNITS_PER_WORD = 2
+BYTES_PER_WORD = 2
+
+
+def read_project_addresses(project_root: Path | str) -> list[dict]:
+    """Every declared variable in the project that carries an IEC address.
+
+    Uses the same declaration reader the rest of the engine uses, so this cannot drift from what
+    mw_code_globals and mw_code_read_st report.
+    """
+    from . import project as P
+
+    root = Path(project_root)
+    proj = P.Project(root=root)
+    found: list[dict] = []
+
+    def collect(table, owner: str) -> None:
+        for v in getattr(table, "variables", []) or []:
+            address = getattr(v, "address", None)
+            if not address:
+                continue
+            found.append({
+                "name": getattr(v, "name", None),
+                "type": getattr(v, "type_name", None),
+                "address": str(address),
+                "owner": owner,
+            })
+
+    try:
+        collect(proj.global_variables(), "(globals)")
+    except Exception:
+        pass
+    for info in proj.pous():
+        try:
+            collect(info.declarations(), info.name)
+        except Exception:
+            continue
+    return found
+
+
+def _data_words(addresses: list[dict]) -> dict:
+    """Group ``%I``/``%Q`` addresses into the used word set, per direction.
+
+    ``.`` marks a bit inside a word, so ``%IX21488.0`` and ``%IW21490`` both occupy a word: the
+    first shares its word with its neighbours, the second owns one. Both are recorded as used,
+    which is what "is there room" has to be computed against.
+    """
+    used: dict[str, set[int]] = {"input": set(), "output": set()}
+    detail: dict[str, list[dict]] = {"input": [], "output": []}
+    unparsed: list[str] = []
+
+    for entry in addresses:
+        m = _ADDRESS.match(entry["address"])
+        if not m:
+            unparsed.append(entry["address"])
+            continue
+        area = m.group("area").upper()
+        if area not in ("I", "Q"):
+            continue  # %M (internal marker) is not part of an assembly
+        direction = "input" if area == "I" else "output"
+        word = int(m.group("word"))
+        size = m.group("size").upper()
+        bit = m.group("bit")
+        if size == "X" and bit is not None:
+            # A bit address names its word, and the word it names is the one in use.
+            used[direction].add(word)
+            detail[direction].append({**entry, "direction": direction, "word": word, "kind": "bit"})
+        elif size in ("W", "B", "D", "L"):
+            # A whole-element address. W is one word; the wider forms occupy more than one, and
+            # this reports the span rather than pretending they are all one word wide.
+            span = {"W": 1, "B": 1, "D": 2, "L": 2}[size]
+            # Address units: a word address advances by ADDRESS_UNITS_PER_WORD, so each
+            # extra data word advances the address by that much.
+            for i in range(span):
+                used[direction].add(word + i * ADDRESS_UNITS_PER_WORD)
+            detail[direction].append({
+                **entry, "direction": direction, "word": word, "kind": f"element({size})",
+                "words": span,
+            })
+        else:
+            unparsed.append(entry["address"])
+
+    return {"used": used, "detail": detail, "unparsed": unparsed}
+
+
+def _runs(words: set[int]) -> list[dict]:
+    """Contiguous runs of used word addresses, so a gap is visible as a gap."""
+    if not words:
+        return []
+    ordered = sorted(words)
+    runs = []
+    start = prev = ordered[0]
+    for w in ordered[1:]:
+        if w == prev + ADDRESS_UNITS_PER_WORD:
+            prev = w
+            continue
+        runs.append({"first": start, "last": prev, "words": (prev - start) // ADDRESS_UNITS_PER_WORD + 1})
+        start = prev = w
+    runs.append({"first": start, "last": prev, "words": (prev - start) // ADDRESS_UNITS_PER_WORD + 1})
+    return runs
+
+
+def read_l5x_module(l5x: Path | str, module_name: str | None = None) -> dict:
+    """The Ethernet module's declared assembly sizes, from an exported L5X.
+
+    Reads the ``<Module>`` whose ``CatalogNumber`` is ``ETHERNET-MODULE`` — a generic
+    EtherNet/IP module — because that is the shape this interface uses. A named module wins when
+    the caller passes one.
+    """
+    path = Path(l5x)
+    if not path.is_file():
+        raise FileNotFoundError(f"L5X not found: {path}")
+    tree = ET.parse(path)
+    root = tree.getroot()
+
+    candidates = []
+    for module in root.iter("Module"):
+        if module_name and module.get("Name") != module_name:
+            continue
+        if not module_name and module.get("CatalogNumber") != "ETHERNET-MODULE":
+            continue
+        comms = module.find("Communications")
+        if comms is None:
+            continue
+        candidates.append({
+            "name": module.get("Name"),
+            "catalog": module.get("CatalogNumber"),
+            "vendor": module.get("Vendor"),
+            "product_type": module.get("ProductType"),
+            "product_code": module.get("ProductCode"),
+            "revision": f"{module.get('Major')}.{module.get('Minor')}",
+            "input_bytes": int(comms.get("PrimCxnInputSize") or 0),
+            "output_bytes": int(comms.get("PrimCxnOutputSize") or 0),
+        })
+
+    if not candidates:
+        named = f" named '{module_name}'" if module_name else ""
+        raise ValueError(
+            f"no EtherNet/IP module{named} with a <Communications> element in {path.name}. "
+            "Pass module_name if the module is not a generic ETHERNET-MODULE."
+        )
+    return {"l5x": str(path), "modules": candidates}
+
+
+def build_map(
+    project_root: Path | str | None = None,
+    l5x: Path | str | None = None,
+    module_name: str | None = None,
+) -> dict:
+    """Assemble the answer from whichever sources the caller supplied."""
+    report: dict = {"automatic_changes": False}
+
+    modules: list[dict] = []
+    if l5x:
+        report["module_source"] = read_l5x_module(l5x, module_name)
+        modules = report["module_source"]["modules"]
+
+    used = {"input": set(), "output": set()}
+    detail = {"input": [], "output": []}
+    unparsed: list[str] = []
+    if project_root:
+        parsed = _data_words(read_project_addresses(project_root))
+        used, detail, unparsed = parsed["used"], parsed["detail"], parsed["unparsed"]
+
+    assemblies: list[dict] = []
+    for direction, size_key in (("input", "input_bytes"), ("output", "output_bytes")):
+        entry: dict = {"direction": direction}
+        words = used[direction]
+        declared_words = None
+        if modules:
+            declared_words = modules[0][size_key] // BYTES_PER_WORD
+            entry["declared_bytes"] = modules[0][size_key]
+            entry["declared_words"] = declared_words
+
+        # THE ASSEMBLY IS A WINDOW, NOT EVERY ADDRESS IN THE PROJECT.
+        #
+        # Measured: the project carries %I/%Q addresses at 21488 AND at 61443, and a naive
+        # min/max over both reported a 64-word assembly spanning 39,955 words with the "next free"
+        # address at 61445. Both numbers were arithmetically faithful and completely wrong: they
+        # described two separate I/O areas as one.
+        #
+        # The base is the lowest address in the direction, which is what a mapped assembly starts
+        # at; anything at or beyond base + declared span is a different module's area and is
+        # reported separately rather than folded in.
+        outside: list[int] = []
+        if declared_words is not None and words:
+            base = min(words)
+            limit = base + declared_words * ADDRESS_UNITS_PER_WORD
+            inside = {w for w in words if base <= w < limit}
+            outside = sorted(w for w in words if w >= limit)
+            entry["base_word_address"] = base
+            entry["window_last_word_address"] = limit - ADDRESS_UNITS_PER_WORD
+            words = inside
+
+        entry["used_words"] = len(words)
+        entry["used_runs"] = _runs(words)
+        if words:
+            entry["first_word_address"] = min(words)
+            entry["last_word_address"] = max(words)
+            entry["span_words"] = (max(words) - min(words)) // ADDRESS_UNITS_PER_WORD + 1
+        if declared_words is not None:
+            entry["unused_words"] = declared_words - entry["used_words"]
+            entry["full"] = entry["unused_words"] <= 0
+            # THE ANSWER TO THE QUESTION, when it can be given: the first word address past the
+            # highest one in use. Whether the PEER leaves it alone is not knowable from here.
+            if words:
+                entry["next_free_word_address"] = max(words) + ADDRESS_UNITS_PER_WORD
+                entry["contiguous_room_after_last"] = (
+                    entry["window_last_word_address"] - max(words)
+                ) // ADDRESS_UNITS_PER_WORD
+        if outside:
+            entry["addresses_outside_this_assembly"] = {
+                "count": len(outside),
+                "first": outside[0],
+                "note": (
+                    "these %I/%Q addresses lie at or beyond this assembly's declared span, so they "
+                    "belong to a different module's area; they are NOT part of this map and this "
+                    "map's unused_words does not describe them"
+                ),
+            }
+        entry["elements"] = detail[direction]
+        assemblies.append(entry)
+
+    report["assemblies"] = assemblies
+    report["address_rules"] = {
+        "unit": "16-bit word",
+        "bytes_per_word": BYTES_PER_WORD,
+        "address_units_per_word": ADDRESS_UNITS_PER_WORD,
+        "note": (
+            "measured on this interface: O.Data[1] is %IW21490 and O.Data[0].0 is %IX21488.0, so "
+            "each data word advances the address by 2 and each element is one 16-bit INT"
+        ),
+    }
+    if unparsed:
+        report["addresses_not_understood"] = sorted(set(unparsed))
+    report["note"] = (
+        "used_words counts declared variables carrying an %I/%Q address; it does not prove the "
+        "peer program leaves the remaining words alone, so confirm a new offset against the "
+        "CompactLogix side before writing it"
+    )
+    return report

package/vendor/mwi/code/engine/motionworks_iec_mcp/errors.py

@@ -0,0 +1,36 @@
+"""Typed errors that surface as actionable messages in MCP tool results."""
+
+from __future__ import annotations
+
+
+class MotionWorksError(Exception):
+    """Base class for every failure this package reports to an agent."""
+
+
+class ProjectNotFound(MotionWorksError):
+    """The requested project could not be resolved to an expanded directory."""
+
+
+class AmbiguousProject(MotionWorksError):
+    """A bare project name matched more than one project on disk."""
+
+
+class IdeRunning(MotionWorksError):
+    """MotionWorks IEC is open, so writing would be unsafe.
+
+    The IDE caches project state in memory and rewrites whole files on save, so
+    an external edit made while it is open will either be silently discarded or
+    produce an inconsistent project.
+    """
+
+
+class UnsupportedFormat(MotionWorksError):
+    """The on-disk format differs from the versions this package understands."""
+
+
+class VerificationFailed(MotionWorksError):
+    """A post-write read-back did not match what was written."""
+
+
+class NotFound(MotionWorksError):
+    """A named POU, variable, or file does not exist in the project."""

package/vendor/mwi/code/engine/motionworks_iec_mcp/graphical_listing.py

@@ -0,0 +1,208 @@
+"""Read bounded compiler networks with exact POU and worksheet identities.
+
+No binary graphical decoding or writes. The caller must bind this cache to a
+fresh native Build and unchanged complete source baseline.
+"""
+import hashlib
+import re
+from pathlib import Path, PureWindowsPath
+
+HEADER = re.compile(r'\A\(\*\s*T: (PROGRAM|FUNCTION_BLOCK|FUNCTION) ([A-Za-z_][A-Za-z_0-9]*)\s', re.S)
+SYMBOL = re.compile(r'@IFBP (\d+)\.(\d+)(?![\d.])|@(RV|IV|IFB) (\d+)(?!\d)')
+DECLARATION = re.compile(r'^([A-Za-z_][A-Za-z_0-9]*)\t(\d+)\t(VAR[A-Z_]*)\t([^\r\n]+)\r?\n([^;]*);', re.M)
+# Generated private code temporaries are counted for completeness, never exposed
+# as public pins. CamGenerator contains @T_Code_00 after its 140 source rows.
+DEPENDENCY_DECLARATION = re.compile(r'^((?:[A-Za-z_][A-Za-z_0-9@]*|@T_Code_[0-9]+))\t(\d+)\t(VAR[A-Z_]*)\t([^\r\n]+)\r?\n([^;]*);', re.M)
+MAX_BYTES = 2_000_000
+
+
+def read_text(path, root):
+    if not path.resolve().is_relative_to(root.resolve()):
+        raise ValueError('Compiler artifact resolves outside project')
+    before = path.stat()
+    raw = path.read_bytes()
+    after = path.stat()
+    if (before.st_size,before.st_mtime_ns)!=(after.st_size,after.st_mtime_ns):
+        raise ValueError('Compiler artifact changed during read')
+    if len(raw) > MAX_BYTES or b'\0' in raw:
+        raise ValueError('Unsupported compiler text size/encoding')
+    return raw.decode('latin1'), dict(path=str(path), sha256=hashlib.sha256(raw).hexdigest(), bytes=len(raw), modified_ms=after.st_mtime_ns/1_000_000)
+
+
+def identity(text):
+    match = HEADER.match(text)
+    if not match:
+        raise ValueError('Unknown compiler listing header')
+    return match.groups()
+
+
+def symbols(text, saved=None):
+    result, rows, ordinals, names = {}, [], set(), set()
+    def bind(token, row):
+        if token in result and result[token] != row:
+            raise ValueError('Ambiguous compiler symbol')
+        result[token] = row
+    for match in DECLARATION.finditer(text):
+        name, ordinal, section, type_token, detail = match.groups()
+        if ordinal in ordinals or name.casefold() in names or int(ordinal) < 1:
+            raise ValueError('Ambiguous compiler declaration ordinal/name')
+        ordinals.add(ordinal); names.add(name.casefold())
+        row = dict(name=name, section=section)
+        rows.append((name, section))
+        explicit = re.findall(r'^@(RV|IV) (\d+)(?:\s|$)', detail, re.M)
+        if len(explicit) > 1:
+            raise ValueError('Ambiguous compiler declaration token')
+        if explicit:
+            kind, number = explicit[0]
+            bind('@' + kind + ' ' + number, row)
+        elif section in ('VAR', 'VAR_INPUT', 'VAR_OUTPUT', 'VAR_IN_OUT', 'VAR_TEMP'):
+            # Local operands use the declaration ordinal. FB instances use the
+            # same ordinal under IFB; the type ID remains raw compiler evidence.
+            if re.fullmatch(r'@FB:\d+\s*', type_token):
+                bind('@IFB ' + ordinal, row)
+            elif re.match(r'@TYP:\d+(?:\s|$)', type_token):
+                bind('@IV ' + ordinal, row)
+    if saved is not None:
+        if sorted(rows) != sorted((v.name, v.section) for v in saved):
+            raise ValueError('Compiler declarations differ from saved worksheet')
+    return result
+
+
+def pin_bindings(code, declarations, saved, path, root):
+    """Bind only public pins from exact compiler FB dependencies, never UI order."""
+    needed = {m.group(1) for m in SYMBOL.finditer(code) if m.group(1) is not None}
+    saved_types = {v.name: v.type_name for v in saved}
+    pins, artifacts, cache = {}, [], {}
+    directions = {'VAR_INPUT': 'input', 'VAR_OUTPUT': 'output', 'VAR_IN_OUT': 'in_out'}
+    for match in DECLARATION.finditer(declarations):
+        name, ordinal, section, type_token, _ = match.groups()
+        fb = re.fullmatch(r'@FB:(\d+)\s*', type_token)
+        if ordinal not in needed or not fb or section not in ('VAR', 'VAR_INPUT', 'VAR_OUTPUT', 'VAR_IN_OUT', 'VAR_TEMP'):
+            continue
+        type_id = int(fb.group(1))
+        if type_id not in cache:
+            dependency = path.with_name(f'ICI{type_id:05d}.DIT')
+            text, evidence = read_text(dependency, root)
+            kind, block = identity(text)
+            if '*)' not in text:
+                raise ValueError('Truncated compiler FB dependency header')
+            header = text.split('*)', 1)[0]
+            ids = re.findall(r'^CI#:\s*(\d+)\s*$', header, re.M)
+            counts = re.findall(r'^QVE:\s*(\d+)\s*$', header, re.M)
+            if kind != 'FUNCTION_BLOCK' or len(ids) != 1 or int(ids[0]) != type_id:
+                raise ValueError('Compiler FB dependency identity mismatch')
+            # Graphical library FBs contain compiler-only names such as Code@@80.
+            # Count those private rows, but never expose them as public pins.
+            rows = list(DEPENDENCY_DECLARATION.finditer(text))
+            # QVE includes internal declarations; a partial parse must not resolve pins.
+            if len(counts) != 1 or int(counts[0]) != len(rows):
+                raise ValueError('Compiler FB dependency declarations are incomplete')
+            symbols(text)  # Reject duplicate names/ordinals and ambiguous bindings.
+            names = {r.group(1).casefold() for r in rows}
+            ordinals = {int(r.group(2)) for r in rows}
+            if len(names) != len(rows) or ordinals != set(range(1, len(rows)+1)):
+                raise ValueError('Compiler FB dependency ordinals are incomplete')
+            cache[type_id] = (block, rows, evidence)
+            artifacts.append(evidence)
+        block, rows, evidence = cache[type_id]
+        if saved_types[name].casefold() != block.casefold():
+            raise ValueError('Compiler FB dependency type differs from saved instance')
+        for row in rows:
+            pin_name, pin_ordinal, pin_section, _, _ = row.groups()
+            if pin_section in directions:
+                if not re.fullmatch(r'[A-Za-z_][A-Za-z_0-9]*', pin_name):
+                    raise ValueError('Compiler FB public pin name is unsupported')
+                pins[f'@IFBP {ordinal}.{int(pin_ordinal)}'] = dict(
+                    declaration=dict(name=pin_name, section=pin_section),
+                    pin_direction=directions[pin_section], block_type=block,
+                    compiler_type_id=type_id, dependency_sha256=evidence['sha256'])
+    return pins, artifacts
+
+
+def networks(text, bindings, pins=None):
+    result, current = [], None
+    if '*)' not in text:
+        raise ValueError('Truncated compiler header')
+    for line in text.split('*)', 1)[1].splitlines():
+        if line.strip() == '@NETWORK_BEGIN':
+            if current is not None:
+                raise ValueError('Nested compiler network')
+            current = []
+        elif line.strip() == '@NETWORK_END':
+            if current is None:
+                raise ValueError('Unmatched compiler network end')
+            result.append(dict(number=len(result)+1, lines=current))
+            current = None
+        elif line.strip():
+            if current is None:
+                raise ValueError('Instruction outside graphical network')
+            refs = []
+            for match in SYMBOL.finditer(line):
+                token = match.group()
+                if match.group(1) is not None:
+                    instance = bindings.get('@IFB ' + match.group(1))
+                    pin = (pins or {}).get(token) if instance else None
+                    refs.append(dict(dict(token=token, declaration=None, resolved=pin is not None,
+                                     instance=instance, pin_ordinal=int(match.group(2))), **(pin or {})))
+                else:
+                    refs.append(dict(token=token, declaration=bindings.get(token), resolved=token in bindings))
+            current.append(dict(raw=line, symbols=refs))
+    if current is not None:
+        raise ValueError('Truncated compiler network')
+    return result
+
+
+def inspect(project, name, start=1, limit=10, *, source_only=False):
+    if type(start) is not int or start < 1 or type(limit) is not int or not 1 <= limit <= 50:
+        raise ValueError('Invalid network range')
+    pou = project.pou(name)
+    if pou.name != name or pou.body_stream()[1] not in (('ST', 'LD', 'FBD') if source_only else ('LD', 'FBD')):
+        raise ValueError('Exact graphical POU required')
+    root = project.root
+    candidates = []
+    for path in sorted((root / 'C').glob('*/R/*/ICI*.CIC')):
+        text, evidence = read_text(path, root)
+        if identity(text)[1] == name:
+            candidates.append((path, text, evidence))
+    if len(candidates) != 1:
+        raise ValueError('Compiler listing for exact POU absent or ambiguous; unused POUs may be omitted. Inspect usage without automatic task assignment')
+    path, code, evidence = candidates[0]
+    declarations, dit_evidence = read_text(path.with_suffix('.DIT'), root)
+    if identity(declarations) != identity(code):
+        raise ValueError('Compiler declaration identity mismatch')
+    worksheet, diw_evidence = read_text(path.with_suffix('.DIW'), root)
+    # Match the saved body worksheet, not a guessed filename or a sibling cache.
+    expected = 'poe/' + name.casefold() + '/' + pou.body_stream()[0].casefold()
+    rows = [line.split('\t') for line in worksheet.splitlines() if re.match(r'^\d+\t\d+\t', line)]
+    if len([r for r in rows if len(r)==3 and r[2].replace('\\','/').casefold()==expected]) != 1:
+        raise ValueError('Compiler worksheet identity mismatch')
+    mapping, sp_evidence = read_text(path.with_suffix('.SP'), root)
+    paths = [line.split('\t')[0] for line in mapping.splitlines() if line.strip() and not line.startswith('*\t')]
+    expected_file = str(root / Path(expected))
+    # Compiler Windows paths are compared as paths even in portable unit tests.
+    if paths and any(PureWindowsPath(p) != PureWindowsPath(expected_file) for p in paths):
+        raise ValueError('Compiler source mapping points to another project/worksheet')
+    table = pou.declarations()
+    if table.warnings:
+        raise ValueError('Saved declaration worksheet is incomplete')
+    bindings = symbols(declarations, table.variables)
+    pins, dependency_artifacts = ({}, []) if source_only else pin_bindings(code, declarations, table.variables, path, root)
+    parsed = [] if source_only else networks(code, bindings, pins)
+    if source_only and not paths:
+        raise ValueError('Compiled source has no worksheet mapping')
+    if parsed and not paths:
+        raise ValueError('Populated listing has no source mapping')
+    selected = parsed[start-1:start-1+limit]
+    artifacts=[evidence,dit_evidence,diw_evidence,sp_evidence]
+    for artifact in artifacts + dependency_artifacts:
+        if read_text(Path(artifact['path']),root)[1]!=artifact:
+            raise ValueError('Compiler artifact set changed during inspection')
+    if source_only:
+        return dict(pou=name, language=pou.body_stream()[1], artifacts=artifacts,
+                    action_performed=False, compiler_cache_freshness_verified=False)
+    return dict(pou=name, language=pou.body_stream()[1], artifacts=artifacts,
+                network_count=len(parsed), start=start, networks=selected, has_more=start-1+len(selected)<len(parsed),
+                symbol_bindings=bindings, dependency_artifacts=dependency_artifacts,
+                compiler_cache_freshness_verified=False, compiler_dependency_freshness_verified=False,
+                action_performed=False, limitations=['Compiler tokens are retained verbatim; unresolved tokens have no inferred meaning.',
+                'Compiler instructions do not prove canvas geometry, pin placement or runtime behavior.'])