@harmonyos-arkts/d2h 0.1.11 → 0.1.13

package/skills/d2h-utg-static-generate/tests/test_static.py

@@ -1,335 +1,335 @@
-import copy
-import importlib.util
-import json
-import re
-import subprocess
-import sys
-import tempfile
-import unittest
-from pathlib import Path
-
-SCRIPT = Path(__file__).resolve().parents[1] / 'scripts' / 'generate.py'
-spec = importlib.util.spec_from_file_location('static_generate', SCRIPT)
-module = importlib.util.module_from_spec(spec)
-spec.loader.exec_module(module)
-
-
-class StaticTests(unittest.TestCase):
-    def setUp(self):
-        self.temp = tempfile.TemporaryDirectory()
-        self.addCleanup(self.temp.cleanup)
-        self.root = Path(self.temp.name) / 'source'
-        self.root.mkdir()
-        (self.root / 'Screen.kt').write_text('fun home() {}\nfun detail() {}\nfun dialog() {}\n', encoding='utf-8')
-        self.ref = {'file': 'Screen.kt', 'line': 1}
-        self.graph = {'schemaVersion': 1, 'platform': 'android', 'app': {'name': 'Demo', 'packageName': 'demo'},
-            'nodes': [{'id': identity, 'kind': 'Screen', 'name': 'SameName', 'platform': 'android',
-                       'subtype': kind, 'platformRef': self.ref}
-                      for identity, kind in [('home', 'activity'), ('detail', 'compose'), ('dialog', 'dialog'), ('fragment', 'fragment')]],
-            'edges': [{'id': identity, 'kind': 'navigates_to', 'from': source, 'to': target,
-                       'attrs': {'evidence': [self.ref]}, 'confidence': 1}
-                      for identity, source, target in [('nav1', 'home', 'detail'), ('nav2', 'home', 'detail'),
-                                                        ('back', 'detail', 'home'), ('external', 'home', 'outside')]],
-            'entryPoints': [{'id': 'launch', 'kind': 'app-launch', 'sourceRef': 'home', 'resolution': 'resolved'},
-                            {'id': 'click', 'kind': 'ui-action', 'sourceRef': 'button', 'ownerRef': 'home', 'resolution': 'resolved'}],
-            'uiComponents': {'nodes': [{'id': 'button', 'kind': 'control', 'name': 'Button', 'evidence': [self.ref]}],
-                             'edges': [{'id': 'owns', 'kind': 'contains', 'from': 'home', 'to': 'button'}]},
-            'callTraces': [{'id': 'trace', 'entryPointId': 'click', 'effects': [
-                {'id': 'effect', 'kind': 'navigation', 'targetRefs': ['dialog'], 'origin': self.ref}]}]}
-        self.base = module.project(self.graph, self.root)
-        self.fingerprint = module.digest({'appgraph': self.graph, 'source': module.source_digest(self.root)})
-
-    def discoveries(self, operations=None):
-        return {'schema_version': 'd2h-utg-discoveries/v1', 'input_fingerprint': self.fingerprint,
-                'operations': operations or [], 'unresolved': []}
-
-    def operation(self, kind, op, identity, value=None):
-        return {'kind': kind, 'op': op, 'id': identity, 'reason': 'source verified',
-                'evidence': 'Screen.kt:1', 'value': value}
-
-    def test_projection(self):
-        self.assertEqual(len(self.base['nodes']), 4)
-        self.assertEqual(len(self.base['edges']), 4)
-        self.assertEqual(self.base['graph']['root'], 'home')
-        home = next(n for n in self.base['nodes'] if n['id'] == 'home')
-        self.assertEqual(home['widgets'][0]['id'], 'button')
-        self.assertTrue(any(x['subject'] == 'external' for x in self.base['unresolved']))
-
-    def test_source_page_coalesces_manifest_and_synthetic_compose_screen(self):
-        graph = {'schemaVersion': 1, 'platform': 'android', 'app': {'name': 'Demo'},
-            'nodes': [
-                {'id': 'manifest', 'kind': 'Screen', 'name': 'MainActivity', 'subtype': 'activity',
-                 'platformRef': {'file': 'missing.xml', 'symbol': '.MainActivity'}},
-                {'id': 'entry', 'kind': 'AppEntry', 'subtype': 'launcher-activity',
-                 'attrs': {'screen': 'manifest'}},
-                {'id': 'route', 'kind': 'Screen', 'name': 'SplashRoute', 'subtype': 'compose',
-                 'matchKey': 'screen:splashroute', 'platformRef': {'file': 'Screen.kt'}},
-                {'id': 'synthetic', 'kind': 'Screen', 'name': 'SplashRoute', 'subtype': 'compose',
-                 'matchKey': 'screen:splashroute:compose', 'platformRef': self.ref,
-                 'attrs': {'classificationRule': 'compose.destination.register'}}],
-            'uiComponents': {'nodes': [
-                {'id': 'activity-page', 'kind': 'page', 'name': 'MainActivity', 'subtype': 'activity',
-                 'evidence': [self.ref], 'attrs': {'screenId': 'manifest'}},
-                {'id': 'route-page', 'kind': 'page', 'name': 'SplashRoute', 'subtype': 'compose',
-                 'evidence': [self.ref], 'attrs': {'screenId': 'route',
-                     'screenMatchKey': 'screen:splashroute', 'classificationRule': 'COMPOSE-SCREEN-AST'}}],
-                'edges': []}, 'edges': [{'id': 'nav', 'kind': 'navigates_to',
-                    'from': 'manifest', 'to': 'synthetic', 'attrs': {'evidence': [self.ref]}}],
-            'entryPoints': [], 'callTraces': []}
-        base = module.project(graph, self.root)
-        self.assertEqual({n['id'] for n in base['nodes']}, {'activity-page', 'route-page'})
-        self.assertEqual(base['graph']['root'], 'activity-page')
-        self.assertEqual([(e['source'], e['target']) for e in base['edges']],
-                         [('activity-page', 'route-page')])
-
-    def test_interaction_projection_preserves_stable_ids_and_alignment(self):
-        self.graph['interactionGraph'] = {'schemaVersion': 1,
-            'surfaces': [{'id': identity, 'name': identity, 'kind': kind, 'sourceRefs': [identity, 'ui:' + identity],
-                          'hostSurfaceIds': [], 'evidence': [self.ref], 'presentation': 'screen'}
-                         for identity, kind in [('home', 'activity'), ('detail', 'compose')]],
-            'controlBindings': [{'id': 'binding:button:home', 'controlRef': 'button', 'surfaceId': 'home',
-                                 'evidence': [self.ref], 'selectorCandidates': []}],
-            'entries': [{'id': 'launch', 'kind': 'app-launch', 'surfaceIds': ['home'], 'resolution': 'resolved'}],
-            'transitions': [{'id': 'transition:stable', 'sourceSurfaceId': 'home',
-                             'target': {'kind': 'internal', 'surfaceId': 'detail'}, 'operation': 'navigate',
-                             'resolution': 'resolved', 'evidence': [self.ref], 'supportingRefs': ['edge', 'trace', 'effect'],
-                             'actionRef': 'click', 'conditions': []}], 'unresolved': []}
-        base = module.project(self.graph, self.root)
-        self.assertEqual(len(base['edges']), 1)  # Legacy edges must not be appended a second time.
-        self.assertEqual(base['graph']['root'], 'home')
-        self.assertEqual(base['alignment']['edges'][0]['source_refs'], ['edge', 'trace', 'effect'])
-        self.assertEqual(base['nodes'][1]['extra']['source_refs'], ['home', 'ui:home'])
-        utg, _, _ = module.normalize_facts(base, self.root)
-        self.assertEqual(utg['links'][0]['id'], 'transition:stable')
-        self.assertEqual(utg['links'][0]['status'], 'static-only')
-        self.graph['interactionGraph']['transitions'][0]['conditions'] = [
-            {'expression': 'loggedIn', 'branch': 'else', 'group': 'login'}]
-        guarded = module.project(self.graph, self.root)
-        self.assertEqual(guarded['edges'][0]['guard']['text'], '!(loggedIn)')
-        self.assertEqual(guarded['edges'][0]['guard']['conditions'][0]['branch'], 'else')
-        self.graph['interactionGraph']['transitions'][0]['conditions'] = []
-        from build_page_json import build_page_plan
-        plan = build_page_plan(utg, module.build_click_paths(utg), utg_path='utg.json', click_paths_path='click_paths.json')
-        self.assertFalse(any(p['capture'] for p in plan['pages']))
-        # Multiple declared launch pages use a non-capturable logical boundary.
-        self.graph['interactionGraph']['entries'].append({'id': 'second-launch', 'kind': 'app-launch',
-            'surfaceIds': ['detail'], 'resolution': 'resolved', 'launch': {'action': 'start-activity', 'component': 'demo/demo.DetailActivity'}})
-        base = module.project(self.graph, self.root)
-        self.assertEqual(base['graph']['root'], 'utg:entry-root')
-        detail = next(n for n in base['nodes'] if n['id'] == 'detail')
-        detail['expected'] = {'text_any': ['Detail']}
-        utg, _, _ = module.normalize_facts(base, self.root)
-        paths = module.build_click_paths(utg)
-        plan = build_page_plan(utg, paths, utg_path='utg.json', click_paths_path='click_paths.json')
-        self.assertFalse(next(p for p in plan['pages'] if p['node_id'] == 'utg:entry-root')['capture'])
-        page = next(p for p in plan['pages'] if p['node_id'] == 'detail')
-        self.assertTrue(page['capture'])
-        self.assertEqual(page['steps'][-1]['component'], 'demo/demo.DetailActivity')
-        self.graph['interactionGraph']['entries'][-1].pop('launch')
-        utg, _, _ = module.normalize_facts(module.project(self.graph, self.root), self.root)
-        plan = build_page_plan(utg, module.build_click_paths(utg), utg_path='utg.json', click_paths_path='click_paths.json')
-        self.assertFalse(next(p for p in plan['pages'] if p['node_id'] == 'detail')['capture'])
-        self.graph['interactionGraph']['entries'][-1].update(kind='deep-link', launch={'action': 'deep-link', 'uri': 'demo://app/detail'})
-        base = module.project(self.graph, self.root)
-        next(n for n in base['nodes'] if n['id'] == 'detail')['expected'] = {'text_any': ['Detail']}
-        # Retain every source-proven edge: the executable entry must win over
-        # the ordinary navigation whose control lacks a replay selector.
-        self.assertTrue(any(e['id'] == 'transition:stable' for e in base['edges']))
-        utg, _, _ = module.normalize_facts(base, self.root)
-        plan = build_page_plan(utg, module.build_click_paths(utg), utg_path='utg.json', click_paths_path='click_paths.json')
-        page = next(p for p in plan['pages'] if p['node_id'] == 'detail')
-        self.assertTrue(page['capture'])
-        self.assertEqual(page['steps'][-1]['action'], 'deep-link')
-        self.assertEqual(page['steps'][-1]['label'], 'demo://app/detail')
-
-    def test_source_selector_candidates_do_not_guess_test_tag_resource_ids(self):
-        self.graph['interactionGraph'] = {'schemaVersion': 1,
-            'surfaces': [{'id': identity, 'name': identity, 'kind': kind, 'sourceRefs': [identity],
-                          'hostSurfaceIds': [], 'evidence': [self.ref], 'presentation': 'screen'}
-                         for identity, kind in [('home', 'activity'), ('detail', 'compose')]],
-            'controlBindings': [{'id': 'binding', 'controlRef': 'button', 'surfaceId': 'home',
-                                 'evidence': [self.ref], 'selectorCandidates': []}],
-            'entries': [{'id': 'launch', 'kind': 'app-launch', 'surfaceIds': ['home'], 'resolution': 'resolved'},
-                        {'id': 'click', 'kind': 'ui-action', 'sourceRef': 'button', 'surfaceIds': ['home'],
-                         'event': 'onClick', 'resolution': 'resolved'}],
-            'transitions': [{'id': 'navigate', 'sourceSurfaceId': 'home', 'actionRef': 'click',
-                             'target': {'kind': 'internal', 'surfaceId': 'detail'}, 'operation': 'navigate',
-                             'resolution': 'resolved', 'evidence': [self.ref], 'supportingRefs': ['click']}],
-            'unresolved': []}
-        binding = self.graph['interactionGraph']['controlBindings'][0]
-        from build_page_json import build_page_plan
-        for kind, ready in [('resource-id', True), ('test-tag', False)]:
-            binding['selectorCandidates'] = [{'kind': kind, 'value': 'demo:id/open', 'evidence': [self.ref]}]
-            base = module.project(self.graph, self.root)
-            next(node for node in base['nodes'] if node['id'] == 'detail')['expected'] = {'text_any': ['Detail']}
-            utg, _, _ = module.normalize_facts(base, self.root)
-            page = next(page for page in build_page_plan(utg, module.build_click_paths(utg),
-                utg_path='utg.json', click_paths_path='click_paths.json')['pages'] if page['node_id'] == 'detail')
-            self.assertEqual(page['capture'], ready)
-            if ready:
-                self.assertEqual(page['steps'][-1]['selector'], {'resource_id': 'demo:id/open'})
-            else:
-                self.assertNotIn('selector', page['steps'][-1])
-
-    def test_sheet_projection_and_external_entry_operand_boundary(self):
-        self.graph['interactionGraph'] = {'schemaVersion': 1,
-            'surfaces': [{'id': 'home', 'name': 'Home', 'kind': 'activity', 'sourceRefs': ['home'],
-                          'hostSurfaceIds': [], 'evidence': [self.ref], 'presentation': 'screen'},
-                         {'id': 'sheet', 'name': 'Sheet', 'kind': 'bottom-sheet', 'sourceRefs': ['sheet'],
-                          'hostSurfaceIds': ['home'], 'evidence': [self.ref], 'presentation': 'overlay'}],
-            'controlBindings': [],
-            'entries': [{'id': 'launch', 'kind': 'app-launch', 'surfaceIds': ['home'], 'resolution': 'resolved',
-                         'launch': {'action': 'start-activity', 'component': 'demo/demo.Home'}},
-                        {'id': 'share', 'kind': 'external-entry', 'surfaceIds': ['sheet'],
-                         'resolution': 'resolved', 'evidence': [self.ref]}],
-            'transitions': [{'id': 'show-sheet', 'sourceSurfaceId': 'home',
-                             'target': {'kind': 'internal', 'surfaceId': 'sheet'}, 'operation': 'show',
-                             'resolution': 'resolved', 'evidence': [self.ref], 'supportingRefs': ['trigger']}],
-            'unresolved': []}
-        base = module.project(self.graph, self.root)
-        sheet = next(node for node in base['nodes'] if node['id'] == 'sheet')
-        self.assertEqual(sheet['kind'], 'sheet')
-        self.assertEqual(sheet['extra']['host_surface_ids'], ['home'])
-        self.assertTrue(any(issue['subject'] == 'share' and 'operands' in issue['reason'] for issue in base['unresolved']))
-        sheet['expected'] = {'text_any': ['Sheet']}
-        utg, _, _ = module.normalize_facts(base, self.root)
-        from build_page_json import build_page_plan
-        plan = build_page_plan(utg, module.build_click_paths(utg), utg_path='utg.json', click_paths_path='click_paths.json')
-        self.assertFalse(next(page for page in plan['pages'] if page['node_id'] == 'sheet')['capture'])
-        self.assertTrue(any(edge['id'] == 'show-sheet' for edge in utg['links']))
-
-    def test_manifest_exact_declaration_and_entry(self):
-        (self.root / 'AndroidManifest.xml').write_text(
-            '<manifest xmlns:android="http://schemas.android.com/apk/res/android">\n'
-            '<application><activity android:name=".MainActivity"/></application>\n</manifest>', encoding='utf-8')
-        self.graph['nodes'][0]['platformRef'] = {'file': 'AndroidManifest.xml', 'symbol': '.MainActivity'}
-        self.graph['nodes'].append({'id': 'manifest-entry', 'kind': 'AppEntry',
-                                    'subtype': 'launcher-activity', 'attrs': {'screen': 'home'}})
-        self.graph['entryPoints'] = []
-        self.graph['edges'][0]['attrs']['evidence'] = self.ref  # Actual producer also emits a single ref.
-        base = module.project(self.graph, self.root)
-        self.assertEqual(base['graph']['root'], 'home')
-        self.assertEqual(next(n for n in base['nodes'] if n['id'] == 'home')['declared_at'], 'AndroidManifest.xml:2')
-
-    def test_ai_edge_guard_and_capture_readiness(self):
-        node = copy.deepcopy(next(n for n in self.base['nodes'] if n['id'] == 'fragment'))
-        node['expected'] = {'text_any': ['Fragment']}
-        edge = {'id': 'ai:fragment', 'source': 'home', 'target': 'fragment',
-                'mechanism': 'fragment-transaction', 'trigger': 'Screen.kt:1', 'confidence': 0.9,
-                'guard': {'kind': 'login', 'text': 'requires login'},
-                'args': {'action': 'tap', 'selector': {'text': 'Fragment'}}}
-        merged = module.apply_discoveries(self.base, self.discoveries([
-            self.operation('node', 'replace', 'fragment', node),
-            self.operation('edge', 'add', 'ai:fragment', edge)]), self.root, self.fingerprint)
-        utg, _, _ = module.normalize_facts(merged, self.root)
-        paths = module.build_click_paths(utg)
-        from build_page_json import build_page_plan
-        plan = build_page_plan(utg, paths, utg_path='utg.json', click_paths_path='click_paths.json')
-        page = next(n for n in plan['pages'] if n['node_id'] == 'fragment')
-        self.assertTrue(page['capture'])
-        self.assertEqual(page['steps'][-1]['guard']['kind'], 'login')
-        next(e for e in merged['edges'] if e['id'] == 'ai:fragment')['args'] = {'nl_hint': 'click Fragment'}
-        utg, _, _ = module.normalize_facts(merged, self.root)
-        plan = build_page_plan(utg, module.build_click_paths(utg), utg_path='utg.json', click_paths_path='click_paths.json')
-        self.assertFalse(next(n for n in plan['pages'] if n['node_id'] == 'fragment')['capture'])
-
-    def test_add_replace_exclude_audit(self):
-        node = copy.deepcopy(self.base['nodes'][0])
-        node.update(id='ai:new', label='New')
-        detail = copy.deepcopy(next(n for n in self.base['nodes'] if n['id'] == 'detail'))
-        detail['expected'] = {'text_any': ['Details']}
-        operations = [self.operation('node', 'add', 'ai:new', node),
-                      self.operation('node', 'replace', 'detail', detail),
-                      self.operation('edge', 'exclude', 'nav2')]
-        merged = module.apply_discoveries(self.base, self.discoveries(operations), self.root, self.fingerprint)
-        self.assertEqual(len(merged['graph']['discovery_audit']), 3)
-        self.assertEqual(len(self.base['edges']), 4)
-        self.assertEqual(next(n for n in merged['nodes'] if n['id'] == 'detail')['provenance'], 'ai-source-review')
-
-    def test_source_review_cannot_claim_runtime_verification(self):
-        node = copy.deepcopy(next(n for n in self.base['nodes'] if n['id'] == 'detail'))
-        node.update(status='runtime-verified', reached=True, screenshot='fake.png')
-        edge = copy.deepcopy(next(e for e in self.base['edges'] if e['id'] == 'nav2'))
-        edge.update(status='runtime-verified', reached=True)
-        merged = module.apply_discoveries(self.base, self.discoveries([
-            self.operation('node', 'replace', 'detail', node),
-            self.operation('edge', 'replace', 'nav2', edge)]), self.root, self.fingerprint)
-        utg, _, _ = module.normalize_facts(merged, self.root)
-        reviewed = [next(n for n in utg['nodes'] if n['id'] == 'detail'),
-                    next(e for e in utg['links'] if e['id'] == 'nav2')]
-        for item in reviewed:
-            self.assertEqual(item['status'], 'static-only')
-            self.assertEqual(item['provenance'], 'ai-source-review')
-            self.assertNotIn('reached', item)
-            self.assertNotIn('screenshot', item)
-        self.assertEqual(next(n for n in self.base['nodes'] if n['id'] == 'detail')['status'], 'static-only')
-
-    def test_resolved_findings_preserve_audit(self):
-        discoveries = self.discoveries()
-        discoveries['resolved_findings'] = [{'id': self.base['unresolved'][0]['id'],
-                                            'reason': 'verified boundary', 'evidence': 'Screen.kt:1'}]
-        merged = module.apply_discoveries(self.base, discoveries, self.root, self.fingerprint)
-        self.assertEqual(len(merged['unresolved']), len(self.base['unresolved']) - 1)
-        self.assertEqual(merged['graph']['resolved_findings'], discoveries['resolved_findings'])
-        discoveries['resolved_findings'][0]['id'] = 'unknown'
-        with self.assertRaises(module.UtgError):
-            module.apply_discoveries(self.base, discoveries, self.root, self.fingerprint)
-
-    def test_reject_invalid_stale_duplicate_and_dangling(self):
-        bad = self.discoveries()
-        bad['input_fingerprint'] = 'old'
-        with self.assertRaises(module.UtgError):
-            module.apply_discoveries(self.base, bad, self.root, self.fingerprint)
-        for operations in [[self.operation('node', 'exclude', 'home')],
-                           [self.operation('edge', 'exclude', 'nav1')] * 2,
-                           [self.operation('node', 'add', 'home', self.base['nodes'][0])]]:
-            with self.assertRaises(module.UtgError):
-                module.apply_discoveries(self.base, self.discoveries(operations), self.root, self.fingerprint)
-        op = self.operation('edge', 'exclude', 'nav1')
-        op['evidence'] = 'Screen.kt:99'
-        with self.assertRaises(module.UtgError):
-            module.apply_discoveries(self.base, self.discoveries([op]), self.root, self.fingerprint)
-        old = module.source_digest(self.root)
-        (self.root / 'Screen.kt').write_text('changed\n')
-        self.assertNotEqual(old, module.source_digest(self.root))
-
-    def test_ambiguous_root_not_guessed(self):
-        self.graph['entryPoints'].append({'id': 'launch2', 'kind': 'app-launch', 'sourceRef': 'detail', 'resolution': 'resolved'})
-        self.assertEqual(module.project(self.graph, self.root)['graph']['root'], '')
-
-    def test_end_to_end_determinism_offline_and_readonly(self):
-        graph_path = Path(self.temp.name) / 'graph.json'
-        graph_path.write_text(json.dumps(self.graph), encoding='utf-8')
-        original = graph_path.read_bytes()
-        ws = Path(self.temp.name) / 'utg'
-        command = [sys.executable, str(SCRIPT), '--project-root', str(self.root), '--appgraph', str(graph_path), '--workspace', str(ws)]
-        subprocess.run(command, check=True, capture_output=True)
-        review = json.loads((ws / 'review-worklist.json').read_text(encoding='utf-8'))
-        self.assertEqual(review['navigation_review']['status'], 'pending')
-        self.assertEqual(review['navigation_review']['total_findings'], 1)
-        self.assertEqual(len(review['navigation_candidates']), 4)
-        outputs = ['utg.json', 'click_paths.json', 'page.json', 'utg.html']
-        before = {n: (ws / n).read_bytes() for n in outputs}
-        subprocess.run(command + ['--force'], check=True, capture_output=True)
-        self.assertEqual(before, {n: (ws / n).read_bytes() for n in outputs})
-        self.assertEqual(graph_path.read_bytes(), original)
-        plan = json.loads((ws / 'page.json').read_text())
-        self.assertFalse(any(n['capture'] for n in plan['pages']))
-        html = (ws / 'utg.html').read_text(encoding='utf-8')
-        self.assertNotIn('<script src=', html)
-        self.assertIn('source-filter', html)
-        for i, script in enumerate(re.findall(r'<script>(.*?)</script>', html, re.S)):
-            js = Path(self.temp.name) / f'html-{i}.js'
-            js.write_text(script, encoding='utf-8')
-            result = subprocess.run(['node', '--check', str(js)], capture_output=True, text=True)
-            self.assertEqual(result.returncode, 0, result.stderr)
-        # The existing TS consumer validates this static plan without ADB.
-        result = subprocess.run(['node', str(module.SHARED / 'capture_from_page_json.ts'),
-            '--page-json', str(ws / 'page.json'), '--output-workspace', str(ws / 'captures'), '--dry-run'],
-            capture_output=True, text=True)
-        self.assertEqual(result.returncode, 0, result.stderr)
-        self.assertFalse((ws / 'captures').exists())
-
-
-if __name__ == '__main__':
-    unittest.main()
+import copy
+import importlib.util
+import json
+import re
+import subprocess
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+SCRIPT = Path(__file__).resolve().parents[1] / 'scripts' / 'generate.py'
+spec = importlib.util.spec_from_file_location('static_generate', SCRIPT)
+module = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(module)
+
+
+class StaticTests(unittest.TestCase):
+    def setUp(self):
+        self.temp = tempfile.TemporaryDirectory()
+        self.addCleanup(self.temp.cleanup)
+        self.root = Path(self.temp.name) / 'source'
+        self.root.mkdir()
+        (self.root / 'Screen.kt').write_text('fun home() {}\nfun detail() {}\nfun dialog() {}\n', encoding='utf-8')
+        self.ref = {'file': 'Screen.kt', 'line': 1}
+        self.graph = {'schemaVersion': 1, 'platform': 'android', 'app': {'name': 'Demo', 'packageName': 'demo'},
+            'nodes': [{'id': identity, 'kind': 'Screen', 'name': 'SameName', 'platform': 'android',
+                       'subtype': kind, 'platformRef': self.ref}
+                      for identity, kind in [('home', 'activity'), ('detail', 'compose'), ('dialog', 'dialog'), ('fragment', 'fragment')]],
+            'edges': [{'id': identity, 'kind': 'navigates_to', 'from': source, 'to': target,
+                       'attrs': {'evidence': [self.ref]}, 'confidence': 1}
+                      for identity, source, target in [('nav1', 'home', 'detail'), ('nav2', 'home', 'detail'),
+                                                        ('back', 'detail', 'home'), ('external', 'home', 'outside')]],
+            'entryPoints': [{'id': 'launch', 'kind': 'app-launch', 'sourceRef': 'home', 'resolution': 'resolved'},
+                            {'id': 'click', 'kind': 'ui-action', 'sourceRef': 'button', 'ownerRef': 'home', 'resolution': 'resolved'}],
+            'uiComponents': {'nodes': [{'id': 'button', 'kind': 'control', 'name': 'Button', 'evidence': [self.ref]}],
+                             'edges': [{'id': 'owns', 'kind': 'contains', 'from': 'home', 'to': 'button'}]},
+            'callTraces': [{'id': 'trace', 'entryPointId': 'click', 'effects': [
+                {'id': 'effect', 'kind': 'navigation', 'targetRefs': ['dialog'], 'origin': self.ref}]}]}
+        self.base = module.project(self.graph, self.root)
+        self.fingerprint = module.digest({'appgraph': self.graph, 'source': module.source_digest(self.root)})
+
+    def discoveries(self, operations=None):
+        return {'schema_version': 'd2h-utg-discoveries/v1', 'input_fingerprint': self.fingerprint,
+                'operations': operations or [], 'unresolved': []}
+
+    def operation(self, kind, op, identity, value=None):
+        return {'kind': kind, 'op': op, 'id': identity, 'reason': 'source verified',
+                'evidence': 'Screen.kt:1', 'value': value}
+
+    def test_projection(self):
+        self.assertEqual(len(self.base['nodes']), 4)
+        self.assertEqual(len(self.base['edges']), 4)
+        self.assertEqual(self.base['graph']['root'], 'home')
+        home = next(n for n in self.base['nodes'] if n['id'] == 'home')
+        self.assertEqual(home['widgets'][0]['id'], 'button')
+        self.assertTrue(any(x['subject'] == 'external' for x in self.base['unresolved']))
+
+    def test_source_page_coalesces_manifest_and_synthetic_compose_screen(self):
+        graph = {'schemaVersion': 1, 'platform': 'android', 'app': {'name': 'Demo'},
+            'nodes': [
+                {'id': 'manifest', 'kind': 'Screen', 'name': 'MainActivity', 'subtype': 'activity',
+                 'platformRef': {'file': 'missing.xml', 'symbol': '.MainActivity'}},
+                {'id': 'entry', 'kind': 'AppEntry', 'subtype': 'launcher-activity',
+                 'attrs': {'screen': 'manifest'}},
+                {'id': 'route', 'kind': 'Screen', 'name': 'SplashRoute', 'subtype': 'compose',
+                 'matchKey': 'screen:splashroute', 'platformRef': {'file': 'Screen.kt'}},
+                {'id': 'synthetic', 'kind': 'Screen', 'name': 'SplashRoute', 'subtype': 'compose',
+                 'matchKey': 'screen:splashroute:compose', 'platformRef': self.ref,
+                 'attrs': {'classificationRule': 'compose.destination.register'}}],
+            'uiComponents': {'nodes': [
+                {'id': 'activity-page', 'kind': 'page', 'name': 'MainActivity', 'subtype': 'activity',
+                 'evidence': [self.ref], 'attrs': {'screenId': 'manifest'}},
+                {'id': 'route-page', 'kind': 'page', 'name': 'SplashRoute', 'subtype': 'compose',
+                 'evidence': [self.ref], 'attrs': {'screenId': 'route',
+                     'screenMatchKey': 'screen:splashroute', 'classificationRule': 'COMPOSE-SCREEN-AST'}}],
+                'edges': []}, 'edges': [{'id': 'nav', 'kind': 'navigates_to',
+                    'from': 'manifest', 'to': 'synthetic', 'attrs': {'evidence': [self.ref]}}],
+            'entryPoints': [], 'callTraces': []}
+        base = module.project(graph, self.root)
+        self.assertEqual({n['id'] for n in base['nodes']}, {'activity-page', 'route-page'})
+        self.assertEqual(base['graph']['root'], 'activity-page')
+        self.assertEqual([(e['source'], e['target']) for e in base['edges']],
+                         [('activity-page', 'route-page')])
+
+    def test_interaction_projection_preserves_stable_ids_and_alignment(self):
+        self.graph['interactionGraph'] = {'schemaVersion': 1,
+            'surfaces': [{'id': identity, 'name': identity, 'kind': kind, 'sourceRefs': [identity, 'ui:' + identity],
+                          'hostSurfaceIds': [], 'evidence': [self.ref], 'presentation': 'screen'}
+                         for identity, kind in [('home', 'activity'), ('detail', 'compose')]],
+            'controlBindings': [{'id': 'binding:button:home', 'controlRef': 'button', 'surfaceId': 'home',
+                                 'evidence': [self.ref], 'selectorCandidates': []}],
+            'entries': [{'id': 'launch', 'kind': 'app-launch', 'surfaceIds': ['home'], 'resolution': 'resolved'}],
+            'transitions': [{'id': 'transition:stable', 'sourceSurfaceId': 'home',
+                             'target': {'kind': 'internal', 'surfaceId': 'detail'}, 'operation': 'navigate',
+                             'resolution': 'resolved', 'evidence': [self.ref], 'supportingRefs': ['edge', 'trace', 'effect'],
+                             'actionRef': 'click', 'conditions': []}], 'unresolved': []}
+        base = module.project(self.graph, self.root)
+        self.assertEqual(len(base['edges']), 1)  # Legacy edges must not be appended a second time.
+        self.assertEqual(base['graph']['root'], 'home')
+        self.assertEqual(base['alignment']['edges'][0]['source_refs'], ['edge', 'trace', 'effect'])
+        self.assertEqual(base['nodes'][1]['extra']['source_refs'], ['home', 'ui:home'])
+        utg, _, _ = module.normalize_facts(base, self.root)
+        self.assertEqual(utg['links'][0]['id'], 'transition:stable')
+        self.assertEqual(utg['links'][0]['status'], 'static-only')
+        self.graph['interactionGraph']['transitions'][0]['conditions'] = [
+            {'expression': 'loggedIn', 'branch': 'else', 'group': 'login'}]
+        guarded = module.project(self.graph, self.root)
+        self.assertEqual(guarded['edges'][0]['guard']['text'], '!(loggedIn)')
+        self.assertEqual(guarded['edges'][0]['guard']['conditions'][0]['branch'], 'else')
+        self.graph['interactionGraph']['transitions'][0]['conditions'] = []
+        from build_page_json import build_page_plan
+        plan = build_page_plan(utg, module.build_click_paths(utg), utg_path='utg.json', click_paths_path='click_paths.json')
+        self.assertFalse(any(p['capture'] for p in plan['pages']))
+        # Multiple declared launch pages use a non-capturable logical boundary.
+        self.graph['interactionGraph']['entries'].append({'id': 'second-launch', 'kind': 'app-launch',
+            'surfaceIds': ['detail'], 'resolution': 'resolved', 'launch': {'action': 'start-activity', 'component': 'demo/demo.DetailActivity'}})
+        base = module.project(self.graph, self.root)
+        self.assertEqual(base['graph']['root'], 'utg:entry-root')
+        detail = next(n for n in base['nodes'] if n['id'] == 'detail')
+        detail['expected'] = {'text_any': ['Detail']}
+        utg, _, _ = module.normalize_facts(base, self.root)
+        paths = module.build_click_paths(utg)
+        plan = build_page_plan(utg, paths, utg_path='utg.json', click_paths_path='click_paths.json')
+        self.assertFalse(next(p for p in plan['pages'] if p['node_id'] == 'utg:entry-root')['capture'])
+        page = next(p for p in plan['pages'] if p['node_id'] == 'detail')
+        self.assertTrue(page['capture'])
+        self.assertEqual(page['steps'][-1]['component'], 'demo/demo.DetailActivity')
+        self.graph['interactionGraph']['entries'][-1].pop('launch')
+        utg, _, _ = module.normalize_facts(module.project(self.graph, self.root), self.root)
+        plan = build_page_plan(utg, module.build_click_paths(utg), utg_path='utg.json', click_paths_path='click_paths.json')
+        self.assertFalse(next(p for p in plan['pages'] if p['node_id'] == 'detail')['capture'])
+        self.graph['interactionGraph']['entries'][-1].update(kind='deep-link', launch={'action': 'deep-link', 'uri': 'demo://app/detail'})
+        base = module.project(self.graph, self.root)
+        next(n for n in base['nodes'] if n['id'] == 'detail')['expected'] = {'text_any': ['Detail']}
+        # Retain every source-proven edge: the executable entry must win over
+        # the ordinary navigation whose control lacks a replay selector.
+        self.assertTrue(any(e['id'] == 'transition:stable' for e in base['edges']))
+        utg, _, _ = module.normalize_facts(base, self.root)
+        plan = build_page_plan(utg, module.build_click_paths(utg), utg_path='utg.json', click_paths_path='click_paths.json')
+        page = next(p for p in plan['pages'] if p['node_id'] == 'detail')
+        self.assertTrue(page['capture'])
+        self.assertEqual(page['steps'][-1]['action'], 'deep-link')
+        self.assertEqual(page['steps'][-1]['label'], 'demo://app/detail')
+
+    def test_source_selector_candidates_do_not_guess_test_tag_resource_ids(self):
+        self.graph['interactionGraph'] = {'schemaVersion': 1,
+            'surfaces': [{'id': identity, 'name': identity, 'kind': kind, 'sourceRefs': [identity],
+                          'hostSurfaceIds': [], 'evidence': [self.ref], 'presentation': 'screen'}
+                         for identity, kind in [('home', 'activity'), ('detail', 'compose')]],
+            'controlBindings': [{'id': 'binding', 'controlRef': 'button', 'surfaceId': 'home',
+                                 'evidence': [self.ref], 'selectorCandidates': []}],
+            'entries': [{'id': 'launch', 'kind': 'app-launch', 'surfaceIds': ['home'], 'resolution': 'resolved'},
+                        {'id': 'click', 'kind': 'ui-action', 'sourceRef': 'button', 'surfaceIds': ['home'],
+                         'event': 'onClick', 'resolution': 'resolved'}],
+            'transitions': [{'id': 'navigate', 'sourceSurfaceId': 'home', 'actionRef': 'click',
+                             'target': {'kind': 'internal', 'surfaceId': 'detail'}, 'operation': 'navigate',
+                             'resolution': 'resolved', 'evidence': [self.ref], 'supportingRefs': ['click']}],
+            'unresolved': []}
+        binding = self.graph['interactionGraph']['controlBindings'][0]
+        from build_page_json import build_page_plan
+        for kind, ready in [('resource-id', True), ('test-tag', False)]:
+            binding['selectorCandidates'] = [{'kind': kind, 'value': 'demo:id/open', 'evidence': [self.ref]}]
+            base = module.project(self.graph, self.root)
+            next(node for node in base['nodes'] if node['id'] == 'detail')['expected'] = {'text_any': ['Detail']}
+            utg, _, _ = module.normalize_facts(base, self.root)
+            page = next(page for page in build_page_plan(utg, module.build_click_paths(utg),
+                utg_path='utg.json', click_paths_path='click_paths.json')['pages'] if page['node_id'] == 'detail')
+            self.assertEqual(page['capture'], ready)
+            if ready:
+                self.assertEqual(page['steps'][-1]['selector'], {'resource_id': 'demo:id/open'})
+            else:
+                self.assertNotIn('selector', page['steps'][-1])
+
+    def test_sheet_projection_and_external_entry_operand_boundary(self):
+        self.graph['interactionGraph'] = {'schemaVersion': 1,
+            'surfaces': [{'id': 'home', 'name': 'Home', 'kind': 'activity', 'sourceRefs': ['home'],
+                          'hostSurfaceIds': [], 'evidence': [self.ref], 'presentation': 'screen'},
+                         {'id': 'sheet', 'name': 'Sheet', 'kind': 'bottom-sheet', 'sourceRefs': ['sheet'],
+                          'hostSurfaceIds': ['home'], 'evidence': [self.ref], 'presentation': 'overlay'}],
+            'controlBindings': [],
+            'entries': [{'id': 'launch', 'kind': 'app-launch', 'surfaceIds': ['home'], 'resolution': 'resolved',
+                         'launch': {'action': 'start-activity', 'component': 'demo/demo.Home'}},
+                        {'id': 'share', 'kind': 'external-entry', 'surfaceIds': ['sheet'],
+                         'resolution': 'resolved', 'evidence': [self.ref]}],
+            'transitions': [{'id': 'show-sheet', 'sourceSurfaceId': 'home',
+                             'target': {'kind': 'internal', 'surfaceId': 'sheet'}, 'operation': 'show',
+                             'resolution': 'resolved', 'evidence': [self.ref], 'supportingRefs': ['trigger']}],
+            'unresolved': []}
+        base = module.project(self.graph, self.root)
+        sheet = next(node for node in base['nodes'] if node['id'] == 'sheet')
+        self.assertEqual(sheet['kind'], 'sheet')
+        self.assertEqual(sheet['extra']['host_surface_ids'], ['home'])
+        self.assertTrue(any(issue['subject'] == 'share' and 'operands' in issue['reason'] for issue in base['unresolved']))
+        sheet['expected'] = {'text_any': ['Sheet']}
+        utg, _, _ = module.normalize_facts(base, self.root)
+        from build_page_json import build_page_plan
+        plan = build_page_plan(utg, module.build_click_paths(utg), utg_path='utg.json', click_paths_path='click_paths.json')
+        self.assertFalse(next(page for page in plan['pages'] if page['node_id'] == 'sheet')['capture'])
+        self.assertTrue(any(edge['id'] == 'show-sheet' for edge in utg['links']))
+
+    def test_manifest_exact_declaration_and_entry(self):
+        (self.root / 'AndroidManifest.xml').write_text(
+            '<manifest xmlns:android="http://schemas.android.com/apk/res/android">\n'
+            '<application><activity android:name=".MainActivity"/></application>\n</manifest>', encoding='utf-8')
+        self.graph['nodes'][0]['platformRef'] = {'file': 'AndroidManifest.xml', 'symbol': '.MainActivity'}
+        self.graph['nodes'].append({'id': 'manifest-entry', 'kind': 'AppEntry',
+                                    'subtype': 'launcher-activity', 'attrs': {'screen': 'home'}})
+        self.graph['entryPoints'] = []
+        self.graph['edges'][0]['attrs']['evidence'] = self.ref  # Actual producer also emits a single ref.
+        base = module.project(self.graph, self.root)
+        self.assertEqual(base['graph']['root'], 'home')
+        self.assertEqual(next(n for n in base['nodes'] if n['id'] == 'home')['declared_at'], 'AndroidManifest.xml:2')
+
+    def test_ai_edge_guard_and_capture_readiness(self):
+        node = copy.deepcopy(next(n for n in self.base['nodes'] if n['id'] == 'fragment'))
+        node['expected'] = {'text_any': ['Fragment']}
+        edge = {'id': 'ai:fragment', 'source': 'home', 'target': 'fragment',
+                'mechanism': 'fragment-transaction', 'trigger': 'Screen.kt:1', 'confidence': 0.9,
+                'guard': {'kind': 'login', 'text': 'requires login'},
+                'args': {'action': 'tap', 'selector': {'text': 'Fragment'}}}
+        merged = module.apply_discoveries(self.base, self.discoveries([
+            self.operation('node', 'replace', 'fragment', node),
+            self.operation('edge', 'add', 'ai:fragment', edge)]), self.root, self.fingerprint)
+        utg, _, _ = module.normalize_facts(merged, self.root)
+        paths = module.build_click_paths(utg)
+        from build_page_json import build_page_plan
+        plan = build_page_plan(utg, paths, utg_path='utg.json', click_paths_path='click_paths.json')
+        page = next(n for n in plan['pages'] if n['node_id'] == 'fragment')
+        self.assertTrue(page['capture'])
+        self.assertEqual(page['steps'][-1]['guard']['kind'], 'login')
+        next(e for e in merged['edges'] if e['id'] == 'ai:fragment')['args'] = {'nl_hint': 'click Fragment'}
+        utg, _, _ = module.normalize_facts(merged, self.root)
+        plan = build_page_plan(utg, module.build_click_paths(utg), utg_path='utg.json', click_paths_path='click_paths.json')
+        self.assertFalse(next(n for n in plan['pages'] if n['node_id'] == 'fragment')['capture'])
+
+    def test_add_replace_exclude_audit(self):
+        node = copy.deepcopy(self.base['nodes'][0])
+        node.update(id='ai:new', label='New')
+        detail = copy.deepcopy(next(n for n in self.base['nodes'] if n['id'] == 'detail'))
+        detail['expected'] = {'text_any': ['Details']}
+        operations = [self.operation('node', 'add', 'ai:new', node),
+                      self.operation('node', 'replace', 'detail', detail),
+                      self.operation('edge', 'exclude', 'nav2')]
+        merged = module.apply_discoveries(self.base, self.discoveries(operations), self.root, self.fingerprint)
+        self.assertEqual(len(merged['graph']['discovery_audit']), 3)
+        self.assertEqual(len(self.base['edges']), 4)
+        self.assertEqual(next(n for n in merged['nodes'] if n['id'] == 'detail')['provenance'], 'ai-source-review')
+
+    def test_source_review_cannot_claim_runtime_verification(self):
+        node = copy.deepcopy(next(n for n in self.base['nodes'] if n['id'] == 'detail'))
+        node.update(status='runtime-verified', reached=True, screenshot='fake.png')
+        edge = copy.deepcopy(next(e for e in self.base['edges'] if e['id'] == 'nav2'))
+        edge.update(status='runtime-verified', reached=True)
+        merged = module.apply_discoveries(self.base, self.discoveries([
+            self.operation('node', 'replace', 'detail', node),
+            self.operation('edge', 'replace', 'nav2', edge)]), self.root, self.fingerprint)
+        utg, _, _ = module.normalize_facts(merged, self.root)
+        reviewed = [next(n for n in utg['nodes'] if n['id'] == 'detail'),
+                    next(e for e in utg['links'] if e['id'] == 'nav2')]
+        for item in reviewed:
+            self.assertEqual(item['status'], 'static-only')
+            self.assertEqual(item['provenance'], 'ai-source-review')
+            self.assertNotIn('reached', item)
+            self.assertNotIn('screenshot', item)
+        self.assertEqual(next(n for n in self.base['nodes'] if n['id'] == 'detail')['status'], 'static-only')
+
+    def test_resolved_findings_preserve_audit(self):
+        discoveries = self.discoveries()
+        discoveries['resolved_findings'] = [{'id': self.base['unresolved'][0]['id'],
+                                            'reason': 'verified boundary', 'evidence': 'Screen.kt:1'}]
+        merged = module.apply_discoveries(self.base, discoveries, self.root, self.fingerprint)
+        self.assertEqual(len(merged['unresolved']), len(self.base['unresolved']) - 1)
+        self.assertEqual(merged['graph']['resolved_findings'], discoveries['resolved_findings'])
+        discoveries['resolved_findings'][0]['id'] = 'unknown'
+        with self.assertRaises(module.UtgError):
+            module.apply_discoveries(self.base, discoveries, self.root, self.fingerprint)
+
+    def test_reject_invalid_stale_duplicate_and_dangling(self):
+        bad = self.discoveries()
+        bad['input_fingerprint'] = 'old'
+        with self.assertRaises(module.UtgError):
+            module.apply_discoveries(self.base, bad, self.root, self.fingerprint)
+        for operations in [[self.operation('node', 'exclude', 'home')],
+                           [self.operation('edge', 'exclude', 'nav1')] * 2,
+                           [self.operation('node', 'add', 'home', self.base['nodes'][0])]]:
+            with self.assertRaises(module.UtgError):
+                module.apply_discoveries(self.base, self.discoveries(operations), self.root, self.fingerprint)
+        op = self.operation('edge', 'exclude', 'nav1')
+        op['evidence'] = 'Screen.kt:99'
+        with self.assertRaises(module.UtgError):
+            module.apply_discoveries(self.base, self.discoveries([op]), self.root, self.fingerprint)
+        old = module.source_digest(self.root)
+        (self.root / 'Screen.kt').write_text('changed\n')
+        self.assertNotEqual(old, module.source_digest(self.root))
+
+    def test_ambiguous_root_not_guessed(self):
+        self.graph['entryPoints'].append({'id': 'launch2', 'kind': 'app-launch', 'sourceRef': 'detail', 'resolution': 'resolved'})
+        self.assertEqual(module.project(self.graph, self.root)['graph']['root'], '')
+
+    def test_end_to_end_determinism_offline_and_readonly(self):
+        graph_path = Path(self.temp.name) / 'graph.json'
+        graph_path.write_text(json.dumps(self.graph), encoding='utf-8')
+        original = graph_path.read_bytes()
+        ws = Path(self.temp.name) / 'utg'
+        command = [sys.executable, str(SCRIPT), '--project-root', str(self.root), '--appgraph', str(graph_path), '--workspace', str(ws)]
+        subprocess.run(command, check=True, capture_output=True)
+        review = json.loads((ws / 'review-worklist.json').read_text(encoding='utf-8'))
+        self.assertEqual(review['navigation_review']['status'], 'pending')
+        self.assertEqual(review['navigation_review']['total_findings'], 1)
+        self.assertEqual(len(review['navigation_candidates']), 4)
+        outputs = ['utg.json', 'click_paths.json', 'page.json', 'utg.html']
+        before = {n: (ws / n).read_bytes() for n in outputs}
+        subprocess.run(command + ['--force'], check=True, capture_output=True)
+        self.assertEqual(before, {n: (ws / n).read_bytes() for n in outputs})
+        self.assertEqual(graph_path.read_bytes(), original)
+        plan = json.loads((ws / 'page.json').read_text())
+        self.assertFalse(any(n['capture'] for n in plan['pages']))
+        html = (ws / 'utg.html').read_text(encoding='utf-8')
+        self.assertNotIn('<script src=', html)
+        self.assertIn('source-filter', html)
+        for i, script in enumerate(re.findall(r'<script>(.*?)</script>', html, re.S)):
+            js = Path(self.temp.name) / f'html-{i}.js'
+            js.write_text(script, encoding='utf-8')
+            result = subprocess.run(['node', '--check', str(js)], capture_output=True, text=True)
+            self.assertEqual(result.returncode, 0, result.stderr)
+        # The existing TS consumer validates this static plan without ADB.
+        result = subprocess.run(['node', str(module.SHARED / 'capture_from_page_json.ts'),
+            '--page-json', str(ws / 'page.json'), '--output-workspace', str(ws / 'captures'), '--dry-run'],
+            capture_output=True, text=True)
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertFalse((ws / 'captures').exists())
+
+
+if __name__ == '__main__':
+    unittest.main()