ui-design-workbench-cli 0.5.0__py3-none-any.whl

fidelity_platform_adapters.py

@@ -0,0 +1,902 @@
+#!/usr/bin/env python3
+"""Built-in platform adapters beyond static Web and Jetpack Compose."""
+
+from __future__ import annotations
+
+import re
+import xml.etree.ElementTree as ET
+from pathlib import Path
+from typing import Any
+
+from android_resource_resolver import AndroidResourceCatalog
+from android_xml_support import android_layout_metadata
+from apple_resource_resolver import AppleResourceCatalog, sf_symbol_asset
+from fidelity_adapter_api import AdapterResult, SourceContext
+from fidelity_core import property_evidence
+
+
+def _slug(value: str, fallback: str = "node") -> str:
+    separated = re.sub(r"(?<=[a-z0-9])(?=[A-Z])", "-", value)
+    return re.sub(r"[^a-z0-9]+", "-", separated.lower()).strip("-") or fallback
+
+
+def _local(value: str) -> str:
+    return value.rsplit("}", 1)[-1].rsplit(":", 1)[-1]
+
+
+def _attrs(element: ET.Element) -> dict[str, str]:
+    return {_local(key): str(value) for key, value in element.attrib.items()}
+
+
+def _line(text: str, expression: str, start: int = 0) -> int:
+    offset = text.find(expression, start)
+    return text.count("\n", 0, max(0, offset)) + 1 if offset >= 0 else 1
+
+
+def _balanced_close(text: str, start: int, opening: str, closing: str) -> int | None:
+    depth, quote, escaped = 0, None, False
+    for index in range(start, len(text)):
+        char = text[index]
+        if quote:
+            if escaped:
+                escaped = False
+            elif char == "\\":
+                escaped = True
+            elif char == quote:
+                quote = None
+            continue
+        if char in {'"', "'"}:
+            quote = char
+        elif char == opening:
+            depth += 1
+        elif char == closing:
+            depth -= 1
+            if depth == 0:
+                return index
+    return None
+
+
+def _normalize_ref(value: str, preferred_group: str = "spacing") -> Any:
+    value = value.strip()
+    if value in {"match_parent", "-1"}: return "fill"
+    if value in {"wrap_content", "Auto"}: return "hug"
+    numeric = re.fullmatch(r"-?\d+(?:\.\d+)?", value)
+    if numeric: return float(value) if "." in value else int(value)
+    dimension = re.fullmatch(r"(-?\d+(?:\.\d+)?)(?:dp|sp|pt)", value)
+    if dimension: return f"{dimension.group(1)}px"
+    match = re.fullmatch(r"@(color|dimen|string)/([\w.-]+)", value)
+    if match:
+        resource_type, resource_name = match.groups()
+        group = "colors" if resource_type == "color" else "strings" if resource_type == "string" else preferred_group
+        return f"${group}.{_slug(resource_name).replace('-', '_')}"
+    match = re.fullmatch(r"\{(?:StaticResource|ThemeResource)\s+([\w.-]+)\}", value)
+    if match:
+        return f"${preferred_group}.{_slug(match.group(1)).replace('-', '_')}"
+    return value
+
+
+def _set(node: dict[str, Any], path: str, value: Any, context: SourceContext, line: int, expression: str, adapter: str, confidence: str = "exact") -> None:
+    group, key = path.split(".", 1)
+    node.setdefault(group, {})[key] = value
+    node.setdefault("provenance", {})[path] = property_evidence(context.source, line, expression, adapter, confidence)
+
+
+def _root_node(context: SourceContext, adapter: str, standard: str, line: int = 1) -> dict[str, Any]:
+    return {
+        "type": "container", "layout": {"direction": "column", "width": "fill", "height": "fill"}, "style": {}, "children": [],
+        "source": {"file": context.source, "line": line}, "confidence": "high", "standardRef": standard,
+        "provenance": {
+            "layout.direction": property_evidence(context.source, line, "screen root", adapter, "high"),
+            "layout.width": property_evidence(context.source, line, "screen bounds", adapter, "high"),
+            "layout.height": property_evidence(context.source, line, "screen bounds", adapter, "high"),
+        },
+    }
+
+
+class AndroidXmlAdapter:
+    id = "android-xml"
+    platforms = ("android",)
+    extensions = (".xml",)
+    maturity = "structural"
+    structural_tier = "translated"
+    visual_tier = "none"
+    native_evidence_required = True
+    native_providers = ("paparazzi", "roborazzi", "android-emulator")
+    resource_resolution = ("values strings/colors/dimens", "styles", "bitmap/vector/shape drawables", "static layout includes")
+    layout_features = ("LinearLayout gravity/weight", "Frame/Constraint overlay", "parent-edge centering", "directional padding/margins", "image scaleType")
+    limitations = ("custom views are not expanded", "complex ConstraintLayout equations and runtime resources remain explicit gaps")
+    TYPES = {
+        "LinearLayout": "container", "ConstraintLayout": "container", "FrameLayout": "container", "RelativeLayout": "container",
+        "CoordinatorLayout": "container", "AppBarLayout": "container", "Toolbar": "container", "MaterialToolbar": "container",
+        "ScrollView": "container", "NestedScrollView": "container", "HorizontalScrollView": "container", "ViewPager": "container",
+        "ViewPager2": "container", "SwipeRefreshLayout": "container", "DrawerLayout": "container", "NavigationView": "container",
+        "RecyclerView": "list", "ListView": "list", "GridView": "list", "TabLayout": "container",
+        "TextView": "text", "AppCompatTextView": "text", "MaterialTextView": "text", "Button": "button",
+        "AppCompatButton": "button", "MaterialButton": "button", "FloatingActionButton": "button", "ExtendedFloatingActionButton": "button",
+        "EditText": "input", "AppCompatEditText": "input", "TextInputEditText": "input", "TextInputLayout": "container",
+        "CheckBox": "button", "RadioButton": "button", "Switch": "button", "SwitchMaterial": "button", "Chip": "button",
+        "MaterialCheckBox": "button", "MaterialSwitch": "button", "CheckedTextView": "button", "RadioGroup": "container",
+        "MaterialButtonToggleGroup": "container", "GridLayout": "container", "ShimmerFrameLayout": "container", "SearchView": "input",
+        "ImageView": "image", "AppCompatImageView": "image", "ShapeableImageView": "image", "ImageButton": "button",
+        "AppCompatImageButton": "button", "CardView": "card", "MaterialCardView": "card", "View": "divider", "Space": "spacer",
+        "ProgressBar": "custom", "Guideline": "spacer", "Barrier": "spacer", "Group": "container",
+    }
+
+    def __init__(self) -> None:
+        self._catalogs: dict[str, AndroidResourceCatalog] = {}
+
+    def prepare(self, contexts: list[SourceContext]) -> None:
+        roots = {str(context.root.resolve()): context.root for context in contexts if self.supports(context)}
+        self._catalogs = {key: AndroidResourceCatalog.discover(root) for key, root in roots.items()}
+
+    def _catalog(self, context: SourceContext) -> AndroidResourceCatalog:
+        key = str(context.root.resolve())
+        if key not in self._catalogs:
+            self._catalogs[key] = AndroidResourceCatalog.discover(context.root)
+        return self._catalogs[key]
+
+    def supports(self, context: SourceContext) -> bool:
+        return context.path.suffix.lower() == ".xml" and any(value.startswith("android-") for value in context.platforms)
+
+    def translate(self, context: SourceContext) -> AdapterResult:
+        result = AdapterResult(adapter=self.id)
+        catalog = self._catalog(context)
+        try:
+            root = ET.fromstring(context.text)
+        except ET.ParseError as exc:
+            result.unsupported.append({"adapter": self.id, "file": context.source, "line": getattr(exc, "position", (1,))[0], "expression": str(exc), "reason": "invalid-xml"})
+            return result
+        normalized_source = "/" + context.source.lower().replace("\\", "/")
+        if "/res/color" in normalized_source:
+            items = [child for child in root if _local(child.tag) == "item"] if _local(root.tag) == "selector" else []
+            default_item = next((child for child in reversed(items) if not any(key.startswith("state_") for key in _attrs(child))), None)
+            selected = default_item if default_item is not None else items[-1] if items else root
+            value = _attrs(selected).get("color") or (selected.text or "").strip()
+            if value:
+                result.tokens["colors"][_slug(context.path.stem).replace("-", "_")] = {
+                    "value": _normalize_ref(value, "colors"),
+                    "source": {"file": context.source, "line": _line(context.text, value)},
+                    "adapter": self.id,
+                }
+            if len(items) > 1:
+                result.unsupported.append({"adapter": self.id, "file": context.source, "line": 1, "expression": context.path.name, "reason": "stateful-color-selector-uses-default-state"})
+            return result
+        if _local(root.tag) == "resources":
+            for child in root:
+                tag, attrs, value = _local(child.tag), _attrs(child), (child.text or "").strip()
+                name = attrs.get("name") or attrs.get("Key")
+                if not name:
+                    continue
+                line = _line(context.text, name)
+                if tag == "style":
+                    result.unsupported.append({"adapter": self.id, "file": context.source, "line": line, "expression": name, "reason": "unresolved-android-style"})
+                    continue
+                if not value:
+                    continue
+                if tag in {"color", "Color", "SolidColorBrush"}:
+                    groups = ("colors",)
+                elif tag == "dimen":
+                    groups = ("spacing", "typography") if value.endswith("sp") else ("spacing",)
+                elif tag in {"string", "plurals", "string-array"}:
+                    groups = ("strings",)
+                elif tag in {"bool", "integer", "fraction"}:
+                    groups = ("values",)
+                else:
+                    continue
+                for group in groups:
+                    result.tokens.setdefault(group, {})[_slug(name).replace("-", "_")] = {
+                        "value": _normalize_ref(value, group),
+                        "source": {"file": context.source, "line": line},
+                        "adapter": self.id,
+                    }
+            if "/values-night" in "/" + context.source.lower().replace("\\", "/"):
+                result.themes.append({"id": "dark", "label": "Dark", "kind": "dark", "sourceRefs": [{"file": context.source, "line": 1, "reason": "values-night"}], "tokenOverrides": result.tokens, "nodeOverrides": {}})
+                result.tokens = {group: {} for group in result.tokens}
+            return result
+        if context.role == "navigation":
+            return result
+        content_root = root
+        if _local(root.tag) == "layout":
+            content_root = next((child for child in root if isinstance(child.tag, str) and _local(child.tag) != "data"), None)
+            if content_root is None:
+                result.unsupported.append({"adapter": self.id, "file": context.source, "line": 1, "expression": "<layout>", "reason": "data-binding-layout-without-view-root"})
+                return result
+        platform = "android"
+        screen_id = _slug(context.path.stem, "android-layout")
+        root_id = f"{screen_id}-root"
+        result.nodes[root_id] = _root_node(context, self.id, "project.android.layout")
+        count = 0
+
+        def convert(element: ET.Element, active_context: SourceContext, active_text: str, include_stack: tuple[str, ...] = ()) -> str:
+            nonlocal count
+            count += 1
+            raw_tag, explicit_attrs = _local(element.tag), _attrs(element)
+            if raw_tag == "include":
+                reference = explicit_attrs.get("layout", "")
+                line = _line(active_text, reference or "<include")
+                node_id = f"{screen_id}-include-{count}"
+                node = {
+                    "type": "container", "component": "include", "layout": {"width": "fill"}, "style": {}, "children": [],
+                    "source": {"file": active_context.source, "line": line}, "confidence": "high", "standardRef": "project.android.include",
+                    "provenance": {
+                        "component": property_evidence(active_context.source, line, reference or "include", self.id, "exact"),
+                        "layout.width": property_evidence(active_context.source, line, reference or "include", self.id, "high"),
+                    },
+                }
+                target = catalog.layout(reference)
+                if not target or reference in include_stack:
+                    result.unsupported.append({"adapter": self.id, "file": active_context.source, "line": line, "expression": reference, "reason": "unresolved-or-cyclic-layout-include"})
+                else:
+                    try:
+                        target_text = target.read_text(encoding="utf-8", errors="replace")
+                        target_root = ET.fromstring(target_text)
+                        target_context = SourceContext(active_context.root, target, target.relative_to(active_context.root).as_posix(), target_text, active_context.platforms, "component")
+                        candidates = list(target_root) if _local(target_root.tag) == "merge" else [target_root]
+                        node["children"] = [convert(child, target_context, target_text, (*include_stack, reference)) for child in candidates]
+                    except (OSError, ET.ParseError, ValueError) as exc:
+                        result.unsupported.append({"adapter": self.id, "file": active_context.source, "line": line, "expression": reference, "reason": f"invalid-layout-include:{type(exc).__name__}"})
+                result.nodes[node_id] = node
+                return node_id
+            style_values, style_entry = catalog.style(explicit_attrs.get("style"))
+            normalized_style = {key.rsplit(":", 1)[-1]: value for key, value in style_values.items()}
+            attrs = {**normalized_style, **explicit_attrs}
+            short = raw_tag.rsplit(".", 1)[-1]
+            node_id = f"{screen_id}-{_slug(attrs.get('id', '').split('/')[-1] or short)}-{count}"
+            node_type = self.TYPES.get(short, "custom")
+            line = _line(active_text, f"<{raw_tag}")
+            standard_prefix = "material3" if short.startswith("Material") or "TextInput" in short else "project"
+            node: dict[str, Any] = {
+                "type": node_type, "component": raw_tag, "layout": {}, "style": {}, "children": [], "source": {"file": active_context.source, "line": line},
+                "confidence": "high" if node_type != "custom" else "unsupported", "standardRef": f"{standard_prefix}.android-xml.{short.lower()}", "provenance": {},
+            }
+            if node_type != "custom":
+                node["inheritsAppearance"] = True
+                node["provenance"]["component"] = property_evidence(active_context.source, line, raw_tag, self.id, "exact")
+            else:
+                result.unsupported.append({"adapter": self.id, "file": active_context.source, "line": line, "expression": raw_tag, "reason": "unsupported-android-view"})
+            if short in {"FrameLayout", "ConstraintLayout", "CoordinatorLayout"}:
+                _set(node, "layout.direction", "overlay", active_context, line, short, self.id)
+            mapping = {
+                "layout_width": ("layout.width", "spacing"), "layout_height": ("layout.height", "spacing"), "padding": ("layout.padding", "spacing"),
+                "paddingHorizontal": ("layout.paddingHorizontal", "spacing"), "paddingVertical": ("layout.paddingVertical", "spacing"),
+                "paddingStart": ("layout.paddingLeft", "spacing"), "paddingEnd": ("layout.paddingRight", "spacing"), "paddingTop": ("layout.paddingTop", "spacing"), "paddingBottom": ("layout.paddingBottom", "spacing"),
+                "layout_margin": ("layout.margin", "spacing"), "layout_marginHorizontal": ("layout.marginHorizontal", "spacing"), "layout_marginVertical": ("layout.marginVertical", "spacing"),
+                "layout_marginStart": ("layout.marginLeft", "spacing"), "layout_marginEnd": ("layout.marginRight", "spacing"), "layout_marginTop": ("layout.marginTop", "spacing"), "layout_marginBottom": ("layout.marginBottom", "spacing"),
+                "minWidth": ("layout.minWidth", "spacing"), "minHeight": ("layout.minHeight", "spacing"), "maxWidth": ("layout.maxWidth", "spacing"), "maxHeight": ("layout.maxHeight", "spacing"),
+                "textColor": ("style.color", "color"), "textSize": ("style.fontSize", "dimen"), "alpha": ("style.opacity", "spacing"), "fontFamily": ("style.fontFamily", "font"),
+                "tint": ("style.color", "color"),
+            }
+            for attr, (path, group) in mapping.items():
+                if attr in attrs:
+                    resolved = catalog.resolve(attrs[attr], group, normalized_style)
+                    value = resolved.value if resolved.resolved else _normalize_ref(attrs[attr], "colors" if group == "color" else group)
+                    source = resolved.source or (style_entry.source if attr not in explicit_attrs and style_entry else active_context.source)
+                    source_line = resolved.line if resolved.source else style_entry.line if attr not in explicit_attrs and style_entry else line
+                    group_name, key = path.split(".", 1)
+                    node.setdefault(group_name, {})[key] = value
+                    node["provenance"][path] = property_evidence(source, source_line, f'{attr}="{attrs[attr]}"', self.id, resolved.confidence if resolved.source else "exact")
+            if attrs.get("orientation") in {"vertical", "horizontal"}:
+                _set(node, "layout.direction", "column" if attrs["orientation"] == "vertical" else "row", active_context, line, f'orientation="{attrs["orientation"]}"', self.id)
+            direction = node.get("layout", {}).get("direction", "column")
+            gravity = attrs.get("gravity", "")
+            if gravity:
+                if "center" == gravity or "center_horizontal" in gravity:
+                    _set(node, "layout.align" if direction == "column" else "layout.justify", "center", active_context, line, f'gravity="{gravity}"', self.id)
+                if "center" == gravity or "center_vertical" in gravity:
+                    _set(node, "layout.justify" if direction == "column" else "layout.align", "center", active_context, line, f'gravity="{gravity}"', self.id)
+                if "end" in gravity or "right" in gravity:
+                    _set(node, "layout.align" if direction == "column" else "layout.justify", "end", active_context, line, f'gravity="{gravity}"', self.id)
+            layout_gravity = attrs.get("layout_gravity", "")
+            if "center" in layout_gravity:
+                _set(node, "layout.alignSelf", "center", active_context, line, f'layout_gravity="{layout_gravity}"', self.id)
+                _set(node, "layout.justifySelf", "center", active_context, line, f'layout_gravity="{layout_gravity}"', self.id)
+            if attrs.get("layout_weight"):
+                _set(node, "layout.grow", _normalize_ref(attrs["layout_weight"]), active_context, line, f'layout_weight="{attrs["layout_weight"]}"', self.id)
+            text_style = attrs.get("textStyle", "")
+            if "bold" in text_style:
+                _set(node, "style.fontWeight", 700, active_context, line, f'textStyle="{text_style}"', self.id)
+            if "italic" in text_style:
+                _set(node, "style.fontStyle", "italic", active_context, line, f'textStyle="{text_style}"', self.id)
+            text_alignment = {"center": "center", "viewStart": "start", "textStart": "start", "viewEnd": "end", "textEnd": "end"}.get(attrs.get("textAlignment", ""))
+            if text_alignment:
+                _set(node, "style.textAlign", text_alignment, active_context, line, f'textAlignment="{attrs["textAlignment"]}"', self.id)
+            constraints = {key: value for key, value in attrs.items() if key.startswith("layout_constraint")}
+            if constraints:
+                result.unsupported.append({"adapter": self.id, "file": active_context.source, "line": line, "expression": ", ".join(sorted(constraints)), "reason": "unresolved-constraint-equations"})
+            horizontal_center = constraints.get("layout_constraintStart_toStartOf") == "parent" and constraints.get("layout_constraintEnd_toEndOf") == "parent"
+            vertical_center = constraints.get("layout_constraintTop_toTopOf") == "parent" and constraints.get("layout_constraintBottom_toBottomOf") == "parent"
+            if horizontal_center:
+                _set(node, "layout.justifySelf", "stretch" if attrs.get("layout_width") == "0dp" else "center", active_context, line, "horizontal parent constraints", self.id, "high")
+                if attrs.get("layout_width") == "0dp": node["layout"]["width"] = "fill"
+            if vertical_center:
+                _set(node, "layout.alignSelf", "stretch" if attrs.get("layout_height") == "0dp" else "center", active_context, line, "vertical parent constraints", self.id, "high")
+                if attrs.get("layout_height") == "0dp": node["layout"]["height"] = "fill"
+            unsupported_constraints = [key for key in constraints if key not in {"layout_constraintStart_toStartOf", "layout_constraintEnd_toEndOf", "layout_constraintTop_toTopOf", "layout_constraintBottom_toBottomOf"}]
+            if unsupported_constraints:
+                result.unsupported.append({"adapter": self.id, "file": active_context.source, "line": line, "expression": ", ".join(sorted(unsupported_constraints)), "reason": "unsupported-constraint-equation"})
+            if attrs.get("text"):
+                resolved = catalog.resolve(attrs["text"], "string", normalized_style)
+                node["text"] = resolved.value if resolved.resolved else _normalize_ref(attrs["text"], "strings")
+                node["provenance"]["text"] = property_evidence(resolved.source or active_context.source, resolved.line if resolved.source else line, f'text="{attrs["text"]}"', self.id, resolved.confidence if resolved.source else "exact")
+            if attrs.get("hint"):
+                resolved = catalog.resolve(attrs["hint"], "string", normalized_style)
+                node["placeholder"] = resolved.value if resolved.resolved else attrs["hint"]
+                node["provenance"]["placeholder"] = property_evidence(resolved.source or active_context.source, resolved.line if resolved.source else line, f'hint="{attrs["hint"]}"', self.id, resolved.confidence if resolved.source else "exact")
+            if attrs.get("contentDescription"):
+                resolved = catalog.resolve(attrs["contentDescription"], "string", normalized_style)
+                node["alt"] = resolved.value if resolved.resolved else attrs["contentDescription"]
+                node["semantics"] = {"role": "button" if node_type == "button" else "image", "label": node["alt"]}
+                node["provenance"]["alt"] = property_evidence(resolved.source or active_context.source, resolved.line if resolved.source else line, f'contentDescription="{attrs["contentDescription"]}"', self.id, resolved.confidence if resolved.source else "exact")
+            if attrs.get("background", "").startswith("@drawable/"):
+                drawable = catalog.drawable(attrs["background"], normalized_style)
+                node["style"].update(drawable.style)
+                for key in drawable.style:
+                    node["provenance"][f"style.{key}"] = property_evidence(drawable.source, drawable.line, attrs["background"], self.id, drawable.confidence)
+                if not drawable.style:
+                    result.unsupported.append({"adapter": self.id, "file": active_context.source, "line": line, "expression": attrs["background"], "reason": "unsupported-background-drawable"})
+            elif attrs.get("background"):
+                resolved = catalog.resolve(attrs["background"], "color", normalized_style)
+                node["style"]["backgroundColor"] = resolved.value if resolved.resolved else attrs["background"]
+                node["provenance"]["style.backgroundColor"] = property_evidence(resolved.source or active_context.source, resolved.line if resolved.source else line, attrs["background"], self.id, resolved.confidence if resolved.source else "exact")
+            if attrs.get("src") or attrs.get("srcCompat"):
+                asset = attrs.get("srcCompat") or attrs.get("src")
+                drawable = catalog.drawable(str(asset), normalized_style)
+                node["asset"] = drawable.asset or asset
+                node["style"].update(drawable.style)
+                node["provenance"]["asset"] = property_evidence(drawable.source or active_context.source, drawable.line if drawable.source else line, str(asset), self.id, drawable.confidence)
+                if not drawable.asset:
+                    result.unsupported.append({"adapter": self.id, "file": active_context.source, "line": line, "expression": asset, "reason": "unsupported-android-drawable"})
+            scale_types = {"centerCrop": "cover", "fitCenter": "contain", "centerInside": "contain", "fitXY": "fill", "center": "none"}
+            if attrs.get("scaleType") in scale_types:
+                _set(node, "style.objectFit", scale_types[attrs["scaleType"]], active_context, line, f'scaleType="{attrs["scaleType"]}"', self.id)
+            if attrs.get("focusable") == "true":
+                node["states"] = {"default": {}, "focused": {"style": {"outline": "source-focus"}}}
+            node["children"] = [convert(child, active_context, active_text, include_stack) for child in element if isinstance(child.tag, str)]
+            if short == "ImageButton" and node.get("asset"):
+                icon_id = f"{node_id}-icon"
+                result.nodes[icon_id] = {
+                    "type": "icon", "component": "ImageButton.drawable", "asset": node["asset"], "alt": node.get("alt", ""),
+                    "layout": {"width": "fill", "height": "fill"}, "style": {"objectFit": node.get("style", {}).get("objectFit", "contain")}, "children": [],
+                    "source": {"file": active_context.source, "line": line}, "confidence": node.get("confidence", "high"), "standardRef": node.get("standardRef"),
+                    "provenance": {"asset": node["provenance"].get("asset", property_evidence(active_context.source, line, str(node["asset"]), self.id, "exact"))},
+                }
+                node["children"].insert(0, icon_id)
+            if node.get("layout", {}).get("direction") == "overlay":
+                for child_id in node["children"]:
+                    child_node = result.nodes[child_id]
+                    child_node.setdefault("layout", {})["gridArea"] = "1 / 1"
+                    child_source = child_node.get("source", {})
+                    child_node.setdefault("provenance", {})["layout.gridArea"] = property_evidence(
+                        str(child_source.get("file") or active_context.source),
+                        int(child_source.get("line") or line),
+                        "overlay parent",
+                        self.id,
+                        "high",
+                    )
+            result.nodes[node_id] = node
+            return node_id
+
+        candidates = list(content_root) if _local(content_root.tag) == "merge" else [content_root]
+        result.nodes[root_id]["children"] = [convert(child, context, context.text) for child in candidates]
+        if context.role == "screen":
+            metadata = android_layout_metadata(context.path) or {}
+            result.screens.append({
+                "id": screen_id,
+                "name": context.path.stem,
+                "root": root_id,
+                "route": "",
+                "platform": platform,
+                "source": {"file": context.source, "line": 1, "symbol": context.path.stem},
+                "confidence": "high",
+                "androidLayout": str(metadata.get("resource") or context.path.stem),
+                "resourceQualifier": str(metadata.get("qualifier") or ""),
+            })
+        return result
+
+
+class XamlAdapter:
+    id = "xaml"
+    platforms = ("windows",)
+    extensions = (".xaml",)
+    maturity = "structural"
+    structural_tier = "translated"
+    visual_tier = "none"
+    native_evidence_required = True
+    limitations = ("templates and bindings are not evaluated", "custom controls remain unsupported")
+    TYPES = {"Page": "container", "Window": "container", "UserControl": "container", "Grid": "container", "StackPanel": "container", "Canvas": "container", "Border": "card", "NavigationView": "container", "Frame": "container", "ScrollViewer": "container", "ListView": "list", "GridView": "list", "ItemsControl": "list", "TextBlock": "text", "Label": "text", "Button": "button", "HyperlinkButton": "button", "TextBox": "input", "PasswordBox": "input", "Image": "image", "SymbolIcon": "icon", "FontIcon": "icon", "Rectangle": "divider"}
+
+    def supports(self, context: SourceContext) -> bool:
+        return context.path.suffix.lower() == ".xaml" and any(value.startswith("windows-") for value in context.platforms)
+
+    def translate(self, context: SourceContext) -> AdapterResult:
+        result = AdapterResult(adapter=self.id)
+        try:
+            root = ET.fromstring(context.text)
+        except ET.ParseError as exc:
+            result.unsupported.append({"adapter": self.id, "file": context.source, "line": getattr(exc, "position", (1,))[0], "expression": str(exc), "reason": "invalid-xaml"})
+            return result
+        root_tag = _local(root.tag)
+        if root_tag == "ResourceDictionary":
+            for child in root:
+                attrs, value = _attrs(child), (child.text or attrs.get("Color") or "").strip()
+                name = attrs.get("Key")
+                if not name or not value:
+                    continue
+                group = "colors" if _local(child.tag) in {"Color", "SolidColorBrush"} else "spacing"
+                result.tokens[group][_slug(name).replace("-", "_")] = {"value": _normalize_ref(value, group), "source": {"file": context.source, "line": _line(context.text, name)}, "adapter": self.id}
+            return result
+        root_attrs = _attrs(root)
+        name = root_attrs.get("Class", context.path.stem).split(".")[-1]
+        screen_id, root_id = _slug(name, "windows-view"), f"{_slug(name, 'windows-view')}-root"
+        result.nodes[root_id] = _root_node(context, self.id, "project.windows.xaml")
+        count = 0
+
+        def convert(element: ET.Element) -> str:
+            nonlocal count
+            count += 1
+            tag, attrs = _local(element.tag), _attrs(element)
+            node_id = f"{screen_id}-{_slug(attrs.get('Name') or tag)}-{count}"
+            node_type, line = self.TYPES.get(tag, "custom"), _line(context.text, f"<{tag}")
+            node: dict[str, Any] = {"type": node_type, "component": tag, "layout": {}, "style": {}, "children": [], "source": {"file": context.source, "line": line}, "confidence": "high" if node_type != "custom" else "unsupported", "standardRef": f"project.windows.{tag.lower()}", "provenance": {}}
+            if node_type != "custom":
+                node["inheritsAppearance"] = True
+                node["provenance"]["component"] = property_evidence(context.source, line, tag, self.id, "exact")
+            else:
+                result.unsupported.append({"adapter": self.id, "file": context.source, "line": line, "expression": tag, "reason": "unsupported-xaml-control"})
+            mapping = {"Width": ("layout.width", "spacing"), "Height": ("layout.height", "spacing"), "MinWidth": ("layout.minWidth", "spacing"), "MinHeight": ("layout.minHeight", "spacing"), "Margin": ("layout.margin", "spacing"), "Padding": ("layout.padding", "spacing"), "Background": ("style.background", "colors"), "Foreground": ("style.color", "colors"), "FontSize": ("style.fontSize", "typography"), "CornerRadius": ("style.radius", "radii"), "Opacity": ("style.opacity", "spacing")}
+            for attr, (path, group) in mapping.items():
+                if attr in attrs:
+                    _set(node, path, _normalize_ref(attrs[attr], group), context, line, f'{attr}="{attrs[attr]}"', self.id)
+            if attrs.get("Orientation") in {"Vertical", "Horizontal"}:
+                _set(node, "layout.direction", "column" if attrs["Orientation"] == "Vertical" else "row", context, line, f'Orientation="{attrs["Orientation"]}"', self.id)
+            text = attrs.get("Text") or attrs.get("Content") or (element.text or "").strip()
+            if text and "{" not in text:
+                node["text"] = text
+                node["provenance"]["text"] = property_evidence(context.source, line, text, self.id, "exact")
+            if attrs.get("Source"):
+                node["asset"] = attrs["Source"]
+                node["provenance"]["asset"] = property_evidence(context.source, line, attrs["Source"], self.id, "exact")
+            node["children"] = [convert(child) for child in element if isinstance(child.tag, str) and "." not in _local(child.tag)]
+            result.nodes[node_id] = node
+            return node_id
+
+        result.nodes[root_id]["children"] = [convert(root)]
+        result.screens.append({"id": screen_id, "name": name, "root": root_id, "route": "", "platform": "windows", "source": {"file": context.source, "line": 1, "symbol": name}, "confidence": "high"})
+        return result
+
+
+DECLARATIVE_TYPES = {
+    "VStack": "container", "HStack": "container", "ZStack": "container", "NavigationStack": "container", "ScrollView": "container", "Form": "container", "Section": "container", "List": "list", "Text": "text", "Button": "button", "TextField": "input", "SecureField": "input", "Image": "image", "AsyncImage": "image", "Label": "text", "Spacer": "spacer", "Divider": "divider", "Toggle": "button",
+    "Column": "container", "Row": "container", "Stack": "container", "Scaffold": "container", "Container": "container", "Padding": "container", "Center": "container", "Expanded": "container", "ListView": "list", "GridView": "list", "Card": "card", "ElevatedButton": "button", "TextButton": "button", "IconButton": "button", "TextFormField": "input", "SizedBox": "spacer", "Icon": "icon",
+}
+
+
+def _declarative_calls(body: str, types: set[str]) -> list[dict[str, Any]]:
+    calls: list[dict[str, Any]] = []
+    pattern = re.compile(r"\b(" + "|".join(sorted(types, key=len, reverse=True)) + r")\b")
+    for match in pattern.finditer(body):
+        cursor = match.end()
+        while cursor < len(body) and body[cursor].isspace(): cursor += 1
+        args, close = "", match.end()
+        if cursor < len(body) and body[cursor] == "(":
+            end = _balanced_close(body, cursor, "(", ")")
+            if end is None: continue
+            args, close, cursor = body[cursor + 1:end], end, end + 1
+        while cursor < len(body) and body[cursor].isspace(): cursor += 1
+        block_end = _balanced_close(body, cursor, "{", "}") if cursor < len(body) and body[cursor] == "{" else None
+        contain_end = block_end if block_end is not None else close
+        calls.append({"widget": match.group(1), "start": match.start(), "args": args, "close": close, "blockStart": cursor if block_end is not None else None, "containEnd": contain_end})
+    return calls
+
+
+def _modifier_chain(body: str, start: int) -> str:
+    cursor, end = start, start
+    while cursor < len(body):
+        while cursor < len(body) and body[cursor].isspace():
+            cursor += 1
+        if cursor >= len(body) or body[cursor] != ".":
+            break
+        match = re.match(r"\.\w+", body[cursor:])
+        if not match:
+            break
+        cursor += match.end()
+        while cursor < len(body) and body[cursor].isspace():
+            cursor += 1
+        if cursor < len(body) and body[cursor] == "(":
+            close = _balanced_close(body, cursor, "(", ")")
+            if close is None:
+                break
+            cursor = close + 1
+        end = cursor
+    return body[start:end]
+
+
+def _apple_color(expression: str, catalog: AppleResourceCatalog | None) -> tuple[str | None, str]:
+    asset = re.search(r'Color\(\s*"([^"]+)"', expression)
+    if asset and catalog and (resolved := catalog.color(asset.group(1))):
+        return resolved.value, resolved.source
+    named = re.search(r"(?:Color\.)?\.(black|white|red|green|blue|gray|orange|yellow|pink|purple|primary|secondary)\b", expression)
+    if not named:
+        named = re.search(r"\bColor\.(black|white|red|green|blue|gray|orange|yellow|pink|purple|primary|secondary)\b", expression)
+    colors = {
+        "black": "#000000", "white": "#ffffff", "red": "#ff3b30", "green": "#34c759", "blue": "#007aff",
+        "gray": "#8e8e93", "orange": "#ff9500", "yellow": "#ffcc00", "pink": "#ff2d55", "purple": "#af52de",
+        "primary": "#000000", "secondary": "#6d6d72",
+    }
+    return (colors.get(named.group(1)), "apple-semantic-color") if named else (None, "")
+
+
+def _translate_declarative(context: SourceContext, adapter: str, screen_name: str, body: str, body_offset: int, platform: str, standard_prefix: str, tokens: dict[str, Any], apple_catalog: AppleResourceCatalog | None = None) -> AdapterResult:
+    result = AdapterResult(adapter=adapter, tokens=tokens)
+    screen_id, root_id = _slug(screen_name), f"{_slug(screen_name)}-root"
+    result.nodes[root_id] = _root_node(context, adapter, f"project.{standard_prefix}.screen", _line(context.text, screen_name))
+    calls = _declarative_calls(body, set(DECLARATIVE_TYPES))
+    records: list[tuple[dict[str, Any], str]] = []
+    for index, call in enumerate(calls, start=1):
+        widget, args = call["widget"], call["args"]
+        node_id, node_type = f"{screen_id}-{_slug(widget)}-{index}", DECLARATIVE_TYPES[widget]
+        line = context.text.count("\n", 0, body_offset + call["start"]) + 1
+        native_prefix = "apple" if platform in {"ios", "macos"} else "material3" if platform == "android" else "project"
+        node: dict[str, Any] = {"type": node_type, "component": widget, "layout": {}, "style": {}, "children": [], "source": {"file": context.source, "line": line, "symbol": screen_name}, "confidence": "high", "standardRef": f"{native_prefix}.{standard_prefix}.{widget.lower()}", "inheritsAppearance": True, "provenance": {"component": property_evidence(context.source, line, widget, adapter, "exact")}}
+        literal = re.search(r"(?:text\s*:\s*|label\s*:\s*)?[\"']([^\"']+)[\"']", args)
+        if literal and node_type in {"text", "button", "input"}:
+            node["text"] = literal.group(1)
+            node["provenance"]["text"] = property_evidence(context.source, line, literal.group(0), adapter, "exact")
+        localized = re.search(r'String\(\s*localized\s*:\s*"([^"]+)"', args)
+        if localized and apple_catalog and (resolved := apple_catalog.localized(localized.group(1))):
+            node["text"] = resolved.value
+            node["provenance"]["text"] = property_evidence(resolved.source, 1, localized.group(0), adapter, resolved.confidence)
+        if widget in {"VStack", "Column", "List", "ListView"}:
+            _set(node, "layout.direction", "column", context, line, widget, adapter)
+        if widget in {"HStack", "Row"}:
+            _set(node, "layout.direction", "row", context, line, widget, adapter)
+        if widget in {"ZStack", "Stack"}:
+            _set(node, "layout.direction", "overlay", context, line, widget, adapter)
+        alignment = re.search(r"\balignment\s*:\s*\.?(leading|trailing|center|top|bottom)", args)
+        if alignment and widget in {"VStack", "HStack", "ZStack"}:
+            mapped = {"leading": "start", "trailing": "end", "top": "start", "bottom": "end", "center": "center"}[alignment.group(1)]
+            _set(node, "layout.align", mapped, context, line, alignment.group(0), adapter)
+        spacing = re.search(r"\bspacing\s*:\s*(-?\d+(?:\.\d+)?)", args)
+        if spacing:
+            _set(node, "layout.gap", _normalize_ref(spacing.group(1)), context, line, spacing.group(0), adapter)
+        modifier_start = int(call.get("containEnd") or call["close"]) + 1
+        expression = args + _modifier_chain(body, modifier_start)
+        padding = re.search(r"\.padding\s*\(\s*(?!\.)([\w.]+)", expression)
+        flutter_padding = re.search(r"padding\s*:\s*(?:const\s+)?EdgeInsets\.all\s*\(\s*([\w.]+)", expression)
+        padding_value = padding.group(1) if padding else flutter_padding.group(1) if flutter_padding else None
+        if padding_value: _set(node, "layout.padding", _normalize_ref(padding_value), context, line, (padding or flutter_padding).group(0), adapter)
+        directional_padding = re.search(r"\.padding\s*\(\s*\.(horizontal|vertical|top|bottom|leading|trailing)\s*,\s*([\w.]+)", expression)
+        if directional_padding:
+            key = {"horizontal": "paddingHorizontal", "vertical": "paddingVertical", "top": "paddingTop", "bottom": "paddingBottom", "leading": "paddingLeft", "trailing": "paddingRight"}[directional_padding.group(1)]
+            _set(node, f"layout.{key}", _normalize_ref(directional_padding.group(2)), context, line, directional_padding.group(0), adapter)
+        width = re.search(r"(?:width\s*:\s*|\.frame\s*\(\s*width\s*:\s*)([\w.]+)", expression)
+        height = re.search(r"(?:height\s*:\s*|\.frame\s*\([^)]*height\s*:\s*)([\w.]+)", expression)
+        if width: _set(node, "layout.width", _normalize_ref(width.group(1)), context, line, width.group(0), adapter)
+        if height: _set(node, "layout.height", _normalize_ref(height.group(1)), context, line, height.group(0), adapter)
+        if re.search(r"\.frame\s*\([^)]*maxWidth\s*:\s*\.infinity", expression):
+            _set(node, "layout.width", "fill", context, line, "frame maxWidth: .infinity", adapter)
+        if re.search(r"\.frame\s*\([^)]*maxHeight\s*:\s*\.infinity", expression):
+            _set(node, "layout.height", "fill", context, line, "frame maxHeight: .infinity", adapter)
+        if platform in {"ios", "macos"}:
+            system_image = re.search(r'systemName\s*:\s*"([^"]+)"', args)
+            named_image = re.match(r'\s*"([^"]+)"', args)
+            if widget == "Image" and system_image:
+                node["type"] = "icon"
+                node["iconName"] = system_image.group(1)
+                if asset := sf_symbol_asset(system_image.group(1)):
+                    node["asset"] = asset
+                    node["provenance"]["asset"] = property_evidence("apple-sf-symbol-fallback", 1, system_image.group(0), adapter, "approximate")
+            elif widget in {"Image", "AsyncImage"} and named_image and apple_catalog:
+                resolved = apple_catalog.image(named_image.group(1))
+                if resolved:
+                    node["asset"] = resolved.value
+                    node["provenance"]["asset"] = property_evidence(resolved.source, 1, named_image.group(0), adapter, resolved.confidence)
+            foreground = re.search(r"\.(?:foregroundStyle|foregroundColor)\s*\(([^)]*(?:\([^)]*\)[^)]*)?)\)", expression)
+            if foreground:
+                color, source = _apple_color(foreground.group(1), apple_catalog)
+                if color:
+                    node["style"]["color"] = color
+                    node["provenance"]["style.color"] = property_evidence(source or context.source, 1 if source else line, foreground.group(0), adapter, "high")
+            background = re.search(r"\.background\s*\(([^)]*(?:\([^)]*\)[^)]*)?)\)", expression)
+            if background:
+                color, source = _apple_color(background.group(1), apple_catalog)
+                if color:
+                    node["style"]["backgroundColor"] = color
+                    node["provenance"]["style.backgroundColor"] = property_evidence(source or context.source, 1 if source else line, background.group(0), adapter, "high")
+            radius = re.search(r"\.cornerRadius\s*\(\s*([\d.]+)", expression) or re.search(r"RoundedRectangle\s*\(\s*cornerRadius\s*:\s*([\d.]+)", expression)
+            if radius:
+                _set(node, "style.radius", _normalize_ref(radius.group(1)), context, line, radius.group(0), adapter)
+            font_size = re.search(r"\.font\s*\(\s*\.system\s*\([^)]*size\s*:\s*([\d.]+)", expression)
+            if font_size:
+                _set(node, "style.fontSize", _normalize_ref(font_size.group(1)), context, line, font_size.group(0), adapter)
+            font_weight = re.search(r"(?:weight\s*:\s*|\.fontWeight\s*\()\.?(bold|semibold|medium|regular)", expression)
+            if font_weight:
+                _set(node, "style.fontWeight", {"bold": 700, "semibold": 600, "medium": 500, "regular": 400}[font_weight.group(1)], context, line, font_weight.group(0), adapter)
+            if ".bold()" in expression:
+                _set(node, "style.fontWeight", 700, context, line, ".bold()", adapter)
+            text_align = re.search(r"\.multilineTextAlignment\s*\(\s*\.(leading|center|trailing)", expression)
+            if text_align:
+                _set(node, "style.textAlign", {"leading": "start", "center": "center", "trailing": "end"}[text_align.group(1)], context, line, text_align.group(0), adapter)
+            if ".scaledToFill()" in expression:
+                _set(node, "style.objectFit", "cover", context, line, ".scaledToFill()", adapter)
+            elif ".scaledToFit()" in expression:
+                _set(node, "style.objectFit", "contain", context, line, ".scaledToFit()", adapter)
+        result.nodes[node_id] = node
+        records.append((call, node_id))
+    for call, node_id in records:
+        parents = [(candidate, candidate_id) for candidate, candidate_id in records if candidate["start"] < call["start"] < candidate["containEnd"]]
+        parent_id = max(parents, key=lambda item: item[0]["start"])[1] if parents else root_id
+        result.nodes[parent_id]["children"].append(node_id)
+    known = set(DECLARATIVE_TYPES) | {"Color", "Font", "String", "EdgeInsets", "RoundedRectangle", "MaterialApp", "ThemeData"}
+    for unknown in re.finditer(r"\b([A-Z]\w*)\s*(?:\(|\{)", body):
+        if unknown.group(1) not in known:
+            result.unsupported.append({"adapter": adapter, "file": context.source, "line": context.text.count("\n", 0, body_offset + unknown.start()) + 1, "expression": unknown.group(1), "reason": "unsupported-declarative-component"})
+    result.screens.append({"id": screen_id, "name": screen_name, "root": root_id, "route": "", "platform": platform, "source": {"file": context.source, "line": _line(context.text, screen_name), "symbol": screen_name}, "confidence": "high"})
+    return result
+
+
+class SwiftUIAdapter:
+    id = "swiftui"
+    platforms = ("ios", "macos")
+    extensions = (".swift",)
+    maturity = "structural"
+    structural_tier = "translated"
+    visual_tier = "none"
+    native_evidence_required = True
+    native_providers = ("xcode-preview", "swift-snapshot-testing", "apple-simulator")
+    resource_resolution = ("Asset Catalog images/colors", "Localizable.strings", "common SF Symbols")
+    layout_features = ("stack direction/alignment/spacing", "frame/fill/padding", "overlay stacks", "basic color/type/image modifiers")
+    limitations = ("supported SwiftUI primitives and modifiers only", "conditional runtime branches are not executed", "SF Symbol SVGs are structural fallbacks")
+
+    def __init__(self) -> None:
+        self._catalogs: dict[str, AppleResourceCatalog] = {}
+
+    def prepare(self, contexts: list[SourceContext]) -> None:
+        roots = {str(context.root.resolve()): context.root for context in contexts if self.supports(context)}
+        self._catalogs = {key: AppleResourceCatalog.discover(root) for key, root in roots.items()}
+
+    def _catalog(self, context: SourceContext) -> AppleResourceCatalog:
+        key = str(context.root.resolve())
+        if key not in self._catalogs:
+            self._catalogs[key] = AppleResourceCatalog.discover(context.root)
+        return self._catalogs[key]
+
+    def supports(self, context: SourceContext) -> bool:
+        return context.path.suffix.lower() == ".swift" and any(value.startswith("swiftui") for value in context.platforms)
+
+    def translate(self, context: SourceContext) -> AdapterResult:
+        combined = AdapterResult(adapter=self.id)
+        catalog = self._catalog(context)
+        tokens = {"colors": {}, "spacing": {}, "radii": {}, "typography": {}}
+        for match in re.finditer(r"(?:static\s+)?let\s+(\w+)\s*(?::\s*\w+)?\s*=\s*(Color\([^\n]+\)|\d+(?:\.\d+)?)", context.text):
+            group = "colors" if match.group(2).startswith("Color") else "spacing"
+            tokens[group][_slug(match.group(1)).replace("-", "_")] = {"value": match.group(2), "source": {"file": context.source, "line": _line(context.text, match.group(0))}, "adapter": self.id}
+        platform = "macos" if any(value in {"swiftui-macos", "appkit"} for value in context.platforms) else "ios"
+        for struct in re.finditer(r"\bstruct\s+([A-Z]\w*)\s*:\s*View\s*\{", context.text):
+            end = _balanced_close(context.text, context.text.find("{", struct.start()), "{", "}")
+            if end is None: continue
+            segment = context.text[struct.end():end]
+            body_match = re.search(r"\bvar\s+body\s*:\s*some\s+View\s*\{", segment)
+            if not body_match: continue
+            body_start = struct.end() + body_match.end()
+            body_end = _balanced_close(context.text, body_start - 1, "{", "}")
+            if body_end is None: continue
+            current = _translate_declarative(context, self.id, struct.group(1), context.text[body_start:body_end], body_start, platform, "swiftui", tokens, catalog)
+            combined.screens.extend(current.screens); combined.nodes.update(current.nodes); combined.unsupported.extend(current.unsupported)
+        combined.tokens = tokens
+        return combined
+
+
+class FlutterAdapter:
+    id = "flutter"
+    platforms = ("flutter",)
+    extensions = (".dart",)
+    maturity = "structural"
+    structural_tier = "translated"
+    visual_tier = "none"
+    native_evidence_required = True
+    native_providers = ("flutter-golden", "flutter-device")
+    limitations = ("custom widgets remain unsupported", "platform-adaptive runtime branches are not executed")
+
+    def supports(self, context: SourceContext) -> bool:
+        return context.path.suffix.lower() == ".dart" and "flutter" in context.platforms
+
+    def translate(self, context: SourceContext) -> AdapterResult:
+        combined = AdapterResult(adapter=self.id)
+        tokens = {"colors": {}, "spacing": {}, "radii": {}, "typography": {}}
+        for match in re.finditer(r"(?:static\s+)?const\s+(?:Color|double)\s+(\w+)\s*=\s*([^;]+);", context.text):
+            group = "colors" if "Color" in match.group(0).split("=")[0] else "spacing"
+            tokens[group][_slug(match.group(1)).replace("-", "_")] = {"value": match.group(2).strip(), "source": {"file": context.source, "line": _line(context.text, match.group(0))}, "adapter": self.id}
+        for klass in re.finditer(r"\bclass\s+([A-Z]\w*)\s+extends\s+(?:StatelessWidget|StatefulWidget)\s*\{", context.text):
+            class_end = _balanced_close(context.text, context.text.find("{", klass.start()), "{", "}")
+            if class_end is None: continue
+            segment = context.text[klass.end():class_end]
+            build = re.search(r"\bWidget\s+build\s*\([^)]*\)\s*\{", segment)
+            if not build: continue
+            build_start = klass.end() + build.end()
+            build_end = _balanced_close(context.text, build_start - 1, "{", "}")
+            if build_end is None: continue
+            current = _translate_declarative(context, self.id, klass.group(1), context.text[build_start:build_end], build_start, "flutter", "flutter", tokens)
+            combined.screens.extend(current.screens); combined.nodes.update(current.nodes); combined.unsupported.extend(current.unsupported)
+        combined.tokens = tokens
+        return combined
+
+
+class AppleInterfaceXmlAdapter:
+    id = "apple-interface-xml"
+    platforms = ("ios", "macos")
+    extensions = (".storyboard", ".xib")
+    maturity = "structural"
+    structural_tier = "translated"
+    visual_tier = "none"
+    native_evidence_required = True
+    native_providers = ("swift-snapshot-testing", "apple-simulator")
+    resource_resolution = ("Asset Catalog images/colors", "authored interface strings")
+    layout_features = ("authored frames", "stack axis/spacing", "basic width/height/center Auto Layout constraints")
+    limitations = ("complex Auto Layout equations are not solved", "runtime UIKit/AppKit mutations are unsupported")
+    TYPES = {"view": "container", "stackView": "container", "scrollView": "container", "tableView": "list", "collectionView": "list", "label": "text", "button": "button", "textField": "input", "textView": "input", "imageView": "image", "separator": "divider"}
+
+    def __init__(self) -> None:
+        self._catalogs: dict[str, AppleResourceCatalog] = {}
+
+    def prepare(self, contexts: list[SourceContext]) -> None:
+        roots = {str(context.root.resolve()): context.root for context in contexts if self.supports(context)}
+        self._catalogs = {key: AppleResourceCatalog.discover(root) for key, root in roots.items()}
+
+    def _catalog(self, context: SourceContext) -> AppleResourceCatalog:
+        key = str(context.root.resolve())
+        if key not in self._catalogs:
+            self._catalogs[key] = AppleResourceCatalog.discover(context.root)
+        return self._catalogs[key]
+
+    def supports(self, context: SourceContext) -> bool:
+        return context.path.suffix.lower() in {".storyboard", ".xib"}
+
+    def translate(self, context: SourceContext) -> AdapterResult:
+        result = AdapterResult(adapter=self.id)
+        catalog = self._catalog(context)
+        try: document = ET.fromstring(context.text)
+        except ET.ParseError as exc:
+            result.unsupported.append({"adapter": self.id, "file": context.source, "line": getattr(exc, "position", (1,))[0], "expression": str(exc), "reason": "invalid-interface-xml"}); return result
+        controllers = [item for item in document.iter() if _local(item.tag) in {"viewController", "windowController"}]
+        if not controllers and context.path.suffix.lower() == ".xib": controllers = [document]
+        platform = "macos" if "MacOSX" in context.text or any(value == "appkit" for value in context.platforms) else "ios"
+        for screen_index, controller in enumerate(controllers, start=1):
+            attrs = _attrs(controller); name = attrs.get("customClass") or attrs.get("id") or f"{context.path.stem}-{screen_index}"
+            screen_id, root_id = _slug(name), f"{_slug(name)}-root"
+            result.nodes[root_id] = _root_node(context, self.id, f"project.{platform}.interface")
+            count = 0
+            source_ids: dict[str, str] = {}
+            def convert(element: ET.Element, parent_tag: str = "") -> str | None:
+                nonlocal count
+                tag = _local(element.tag)
+                if tag in {"connections", "constraints", "resources", "dependencies", "outlet", "segue", "constraint", "color"}: return None
+                count += 1; attrs = _attrs(element); node_type = self.TYPES.get(tag, "custom"); line = _line(context.text, f"<{tag}")
+                node_id = f"{screen_id}-{_slug(attrs.get('id') or tag)}-{count}"
+                if attrs.get("id"):
+                    source_ids[attrs["id"]] = node_id
+                node: dict[str, Any] = {"type": node_type, "component": tag, "layout": {}, "style": {}, "children": [], "source": {"file": context.source, "line": line}, "confidence": "high" if node_type != "custom" else "unsupported", "standardRef": f"project.{platform}.{tag.lower()}", "provenance": {}}
+                if node_type != "custom": node["inheritsAppearance"] = True; node["provenance"]["component"] = property_evidence(context.source, line, tag, self.id, "exact")
+                else: result.unsupported.append({"adapter": self.id, "file": context.source, "line": line, "expression": tag, "reason": "unsupported-interface-node"})
+                text = attrs.get("text") or attrs.get("title") or attrs.get("placeholder")
+                if text: node["text"] = text; node["provenance"]["text"] = property_evidence(context.source, line, text, self.id, "exact")
+                if tag == "view":
+                    _set(node, "layout.direction", "overlay", context, line, tag, self.id)
+                if tag == "stackView":
+                    _set(node, "layout.direction", "column" if attrs.get("axis") == "vertical" else "row", context, line, f'axis={attrs.get("axis", "horizontal")}', self.id)
+                    if attrs.get("spacing"):
+                        _set(node, "layout.gap", _normalize_ref(attrs["spacing"]), context, line, f'spacing={attrs["spacing"]}', self.id)
+                if attrs.get("image"):
+                    resolved = catalog.image(attrs["image"])
+                    node["asset"] = resolved.value if resolved else attrs["image"]
+                    node["provenance"]["asset"] = property_evidence(resolved.source if resolved else context.source, 1 if resolved else line, attrs["image"], self.id, resolved.confidence if resolved else "approximate")
+                    if not resolved:
+                        result.unsupported.append({"adapter": self.id, "file": context.source, "line": line, "expression": attrs["image"], "reason": "unresolved-apple-image"})
+                named_color = next((_attrs(child).get("name") for child in element if _local(child.tag) == "color" and _attrs(child).get("name")), None)
+                if named_color and (resolved_color := catalog.color(named_color)):
+                    node["style"]["color" if node_type in {"text", "button", "input", "icon"} else "backgroundColor"] = resolved_color.value
+                    node["provenance"]["style.color" if node_type in {"text", "button", "input", "icon"} else "style.backgroundColor"] = property_evidence(resolved_color.source, 1, named_color, self.id, resolved_color.confidence)
+                frame = next((child for child in element if _local(child.tag) == "rect" and _attrs(child).get("key") == "frame"), None)
+                if frame is not None:
+                    values = _attrs(frame)
+                    for attr, key in (("x", "left"), ("y", "top"), ("width", "width"), ("height", "height")):
+                        if attr in values: _set(node, f"layout.{key}", _normalize_ref(values[attr]), context, line, f"frame.{attr}={values[attr]}", self.id)
+                    if parent_tag and parent_tag != "stackView":
+                        _set(node, "layout.position", "absolute", context, line, "authored frame", self.id, "high")
+                child_ids: list[str] = []
+                for child in element:
+                    if not isinstance(child.tag, str) or _local(child.tag) == "rect": continue
+                    candidates = list(child) if _local(child.tag) in {"subviews", "objects", "scenes"} else [child]
+                    for candidate in candidates:
+                        if isinstance(candidate.tag, str) and (child_id := convert(candidate, tag)): child_ids.append(child_id)
+                node["children"] = child_ids
+                result.nodes[node_id] = node; return node_id
+            roots = [child_id for child in controller if isinstance(child.tag, str) and (child_id := convert(child))]
+            result.nodes[root_id]["children"] = roots
+            for constraint in controller.iter():
+                if _local(constraint.tag) != "constraint":
+                    continue
+                values = _attrs(constraint)
+                first_id = source_ids.get(values.get("firstItem", ""))
+                if not first_id:
+                    continue
+                node = result.nodes[first_id]
+                attribute = values.get("firstAttribute", "")
+                second_attribute = values.get("secondAttribute", "")
+                second_item = values.get("secondItem")
+                constant = values.get("constant")
+                if attribute in {"width", "height"} and not second_item and constant:
+                    _set(node, f"layout.{attribute}", _normalize_ref(constant), context, _line(context.text, values.get("id", "constraint")), f"constraint {attribute}={constant}", self.id, "high")
+                elif attribute == "centerX" and second_attribute == "centerX":
+                    _set(node, "layout.justifySelf", "center", context, _line(context.text, values.get("id", "constraint")), "centerX constraint", self.id, "high")
+                elif attribute == "centerY" and second_attribute == "centerY":
+                    _set(node, "layout.alignSelf", "center", context, _line(context.text, values.get("id", "constraint")), "centerY constraint", self.id, "high")
+                else:
+                    result.unsupported.append({"adapter": self.id, "file": context.source, "line": _line(context.text, values.get("id", "constraint")), "expression": values.get("id", "constraint"), "reason": "unsupported-auto-layout-equation"})
+            result.screens.append({"id": screen_id, "name": name, "root": root_id, "route": "", "platform": platform, "source": {"file": context.source, "line": _line(context.text, name), "symbol": name}, "confidence": "high"})
+        return result
+
+
+class ProjectedMarkupAdapter:
+    def __init__(self, web_adapter: Any, kind: str):
+        self.web_adapter, self.id = web_adapter, kind
+        self.platforms = ("web",)
+        self.extensions = (".jsx", ".tsx", ".js", ".ts") if kind.startswith("react") else (f".{kind}",)
+        self.maturity = "golden"
+        self.structural_tier = "translated"
+        self.visual_tier = "projection"
+        self.native_evidence_required = False
+        self.native_providers = ()
+        self.limitations = ("dynamic expressions are not executed", "project components remain unsupported until mapped")
+
+    def supports(self, context: SourceContext) -> bool:
+        suffix = context.path.suffix.lower()
+        if self.id == "react-jsx": return suffix in {".jsx", ".tsx", ".js", ".ts"} and "react-web" in context.platforms
+        if self.id == "vue": return suffix == ".vue"
+        return suffix == ".svelte"
+
+    def translate(self, context: SourceContext) -> AdapterResult:
+        text, start = context.text, 0
+        if self.id == "vue":
+            match = re.search(r"<template\b[^>]*>([\s\S]*?)</template>", text, re.I)
+            if not match: return AdapterResult(adapter=self.id, unsupported=[{"adapter": self.id, "file": context.source, "line": 1, "expression": "template", "reason": "missing-template"}])
+            markup, start = match.group(1), match.start(1)
+        elif self.id == "svelte":
+            markup = re.sub(r"<(script|style)\b[^>]*>[\s\S]*?</\1>", "", text, flags=re.I)
+        else:
+            match = re.search(r"\breturn\s*\(", text)
+            if not match: return AdapterResult(adapter=self.id, unsupported=[{"adapter": self.id, "file": context.source, "line": 1, "expression": "return", "reason": "missing-static-jsx-return"}])
+            open_index = text.find("(", match.start()); end = _balanced_close(text, open_index, "(", ")")
+            if end is None: return AdapterResult(adapter=self.id, unsupported=[{"adapter": self.id, "file": context.source, "line": _line(text, match.group(0)), "expression": "return", "reason": "unbalanced-jsx"}])
+            markup, start = text[open_index + 1:end], open_index + 1
+        unsupported: list[dict[str, Any]] = []
+        for expression in re.finditer(r"\{[^{}]*\}", markup):
+            unsupported.append({"adapter": self.id, "file": context.source, "line": text.count("\n", 0, start + expression.start()) + 1, "expression": expression.group(0)[:200], "reason": "dynamic-markup-expression"})
+        projected = re.sub(r"\{[^{}]*\}", "", markup)
+        projected = projected.replace("className=", "class=").replace("htmlFor=", "for=")
+        embedded_css = "\n".join(re.findall(r"<style\b[^>]*>([\s\S]*?)</style>", text, re.I)) if self.id in {"vue", "svelte"} else ""
+        padded = "\n" * text.count("\n", 0, start) + projected + ("\n" + embedded_css if embedded_css else "")
+        projected_context = SourceContext(context.root, context.path, context.source, padded, context.platforms, context.role)
+        result = self.web_adapter.translate(projected_context)
+        result.adapter = self.id; result.unsupported.extend(unsupported)
+        custom_tags = {value.lower(): value for value in re.findall(r"<([A-Z][A-Za-z0-9_.]*)\b", markup)}
+        for node in result.nodes.values():
+            for evidence in node.get("provenance", {}).values():
+                if isinstance(evidence, dict): evidence["adapter"] = self.id; evidence["confidence"] = "high"
+            node["confidence"] = "high"
+            ref = str(node.get("standardRef") or "")
+            tag = ref.removeprefix("html.")
+            if tag in custom_tags:
+                node.update({"type": "custom", "component": custom_tags[tag], "confidence": "unsupported", "standardRef": f"project.{self.id}.{tag}"})
+                result.unsupported.append({"adapter": self.id, "file": context.source, "line": node.get("source", {}).get("line", 1), "expression": custom_tags[tag], "reason": "untranslated-project-component"})
+        target_platform = "web"
+        for screen in result.screens: screen["platform"] = target_platform; screen["name"] = context.path.stem
+        return result
+
+
+def builtin_platform_adapters(web_adapter: Any) -> list[Any]:
+    return [
+        AndroidXmlAdapter(), SwiftUIAdapter(), XamlAdapter(), FlutterAdapter(), AppleInterfaceXmlAdapter(),
+        ProjectedMarkupAdapter(web_adapter, "react-jsx"),
+        ProjectedMarkupAdapter(web_adapter, "vue"), ProjectedMarkupAdapter(web_adapter, "svelte"),
+    ]