@litfamily/lithermes 1.0.8 → 1.0.9

package/assets/lithermes-plugin/skills/lit-diagram-drawer/scripts/drawio_extract.py

@@ -0,0 +1,209 @@
+#!/usr/bin/env python3
+"""Bounded stdlib-only draw.io extraction; labels are inert and never executed."""
+
+# /// script
+# requires-python = ">=3.10"
+# dependencies = []
+# ///
+# ─── How to run ───
+# python3 drawio_extract.py input.drawio [--page 0]
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import html
+import json
+import re
+from drawio_source import ImportFailure, MAX_DEPTH, parse_source, reject
+import sys
+from pathlib import Path
+from typing import Final, TypeAlias
+
+JsonValue: TypeAlias = str | int | float | bool | None | list["JsonValue"] | dict[str, "JsonValue"]
+JsonObject: TypeAlias = dict[str, JsonValue]
+MAX_NODES: Final = 2_000
+MAX_EDGES: Final = 5_000
+URL_RE: Final = re.compile(r"(?i)\b(?:https?|ftp|file|javascript|data):[^\s<>\"']+")
+TAG_RE: Final = re.compile(r"<[^>]*>")
+BREAK_RE: Final = re.compile(r"(?i)<br\s*/?>|</(?:p|div)\s*>")
+EXEC_RE: Final = re.compile(r"(?is)<\s*(?:script|iframe|object|embed)\b|\bon[a-z]+\s*=")
+SAFE_ID_RE: Final = re.compile(r"[A-Za-z][A-Za-z0-9_-]{0,63}\Z")
+SHAPE_ALIASES: Final = (("rhombus", "diamond"), ("diamond", "diamond"), ("ellipse", "ellipse"), ("actor", "ellipse"), ("cylinder", "cylinder"), ("database", "cylinder"), ("swimlane", "container"), ("text", "text"), ("group", "group"), ("table", "table"), ("hexagon", "hexagon"), ("cloud", "cloud"), ("parallelogram", "parallelogram"), ("document", "document"), ("image", "image"))
+
+
+
+
+
+
+def safe_id(source_id: str, used: set[str]) -> str:
+    """Map a source identifier to a stable, bounded identifier."""
+    if not source_id: reject("diagram contains an element without an id")
+    candidate = source_id if SAFE_ID_RE.fullmatch(source_id) else f"n-{hashlib.sha256(source_id.encode()).hexdigest()[:16]}"
+    if candidate in used: reject("diagram contains duplicate element ids")
+    used.add(candidate)
+    return candidate
+
+
+def plain_label(value: str) -> tuple[str, int]:
+    """Keep plain label text while removing executable markup and URL tokens."""
+    if EXEC_RE.search(value): reject("executable markup or event attributes in labels are unsupported")
+    url_count = len(URL_RE.findall(value))
+    text = URL_RE.sub("", value)
+    text = BREAK_RE.sub("\n", text)
+    text = TAG_RE.sub("", text)
+    text = html.unescape(text).replace("\xa0", " ")
+    lines = [re.sub(r"[ \t]+", " ", line).strip() for line in text.splitlines()]
+    return "\n".join(line for line in lines if line)[:2_000], url_count
+
+
+
+
+
+
+
+
+
+
+
+
+def shape_name(style: str) -> str:
+    """Reduce source shape syntax to the portable shape vocabulary."""
+    match = re.search(r"(?:^|;)shape=([^;]+)", style)
+    raw = match.group(1).casefold() if match else "rect"
+    return next((shape for token, shape in SHAPE_ALIASES if token in raw), "rectangle")
+
+
+
+
+def extract(path: Path, page_index: int) -> JsonObject:
+    """Return one page in the shared canonical import schema."""
+    data, source_root, pages = parse_source(path)
+    if page_index < 0 or page_index >= len(pages): reject(f"page index is out of range (file contains {len(pages)} page(s))")
+    model = pages[page_index]
+    root = next((child for child in model if child.tag.rsplit("}", 1)[-1] == "root"), None)
+    if root is None: reject("mxGraphModel has no root cell list")
+
+    records: list[dict[str, str]] = []
+    for wrapper in root:
+        tag = wrapper.tag.rsplit("}", 1)[-1]
+        cell = wrapper if tag == "mxCell" else next((item for item in wrapper if item.tag.rsplit("}", 1)[-1] == "mxCell"), None)
+        if cell is None:
+            continue
+        attrs = dict(wrapper.attrib)
+        attrs.update(cell.attrib)
+        if "value" not in attrs:
+            attrs["value"] = wrapper.get("label", "")
+        records.append(attrs)
+    if len(records) > MAX_NODES + MAX_EDGES: reject("diagram exceeds the 7,000 cell limit")
+
+    used: set[str] = set()
+    id_map: dict[str, str] = {}
+    for attrs in records:
+        raw_id = attrs.get("id", "")
+        if raw_id in id_map: reject("diagram contains duplicate element ids")
+        id_map[raw_id] = safe_id(raw_id, used)
+
+    vertices = [attrs for attrs in records if attrs.get("vertex") == "1"]
+    edge_records = [attrs for attrs in records if attrs.get("edge") == "1"]
+    if len(vertices) > MAX_NODES or len(edge_records) > MAX_EDGES: reject("diagram exceeds the node or relationship limit")
+
+    node_ids = {attrs["id"] for attrs in vertices}
+    child_ids: dict[str, list[str]] = {}
+    for attrs in vertices:
+        parent = attrs.get("parent", "")
+        if parent in node_ids:
+            child_ids.setdefault(parent, []).append(attrs["id"])
+
+    discarded: dict[str, JsonValue] = {
+        "styles": 0, "links": 0, "urls": 0,
+        "assets": 0, "unsupportedElements": 0, "danglingRelationships": 0,
+    }
+    nodes: list[JsonObject] = []
+    groups: list[JsonObject] = []
+    for attrs in vertices:
+        source_id = attrs["id"]
+        label, url_count = plain_label(attrs.get("value", ""))
+        discarded["urls"] = int(discarded["urls"]) + url_count
+        style = attrs.get("style", "")
+        discarded["styles"] = int(discarded["styles"]) + bool(style)
+        discarded["links"] = int(discarded["links"]) + bool(attrs.get("link") or attrs.get("href"))
+        discarded["assets"] = int(discarded["assets"]) + ("image=" in style.casefold() or shape_name(style) == "image")
+        children = child_ids.get(source_id, [])
+        source_shape = shape_name(style)
+        is_group = bool(children) or source_shape in {"container", "group"}
+        node: JsonObject = {
+            "id": id_map[source_id], "label": label,
+            "kind": "container" if is_group else "component",
+            "shape": "container" if is_group else source_shape,
+        }
+        parent = attrs.get("parent", "")
+        if parent in node_ids:
+            node["parentId"] = id_map[parent]
+        nodes.append(node)
+        if children:
+            groups.append({
+                "id": id_map[source_id], "label": label or "Group",
+                "nodeIds": [id_map[child] for child in children],
+            })
+
+    relationships: list[JsonObject] = []
+    for attrs in edge_records:
+        source = attrs.get("source", "")
+        target = attrs.get("target", "")
+        if source not in node_ids or target not in node_ids:
+            discarded["danglingRelationships"] = int(discarded["danglingRelationships"]) + 1
+            continue
+        label, url_count = plain_label(attrs.get("value", ""))
+        discarded["urls"] = int(discarded["urls"]) + url_count
+        style = attrs.get("style", "")
+        discarded["styles"] = int(discarded["styles"]) + bool(style)
+        discarded["links"] = int(discarded["links"]) + bool(attrs.get("link") or attrs.get("href"))
+        start_arrow = re.search(r"(?:^|;)startArrow=(?!none(?:;|$))", style) is not None
+        end_arrow = re.search(r"(?:^|;)endArrow=(?!none(?:;|$))", style) is not None
+        direction = "both" if start_arrow and end_arrow else "reverse" if start_arrow else "forward" if end_arrow else "none"
+        relationships.append({
+            "from": id_map[source], "to": id_map[target], "label": label,
+            "kind": "flow" if direction != "none" else "association", "direction": direction,
+        })
+
+    parents = {attrs["id"]: attrs.get("parent", "") for attrs in vertices}
+    for attrs in vertices:
+        parent, depth, seen = parents[attrs["id"]], 0, {attrs["id"]}
+        while parent in parents:
+            if parent in seen: reject("container hierarchy contains a cycle")
+            seen.add(parent)
+            depth += 1
+            if depth > MAX_DEPTH: reject("container hierarchy exceeds the depth limit")
+            parent = parents[parent]
+
+    page_name = next((child.get("name", "") for index, child in enumerate(item for item in source_root if item.tag.rsplit("}", 1)[-1] == "diagram") if index == page_index), "")
+    suggested_type = "flowchart" if edge_records or any(node["shape"] == "diamond" for node in nodes) else "architecture"
+    return {
+        "schemaVersion": 1, "sourceFormat": "drawio",
+        "sourceDigest": hashlib.sha256(data).hexdigest(),
+        "title": plain_label(page_name or path.stem)[0] or "Imported diagram",
+        "suggestedType": suggested_type,
+        "nodes": nodes, "relationships": relationships, "groups": groups,
+        "discarded": discarded,
+        "warnings": ["Source styles and coordinates are omitted; label text is inert data."],
+    }
+
+
+def main() -> int:
+    """Run the standalone JSON extractor."""
+    parser = argparse.ArgumentParser(description="Extract inert diagram meaning from bounded draw.io XML, SVG, or PNG.")
+    parser.add_argument("file", type=Path)
+    parser.add_argument("--page", type=int, default=0, help="zero-based page index (default: 0)")
+    args = parser.parse_args()
+    try:
+        result = extract(args.file, args.page)
+    except ImportFailure as error:
+        print(f"drawio_extract: {error}", file=sys.stderr)
+        return 2
+    print(json.dumps(result, ensure_ascii=False, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/assets/lithermes-plugin/skills/lit-diagram-drawer/scripts/drawio_source.py

@@ -0,0 +1,188 @@
+"""Bounded draw.io file/container decoding without executing embedded content."""
+
+from __future__ import annotations
+
+import base64
+import binascii
+import re
+import struct
+import zlib
+from pathlib import Path
+from typing import Final, NoReturn
+from urllib.parse import unquote
+from xml.etree import ElementTree as ET
+
+MAX_INPUT: Final = 16 * 1024 * 1024
+MAX_DECODED: Final = 32 * 1024 * 1024
+MAX_DEPTH: Final = 64
+PNG_MAGIC: Final = b"\x89PNG\r\n\x1a\n"
+
+class ImportFailure(Exception):
+    """A bounded, user-correctable import rejection."""
+
+def reject(message: str) -> NoReturn:
+    raise ImportFailure(message)
+
+def decode_page(payload: str) -> str:
+    """Decode one draw.io compressed page without allowing unbounded expansion."""
+    compact = re.sub(r"\s+", "", payload)
+    try:
+        packed = base64.b64decode(compact, validate=True)
+    except (binascii.Error, ValueError):
+        reject("compressed draw.io page is not valid base64")
+    try:
+        decoder = zlib.decompressobj(-15)
+        decoded = decoder.decompress(packed, MAX_DECODED + 1)
+        if len(decoded) > MAX_DECODED or decoder.unconsumed_tail: reject("decoded draw.io page exceeds the size limit")
+        remaining = MAX_DECODED + 1 - len(decoded)
+        if remaining < 1: reject("decoded draw.io page exceeds the size limit")
+        decoded += decoder.flush(remaining)
+        if len(decoded) > MAX_DECODED or not decoder.eof: reject("compressed draw.io page is malformed or oversized")
+        return unquote(decoded.decode("utf-8", "strict"))
+    except UnicodeDecodeError:
+        reject("compressed draw.io page is not UTF-8")
+    except zlib.error:
+        reject("compressed draw.io page is malformed or unsupported")
+
+def _bounded_inflate(data: bytes) -> bytes:
+    """Inflate one bounded PNG text payload and require a complete stream."""
+    try:
+        decoder = zlib.decompressobj()
+        decoded = decoder.decompress(data, MAX_DECODED + 1)
+        if len(decoded) > MAX_DECODED or decoder.unconsumed_tail:
+            reject("embedded draw.io payload exceeds the decoded size limit")
+        decoded += decoder.flush(MAX_DECODED + 1 - len(decoded))
+        if len(decoded) > MAX_DECODED or not decoder.eof:
+            reject("embedded draw.io payload is malformed or oversized")
+        return decoded
+    except zlib.error:
+        reject("embedded draw.io payload has invalid compression")
+
+def _png_embedded_xml(data: bytes) -> str:
+    """Extract only the mxfile text chunk from a bounded PNG container."""
+    position = len(PNG_MAGIC)
+    while position + 12 <= len(data):
+        size = struct.unpack(">I", data[position:position + 4])[0]
+        kind = data[position + 4:position + 8]
+        end = position + 8 + size
+        if end + 4 > len(data):
+            reject("PNG has a truncated metadata chunk")
+        payload = data[position + 8:end]
+        expected_crc = struct.unpack(">I", data[end:end + 4])[0]
+        if zlib.crc32(kind + payload) & 0xffffffff != expected_crc:
+            reject("PNG metadata chunk has an invalid CRC")
+        position = end + 4
+        if kind not in {b"tEXt", b"zTXt", b"iTXt"}:
+            if kind == b"IEND":
+                break
+            continue
+        keyword, separator, rest = payload.partition(b"\x00")
+        if not separator or keyword.lower() != b"mxfile":
+            continue
+        try:
+            if kind == b"tEXt":
+                value = rest.decode("latin-1")
+            elif kind == b"zTXt":
+                if not rest or rest[0] != 0:
+                    reject("PNG mxfile text uses an unsupported compression method")
+                value = _bounded_inflate(rest[1:]).decode("utf-8", "strict")
+            else:
+                if len(rest) < 4 or rest[1] != 0:
+                    reject("PNG mxfile international text is malformed")
+                compression_flag = rest[0]
+                fields = rest[2:].split(b"\x00", 2)
+                if len(fields) != 3:
+                    reject("PNG mxfile international text is malformed")
+                raw = _bounded_inflate(fields[2]) if compression_flag == 1 else fields[2]
+                value = raw.decode("utf-8", "strict")
+        except UnicodeDecodeError:
+            reject("PNG mxfile metadata is not valid text")
+        expanded = unquote(value)
+        if len(expanded.encode("utf-8")) > MAX_DECODED:
+            reject("embedded draw.io payload exceeds the decoded size limit")
+        return expanded
+    reject("PNG has no embedded mxfile diagram")
+
+def _svg_embedded_xml(text: str) -> str:
+    """Read a draw.io SVG metadata content attribute without loading SVG resources."""
+    try:
+        root = ET.fromstring(text)
+    except (ET.ParseError, RecursionError):
+        reject("draw.io SVG is malformed")
+    if _too_deep(root):
+        reject("SVG nesting exceeds the depth limit")
+    for element in root.iter():
+        for name, raw in element.attrib.items():
+            if name.rsplit("}", 1)[-1].casefold() != "content":
+                continue
+            candidate = raw
+            if "<mxfile" in candidate or "<mxGraphModel" in candidate:
+                if len(candidate.encode("utf-8")) > MAX_DECODED:
+                    reject("embedded draw.io payload exceeds the decoded size limit")
+                return candidate
+    reject("SVG has no embedded draw.io diagram")
+
+def parse_source(path: Path) -> tuple[bytes, ET.Element, list[ET.Element]]:
+    """Read and parse a supported draw.io source under explicit byte limits."""
+    try:
+        with path.open("rb") as source:
+            data = source.read(MAX_INPUT + 1)
+    except OSError as error:
+        reject(f"cannot read input: {error.strerror or 'I/O error'}")
+    if len(data) > MAX_INPUT: reject("input exceeds the 16 MiB limit")
+    if data.startswith(PNG_MAGIC):
+        text = _png_embedded_xml(data)
+    else:
+        try:
+            text = data.decode("utf-8-sig", "strict").strip()
+        except UnicodeDecodeError:
+            reject("input is not UTF-8 draw.io XML")
+        if re.search(r"(?i)<!DOCTYPE|<!ENTITY", text): reject("DTD and entity declarations are unsupported")
+        if text.lstrip().startswith("<svg"):
+            text = _svg_embedded_xml(text)
+        elif not text.startswith("<"):
+            reject("unsupported form; provide draw.io XML, compressed XML, or an SVG/PNG with embedded mxfile data")
+    if re.search(r"(?i)<!DOCTYPE|<!ENTITY", text): reject("DTD and entity declarations are unsupported")
+    try:
+        root = ET.fromstring(text)
+    except ET.ParseError as error:
+        reject(f"malformed draw.io XML at line {error.position[0]}")
+    except RecursionError:
+        reject("XML nesting exceeds the parser depth limit")
+    if _too_deep(root): reject("XML nesting exceeds the depth limit")
+    if root.tag.rsplit("}", 1)[-1] == "mxGraphModel": return data, root, [root]
+    if root.tag.rsplit("}", 1)[-1] != "mxfile":
+        reject("unsupported XML root; expected mxfile or mxGraphModel")
+    pages: list[ET.Element] = []
+    for diagram in root:
+        if diagram.tag.rsplit("}", 1)[-1] != "diagram":
+            continue
+        model = next((child for child in diagram if child.tag.rsplit("}", 1)[-1] == "mxGraphModel"), None)
+        if model is None:
+            payload = (diagram.text or "").strip()
+            if not payload:
+                reject("draw.io page has no readable mxGraphModel")
+            expanded = decode_page(payload)
+            if re.search(r"(?i)<!DOCTYPE|<!ENTITY", expanded):
+                reject("DTD and entity declarations are unsupported")
+            try:
+                model = ET.fromstring(expanded)
+            except ET.ParseError as error:
+                reject(f"malformed compressed draw.io XML at line {error.position[0]}")
+            except RecursionError:
+                reject("compressed XML nesting exceeds the parser depth limit")
+            if _too_deep(model): reject("XML nesting exceeds the depth limit")
+            if model.tag.rsplit("}", 1)[-1] != "mxGraphModel":
+                reject("compressed page does not contain mxGraphModel")
+        pages.append(model)
+    if not pages: reject("draw.io file contains no pages")
+    return data, root, pages
+
+def _too_deep(root: ET.Element) -> bool:
+    """Check XML nesting iteratively without recursive traversal."""
+    pending = [(root, 1)]
+    while pending:
+        element, depth = pending.pop()
+        if depth > MAX_DEPTH: return True
+        pending.extend((child, depth + 1) for child in element)
+    return False

package/assets/lithermes-plugin/skills/lit-diagram-drawer/scripts/excalidraw_extract.py

@@ -0,0 +1,233 @@
+#!/usr/bin/env python3
+"""Bounded stdlib-only Excalidraw extraction; labels are inert, never executed."""
+
+# /// script
+# requires-python = ">=3.10"
+# dependencies = []
+# ///
+# ─── How to run ───
+# python3 excalidraw_extract.py board.excalidraw
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import sys
+from excalidraw_support import (
+    ImportFailure, JsonObject, JsonValue, MAX_DEPTH, URL_RE, check_json_depth,
+    clean_label, finite_geometry, reject, safe_id,
+)
+from pathlib import Path
+from typing import Final
+
+MAX_INPUT: Final = 16 * 1024 * 1024
+MAX_ELEMENTS: Final = 10_000
+MAX_NODES: Final = 2_000
+MAX_RELATIONSHIPS: Final = 5_000
+NODE_SHAPES: Final = {"rectangle": "rectangle", "ellipse": "ellipse", "diamond": "diamond", "image": "image", "embeddable": "embed", "iframe": "embed"}
+EDGE_TYPES: Final = {"arrow", "line"}
+CONTAINER_TYPES: Final = {"frame", "magicframe"}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+def extract(path: Path) -> JsonObject:
+    """Parse one saved scene into the shared canonical import schema."""
+    suffix = path.name.casefold()
+    if not (suffix.endswith(".excalidraw") or suffix.endswith(".excalidraw.json")): reject("unsupported form; provide a saved .excalidraw scene")
+    try:
+        with path.open("rb") as source:
+            data = source.read(MAX_INPUT + 1)
+    except OSError as error:
+        reject(f"cannot read input: {error.strerror or 'I/O error'}")
+    if len(data) > MAX_INPUT: reject("input exceeds the 16 MiB limit")
+    try:
+        text = data.decode("utf-8", "strict")
+    except UnicodeDecodeError:
+        reject("scene is not valid UTF-8 JSON")
+    check_json_depth(text)
+    try:
+        document = json.loads(text, parse_constant=lambda token: reject(f"non-finite JSON number {token} is unsupported"))
+    except (json.JSONDecodeError, RecursionError):
+        reject("scene is malformed JSON")
+    if not isinstance(document, dict) or document.get("type") != "excalidraw": reject("input is not an Excalidraw scene")
+    elements = document.get("elements")
+    if not isinstance(elements, list): reject("scene has no elements array")
+    if len(elements) > MAX_ELEMENTS: reject("element limit exceeded (max 10,000)")
+
+    live: list[dict[str, JsonValue]] = []
+    used: set[str] = set()
+    id_map: dict[str, str] = {}
+    discarded: dict[str, JsonValue] = {
+        "styles": 0, "links": 0, "urls": 0, "scripts": 0,
+        "assets": 0, "unsupportedElements": 0, "deletedElements": 0,
+        "freehandStrokes": 0, "danglingRelationships": 0,
+    }
+    for item in elements:
+        if not isinstance(item, dict): reject("scene element must be an object")
+        source_id, element_type = item.get("id"), item.get("type")
+        if not isinstance(source_id, str) or not isinstance(element_type, str): reject("scene elements require string id and type fields")
+        if source_id in id_map: reject("scene contains duplicate element ids")
+        id_map[source_id] = safe_id(source_id, used)
+        finite_geometry(item)
+        if item.get("isDeleted") is True:
+            discarded["deletedElements"] = int(discarded["deletedElements"]) + 1
+            continue
+        live.append(item)
+    frame_ids = {element["id"] for element in live if element.get("type") in CONTAINER_TYPES and isinstance(element.get("id"), str)}
+
+    labels: dict[str, list[str]] = {}
+    for element in live:
+        if element.get("type") != "text":
+            continue
+        container = element.get("containerId")
+        raw_text = element.get("text", "")
+        if not isinstance(raw_text, str):
+            reject("text element content must be a string")
+        label, count = clean_label(raw_text)
+        discarded["urls"] = int(discarded["urls"]) + count
+        if isinstance(container, str) and container in id_map and label:
+            labels.setdefault(container, []).append(label)
+
+    nodes: list[JsonObject] = []
+    node_source_ids: set[str] = set()
+    for element in live:
+        source_id = element["id"]
+        element_type = element["type"]
+        if not isinstance(source_id, str) or not isinstance(element_type, str):
+            reject("scene element id and type must be strings")
+        if element_type in EDGE_TYPES or element_type == "text" and isinstance(element.get("containerId"), str):
+            continue
+        if element_type in {"selection", "laser"}:
+            continue
+        if element_type == "freedraw":
+            discarded["freehandStrokes"] = int(discarded["freehandStrokes"]) + 1
+            continue
+        if element_type in CONTAINER_TYPES:
+            shape, kind = "container", "container"
+            label = element.get("name", "")
+            if not isinstance(label, str):
+                label = ""
+        elif element_type == "text":
+            shape, kind = "text", "annotation"
+            label = element.get("text", "")
+            if not isinstance(label, str):
+                label = ""
+        elif element_type in NODE_SHAPES:
+            shape, kind = NODE_SHAPES[element_type], "component"
+            label = ""
+            if element_type in {"image", "embeddable", "iframe"}:
+                discarded["assets"] = int(discarded["assets"]) + 1
+        else:
+            discarded["unsupportedElements"] = int(discarded["unsupportedElements"]) + 1
+            continue
+        label, count = clean_label(label)
+        discarded["urls"] = int(discarded["urls"]) + count
+        bound = labels.get(source_id, [])
+        if bound:
+            label = "\n".join(bound)[:2_000]
+        link = element.get("link")
+        if isinstance(link, str) and link:
+            discarded["links"] = int(discarded["links"]) + 1
+            discarded["urls"] = int(discarded["urls"]) + bool(URL_RE.search(link))
+        if len(nodes) >= MAX_NODES:
+            reject("node limit exceeded (max 2,000)")
+        node: JsonObject = {"id": id_map[source_id], "label": label, "kind": kind, "shape": shape}
+        parent = element.get("frameId")
+        if isinstance(parent, str) and parent in frame_ids:
+            node["parentId"] = id_map[parent]
+        nodes.append(node)
+        node_source_ids.add(source_id)
+
+    relationships: list[JsonObject] = []
+    for element in live:
+        if element.get("type") not in EDGE_TYPES:
+            continue
+        source_id = element.get("id")
+        if not isinstance(source_id, str):
+            continue
+        start = element.get("startBinding")
+        end = element.get("endBinding")
+        start_id = start.get("elementId") if isinstance(start, dict) else None
+        end_id = end.get("elementId") if isinstance(end, dict) else None
+        if not isinstance(start_id, str) or not isinstance(end_id, str) or start_id not in node_source_ids or end_id not in node_source_ids:
+            discarded["danglingRelationships"] = int(discarded["danglingRelationships"]) + 1
+            continue
+        raw_label = "\n".join(labels.get(source_id, []))
+        label, count = clean_label(raw_label)
+        discarded["urls"] = int(discarded["urls"]) + count
+        start_head = element.get("startArrowhead")
+        end_head = element.get("endArrowhead")
+        has_start = isinstance(start_head, str) and start_head not in {"", "none"}
+        has_end = isinstance(end_head, str) and end_head not in {"", "none"}
+        direction = "both" if has_start and has_end else "reverse" if has_start else "forward" if has_end or element.get("type") == "arrow" else "none"
+        relationships.append({"from": id_map[start_id], "to": id_map[end_id], "label": label, "kind": "flow" if element.get("type") == "arrow" else "association", "direction": direction})
+    if len(relationships) > MAX_RELATIONSHIPS:
+        reject("relationship limit exceeded (max 5,000)")
+
+    groups: list[JsonObject] = []
+    for frame_id in sorted(frame_ids):
+        members = [element.get("id") for element in live if element.get("frameId") == frame_id and isinstance(element.get("id"), str) and element.get("id") in node_source_ids]
+        if members:
+            label = next((str(node["label"]) for node in nodes if node["id"] == id_map[frame_id]), "Frame")
+            groups.append({"id": id_map[frame_id], "label": label, "nodeIds": [id_map[item] for item in members]})
+    source_groups: dict[str, list[str]] = {}
+    for element in live:
+        element_id = element.get("id")
+        group_ids = element.get("groupIds")
+        if isinstance(element_id, str) and element_id in node_source_ids and isinstance(group_ids, list):
+            for group_id in group_ids[:64]:
+                if isinstance(group_id, str):
+                    if group_id not in source_groups and len(source_groups) >= MAX_NODES: reject("group limit exceeded (max 2,000)")
+                    source_groups.setdefault(group_id, []).append(element_id)
+    for group_id, members in source_groups.items():
+        group_safe_id = f"g-{hashlib.sha256(group_id.encode()).hexdigest()[:16]}"
+        if group_safe_id in used: reject("group id collides with an element id")
+        used.add(group_safe_id)
+        groups.append({"id": group_safe_id, "label": "Group", "nodeIds": [id_map[item] for item in members]})
+
+    if not nodes:
+        reject("scene contains no supported diagram elements")
+    discarded["styles"] = sum(1 for element in live if any(key in element for key in ("backgroundColor", "strokeColor", "strokeStyle", "roughness")))
+    files = document.get("files")
+    if isinstance(files, dict):
+        discarded["assets"] = int(discarded["assets"]) + len(files)
+    suggested = "flowchart" if relationships else "architecture"
+    return {
+        "schemaVersion": 1, "sourceFormat": "excalidraw",
+        "sourceDigest": hashlib.sha256(data).hexdigest(),
+        "title": path.name.removesuffix(".excalidraw.json").removesuffix(".excalidraw") or "Imported diagram",
+        "suggestedType": suggested,
+        "nodes": nodes, "relationships": relationships, "groups": groups,
+        "discarded": discarded,
+        "warnings": ["Source coordinates and styling are omitted; label text is inert data."],
+    }
+
+
+def main() -> int:
+    """Run the standalone JSON extractor."""
+    parser = argparse.ArgumentParser(description="Extract inert diagram meaning from Excalidraw JSON.")
+    parser.add_argument("file", type=Path)
+    args = parser.parse_args()
+    try:
+        result = extract(args.file)
+    except ImportFailure as error:
+        print(f"excalidraw_extract: {error}", file=sys.stderr)
+        return 2
+    print(json.dumps(result, ensure_ascii=False, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())