@antprofuse/saddle-islands-tools 0.0.0-stage → 0.1.4

package/tools/modules/minifish/harness/test_batch_plugin_groups.py

@@ -0,0 +1,97 @@
+import json
+import runpy
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+from unittest.mock import patch
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from batch_plugin_groups import plugin_groups as configured_groups
+def plugin_groups(*args, **options):
+    return configured_groups(*args, **options, source=Path('/alternate-fixture-source'))
+
+class PluginBatchIsolation(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.addCleanup(self.tmp.cleanup)
+        self.root = Path(self.tmp.name)
+        self.events = {'instances': [{'id': 'balance', 'events': []}]}
+
+    def case(self, ident, plugin=False):
+        package=self.root/ident; package.mkdir()
+        plan={'case': {'id': ident}}
+        if plugin: plan['plugin']={'events': self.events}
+        (package/'case.spec.mjs').write_text('// Generated\nexport const plan = '+json.dumps(plan)+';\ntest(plan.case.id, async () => {});\n')
+        return {'id':ident,'package':str(package)}
+
+    def mapping(self, mapping):
+        file=self.root/'map.json'; file.write_text(json.dumps(mapping)); return file
+
+    def test_every_case_exactly_once_and_no_cross_plan_shard(self):
+        rows=[self.case(str(i),i<9) for i in range(19)]
+        mapping={str(i):f'/artifacts/plan-{i%3}' for i in range(9)}
+        with patch('batch_plugin_groups.validate_plugin_artifact',return_value={'plan': self.events}) as validate:
+            groups=plugin_groups(rows,4,self.mapping(mapping))
+        self.assertEqual(validate.call_count,3)
+        flattened=[r['id'] for group,artifact in groups for r in group]
+        self.assertCountEqual(flattened,[r['id'] for r in rows])
+        self.assertEqual(len(flattened),len(set(flattened)))
+        for group,artifact in groups:
+            self.assertTrue(all(mapping.get(r['id'])==artifact for r in group))
+
+    def test_unknown_identity_and_invalid_artifact(self):
+        rows=[self.case('current',True)]
+        with self.assertRaises(ValueError):plugin_groups(rows,4,self.mapping({'stale':'/artifact'}))
+        with patch('batch_plugin_groups.validate_plugin_artifact',side_effect=ValueError('changed artifact SHA')):
+            with self.assertRaisesRegex(ValueError,'changed artifact SHA'):
+                plugin_groups(rows,4,self.mapping({'current':'/artifact'}))
+
+    def test_default_artifact_is_validated_and_retains_four_shards(self):
+        rows=[self.case(str(i),True) for i in range(12)]
+        with patch('batch_plugin_groups.validate_plugin_artifact',return_value={'plan': self.events}) as validate:
+            groups=plugin_groups(rows,4,default_artifact=Path('/existing'))
+        self.assertEqual(validate.call_count,1)
+        self.assertEqual(len(groups),4)
+        self.assertTrue(all(artifact=='/existing' for _,artifact in groups))
+
+    def test_all_missing_cases_reported_together(self):
+        rows=[self.case('first',True),self.case('ordinary'),self.case('second',True)]
+        with self.assertRaises(ValueError) as caught:plugin_groups(rows,4)
+        self.assertIn('first: Explicit',str(caught.exception))
+        self.assertIn('second: Explicit',str(caught.exception))
+        self.assertNotIn('ordinary:',str(caught.exception))
+
+    def test_wrong_plan_rejected_even_if_artifact_hashes_valid(self):
+        rows=[self.case('current',True)]
+        with patch('batch_plugin_groups.validate_plugin_artifact',return_value={'plan': {'instances':[{'id':'different'}]}}):
+            with self.assertRaisesRegex(ValueError,'plan must match'):
+                plugin_groups(rows,2,default_artifact='/artifact')
+
+    def test_no_plugin_needs_no_artifact(self):
+        row=self.case('ordinary')
+        self.assertEqual(plugin_groups([row],4),[([row],None)])
+
+    def test_unreadable_or_changed_plan_not_silently_treated_as_no_plugin(self):
+        row=self.case('changed')
+        (Path(row['package'])/'case.spec.mjs').write_text('throw new Error("must not execute");')
+        with self.assertRaisesRegex(ValueError,'Rebuild case package'):plugin_groups([row],4)
+
+    def test_real_batch_entry_stops_before_worker_and_report_creation(self):
+        rows=[self.case('missing',True)]
+        package=Path(rows[0]['package'])
+        for name in ['playwright.config.mjs','package.json','package-lock.json','node_modules/.bin/playwright']:
+            path=package/name;path.parent.mkdir(parents=True,exist_ok=True);path.write_text('{}')
+        manifest=self.root/'manifest.json';manifest.write_text(json.dumps(rows))
+        product=self.root/'product';product.mkdir()
+        modules=self.root/'modules';(modules/'.bin').mkdir(parents=True);(modules/'.bin/minifish2').touch()
+        report=self.root/'report'
+        source=self.root/'carrier';source.mkdir()
+        config=self.root/'config.json';config.write_text(json.dumps({'schemaVersion':1,'repositoryRoot':'product','pageRoute':'pages/alternate/index','pluginSource':'carrier','localComponentPackages':[]}))
+        argv=['run-batch.py','--project-root',str(self.root),'--config',str(config),'--manifest',str(manifest),'--product',str(product),'--node-modules',str(modules),'--report-dir',str(report)]
+        with patch.object(sys,'argv',argv),patch('concurrent.futures.ThreadPoolExecutor') as executor,patch('subprocess.Popen') as process:
+            with self.assertRaisesRegex(ValueError,'missing: Explicit compiled plugin artifact required'):
+                runpy.run_path(str(Path(__file__).resolve().with_name('run-batch.py')),run_name='__main__')
+        executor.assert_not_called();process.assert_not_called()
+        self.assertFalse(report.exists())
+
+if __name__=='__main__':unittest.main()

package/tools/modules/minifish/harness/test_batch_runner.py

@@ -0,0 +1,107 @@
+"""Infrastructure controls; these do not count as business coverage."""
+import importlib.util
+import json
+from pathlib import Path
+import signal
+import tempfile
+import unittest
+from batch_report import render_report
+from batch_cases import worker_certified, fingerprint, product_fingerprint, read_cases
+
+spec = importlib.util.spec_from_file_location('checker', Path(__file__).with_name('check-independent-batch.py'))
+checker = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(checker)
+
+
+class BatchControls(unittest.TestCase):
+    def test_receipt_failures_and_timeout_do_not_skip_next_case(self):
+        old = {sig: signal.getsignal(sig) for sig in (signal.SIGINT, signal.SIGTERM)}
+        try:
+            with tempfile.TemporaryDirectory() as tmp:
+                root = Path(tmp)
+                rows = []
+                for i, mode in enumerate(('pass', 'bad-json', 'wrong-id', 'timeout', 'pass')):
+                    package = root / str(i)
+                    binary = package / 'node_modules/.bin/playwright'
+                    binary.parent.mkdir(parents=True)
+                    receipt = dict(caseId=str(i), preparation='passed', target='passed', boundary='passed', cleanup='passed', errors=[])
+                    if mode == 'wrong-id': receipt['caseId'] = 'wrong'
+                    script = '#!/usr/bin/env python3\nimport os,json,time\nfrom pathlib import Path\n'
+                    if mode == 'timeout': script += 'time.sleep(30)\n'
+                    script += "p=Path(os.environ['MINIFISH_TEST_REPORT_DIR']);p.mkdir(parents=True)\n"
+                    script += f"(p/'case-result.json').write_text({('{' if mode == 'bad-json' else json.dumps(receipt))!r})\n"
+                    binary.write_text(script); binary.chmod(0o755)
+                    rows.append(dict(id=str(i), package=str(package)))
+                out = root / 'results'; out.mkdir()
+                self.assertEqual(checker.execute(rows, out, 1), 1)
+                results = json.loads((out / 'batch-results.json').read_text())
+                self.assertEqual([r['status'] for r in results], ['passed', 'failed', 'failed', 'failed', 'passed'])
+                self.assertEqual(results[3]['error'], 'case timeout')
+        finally:
+            for sig, handler in old.items(): signal.signal(sig, handler)
+
+    def test_cleanup_failure_not_excused_by_business_failure(self):
+        rows = [dict(id='a', status='passed'), dict(id='b', status='failed')]
+        lifecycle = dict(inputsVerified=True, children=[dict(returncode=0)])
+        network = dict(namespaceCleanup=dict(remaining=[]), children=[dict(returncode=1)])
+        self.assertTrue(worker_certified(rows, lifecycle, network, ['a', 'b'], 1))
+        network['namespaceCleanup']['remaining'] = [123]
+        self.assertFalse(worker_certified(rows, lifecycle, network, ['a', 'b'], 1))
+        network['namespaceCleanup']['remaining'] = []
+        self.assertFalse(worker_certified(rows, lifecycle, network, ['a', 'c'], 1))
+        lifecycle['inputsVerified'] = False
+        self.assertFalse(worker_certified(rows, lifecycle, network, ['a', 'b'], 1))
+
+    def test_product_copy_fingerprint_excludes_runtime_and_detects_source(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            (root / 'src').mkdir()
+            source = root / 'src/app.ts'; source.write_text('original')
+            before = product_fingerprint(root)
+            (root / 'node_modules').mkdir()
+            (root / 'node_modules/cache').write_text('runtime')
+            self.assertEqual(before, product_fingerprint(root))
+            source.write_text('changed')
+            self.assertNotEqual(before, product_fingerprint(root))
+
+    def test_duplicate_ids_and_packages_rejected_before_launch(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            for name in ('case.spec.mjs', 'playwright.config.mjs', 'package.json', 'package-lock.json', 'node_modules/.bin/playwright'):
+                file = root / 'pkg' / name
+                file.parent.mkdir(parents=True, exist_ok=True)
+                file.write_text('{}')
+            manifest = root / 'input.json'
+            for rows in ([dict(id='a', package='pkg'), dict(id='b', package='pkg')],
+                         [dict(id='a', package='pkg'), dict(id='a', package='other')],
+                         [dict(id='a', package=None)]):
+                manifest.write_text(json.dumps(rows))
+                with self.assertRaises(ValueError): read_cases(manifest)
+
+    def test_html_escapes_errors_and_rejects_outside_image_links(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp); report = root / 'report'; report.mkdir()
+            (root / 'private.png').write_bytes(b'not-an-image')
+            receipt = report / 'case-result.json'
+            receipt.write_text(json.dumps(dict(errors=['<script>alert(1)</script>'], screenshots=[dict(file='../private.png', phase='target')], artifactErrors=[])))
+            summary = dict(startedAt=0, finishedAt=1, counts={'failed':1}, cases=[dict(id='区域 / <bad>', status='failed', receipt=str(receipt))])
+            output = render_report(summary, report).read_text()
+            self.assertNotIn('<script>alert(1)</script>', output)
+            self.assertIn('&lt;script&gt;', output)
+            self.assertIn('&lt;bad&gt;', output)
+            self.assertNotIn('<img ', output)
+            self.assertIn('无截图', output)
+
+    def test_runner_source_mutation_changes_fingerprint(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            for name in ('case.spec.mjs', 'playwright.config.mjs', 'package.json', 'package-lock.json'):
+                (root / name).write_text('{}')
+            (root / 'runner').mkdir()
+            source = root / 'runner/main.mjs'; source.write_text('a')
+            rows = [dict(id='a', package=tmp)]
+            before = fingerprint(rows)
+            source.write_text('b')
+            self.assertNotEqual(before, fingerprint(rows))
+
+if __name__ == '__main__': unittest.main()

package/tools/modules/minifish/harness/test_common_report.py

@@ -0,0 +1,47 @@
+import copy
+import json
+from pathlib import Path
+import sys
+import tempfile
+import unittest
+
+from batch_report import render_report
+from plugin_artifact import validate_plugin_artifact
+
+class CommonReportControls(unittest.TestCase):
+    def test_current_only_main_image_and_old_identity_in_history(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root=Path(tmp)
+            (root/'current.png').write_bytes(b'PNG-current')
+            (root/'old.png').write_bytes(b'PNG-old')
+            cases=[]
+            for name,sha in [('current','new-sha'),('old','old-sha')]:
+                receipt=root/(name+'.json');receipt.write_text(json.dumps(dict(caseId=name,executionId=name,productIdentity=dict(sha256=sha),errors=[],artifactErrors=[],screenshots=[dict(file=name+'.png',phase='target')])));cases.append(dict(id=name,status='passed',receipt=str(receipt)))
+            html=render_report(dict(currentProduct=dict(sha256='new-sha'),cases=cases,counts=dict(passed=2),startedAt=0,finishedAt=1),root).read_text()
+            current=html.split('data-status="passed"')[1];old=html.split('data-status="passed"')[2]
+            self.assertIn('data:image/png;base64',current.split('class="shots current-product"')[1].split('</div>')[0])
+            self.assertNotIn('<img ',old.split('class="shots current-product"')[1].split('</div>')[0])
+            self.assertIn('历史执行截图（非当前产品）',old);self.assertIn('old-sha',old);self.assertIn('当前产品最终图缺失',old)
+    def test_missing_current_identity_never_adopts_legacy_screenshot(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root=Path(tmp);(root/'old.png').write_bytes(b'PNG');receipt=root/'old.json';receipt.write_text(json.dumps(dict(errors=[],screenshots=[dict(file='old.png',phase='target')],fingerprints=dict(productSha256='legacy-sha'))))
+            html=render_report(dict(currentProduct=dict(sha256='new-sha'),cases=[dict(id='old',status='passed',receipt=str(receipt))],startedAt=0,finishedAt=1),root).read_text()
+            self.assertNotIn('<img ',html.split('class="shots current-product"')[1].split('</div>')[0]);self.assertIn('legacy-sha',html);self.assertIn('<details class="history">',html)
+    def test_artifact_missing_modified_and_source_mismatch_preflight(self):
+        import hashlib
+        with tempfile.TemporaryDirectory() as tmp:
+            source=Path(tmp)/'source';source.mkdir();(source/'carrier.js').write_text('controlled source')
+            copydir=Path(tmp)/'plugin';copydir.mkdir()
+            for name in ['appConfig.json','index.worker.js','index.js']:(copydir/name).write_text('facility artifact')
+            digest=lambda p:hashlib.sha256(p.read_bytes()).hexdigest()
+            manifest=dict(schemaVersion=1,plan=dict(instances=[dict(id='facility')]),sourceHashes={'carrier.js':digest(source/'carrier.js')},artifacts={p.name:digest(p) for p in copydir.iterdir()})
+            (copydir/'plugin-artifact.json').write_text(json.dumps(manifest))
+            validate_plugin_artifact(copydir,source)
+            (copydir/'index.worker.js').write_text('changed')
+            with self.assertRaises(ValueError):validate_plugin_artifact(copydir,source)
+            (copydir/'index.worker.js').unlink()
+            with self.assertRaises(ValueError):validate_plugin_artifact(copydir,source)
+            with self.assertRaises(FileNotFoundError):validate_plugin_artifact(Path(tmp)/'absent',source)
+            manifest=json.loads((copydir/'plugin-artifact.json').read_text());manifest['sourceHashes']={};(copydir/'plugin-artifact.json').write_text(json.dumps(manifest))
+            with self.assertRaises(ValueError):validate_plugin_artifact(copydir,source)
+if __name__=='__main__':unittest.main()

package/tools/modules/minifish/harness/test_held_capture_contract.py

@@ -0,0 +1,50 @@
+import copy
+import json
+from pathlib import Path
+import tempfile
+import unittest
+from capture_contract import classify_receipt, associate_capture
+from batch_cases import worker_certified
+from batch_report import render_report
+
+
+def behavior():
+    return dict(caseId='held',executionRole='behavior',executionId='behavior-1',outcome='passed',preparation='passed',target='passed',boundary='passed',cleanup='passed',errors=[],artifactErrors=[],screenshots=[],fingerprints=dict(caseId='held',**{k:'a'*64 for k in ['planSha256','sourceSha256','productSha256','packageSha256','dependencyLockSha256']}))
+
+
+def artifact():
+    a=behavior();a.update(executionRole='held-artifact',executionId='capture-1',outcome='artifact-only',boundary='not-executed-artifact-only',screenshots=[dict(file='held.png',phase='target')],notExecutedActions=[dict(kind='release',boundaryId='open',status='not-executed-artifact-only')],actions=[dict(kind='cancel',status='passed',protocol='native-move-outside-device-then-up')],artifactAudit=dict(status='verified',violations=[],expectations=[dict(id='prepare',status='completed'),dict(id='open',status='not-executed-artifact-only')]),evidence=dict(violations=[],networkViolations=[],expectations=[dict(id='prepare',times=1,received=1,delivered=1,consumed=1,outcome=dict(kind='response'),requireConsumption=True),dict(id='open',times=1,received=0,delivered=0,consumed=0,outcome=dict(kind='response'),requireConsumption=True)]));return a
+
+
+class HeldCaptureControls(unittest.TestCase):
+    def test_artifact_is_never_behavior_pass_and_all_cancellation_audits_required(self):
+        a=artifact();self.assertEqual(classify_receipt(a,'held',0,'held-artifact'),'artifact-only');self.assertEqual(classify_receipt(a,'held',0),'failed')
+        for mutate in [lambda a:a.update(boundary='passed'),lambda a:a.update(actions=[]),lambda a:a['evidence'].update(networkViolations=['unknown external call']),lambda a:a['evidence']['expectations'][1].update(received=1),lambda a:a['evidence']['expectations'][0].update(consumed=0),lambda a:a['artifactAudit'].update(violations=['unexpected operation']),lambda a:a.update(executionId=None)]:
+            bad=copy.deepcopy(a);mutate(bad);self.assertEqual(classify_receipt(bad,'held',0,'held-artifact'),'failed')
+        forged=behavior();forged['outcome']='artifact-only';self.assertEqual(classify_receipt(forged,'held',0),'failed')
+        b=behavior();b.update(boundary='failed',errors=['missing navigation']);self.assertEqual(classify_receipt(b,'held',0),'failed');associate_capture(b,a)
+
+    def test_different_inputs_product_source_package_lock_or_execution_identity_reject(self):
+        b,a=behavior(),artifact();self.assertEqual(associate_capture(b,a)['captureOutcome'],'artifact-only')
+        for key in a['fingerprints']:
+            bad=copy.deepcopy(a);bad['fingerprints'][key]='b'*64
+            with self.assertRaises(ValueError):associate_capture(b,bad)
+        a['executionId']=b['executionId']
+        with self.assertRaises(ValueError):associate_capture(b,a)
+
+    def test_legacy_dependency_mismatch_rejects_and_old_failure_is_preserved(self):
+        b,a=behavior(),artifact();b['packageFiles']={'case.spec.mjs':'1','runner/regions/T4.mjs':'2','runner/miniapp-screenshot.mjs':'new'};a['packageFiles']={'case.spec.mjs':'1','runner/regions/T4.mjs':'2','runner/miniapp-screenshot.mjs':'old'};a.update(historicalStatus='failed',outcome='failed');a['fingerprints'].update(sourceSha256='b'*64,packageSha256='c'*64)
+        association=associate_capture(b,a,legacy=True);self.assertEqual(association['captureOutcome'],'failed');self.assertEqual(association['changedLifecycleDependencies'],['runner/miniapp-screenshot.mjs']);a['packageFiles']['runner/regions/T4.mjs']='different'
+        with self.assertRaises(ValueError):associate_capture(b,a,legacy=True)
+
+    def test_artifact_worker_cleanup_and_failed_behavior_html_remain_distinct(self):
+        lifecycle=dict(inputsVerified=True,children=[dict(returncode=0)]);network=dict(namespaceCleanup=dict(remaining=[]),children=[dict(returncode=0)])
+        self.assertTrue(worker_certified([dict(id='held',status='artifact-only')],lifecycle,network,['held'],0));network['namespaceCleanup']['remaining']=[1];self.assertFalse(worker_certified([dict(id='held',status='artifact-only')],lifecycle,network,['held'],0))
+        with tempfile.TemporaryDirectory() as tmp:
+            p=Path(tmp);b=behavior();b.update(outcome='failed',boundary='failed',errors=['missing navigation']);a=artifact();(p/'behavior.json').write_text(json.dumps(b));(p/'capture.json').write_text(json.dumps(a));(p/'held.png').write_bytes(b'PNG')
+            summary=dict(startedAt=0,finishedAt=1,counts=dict(passed=0,failed=1),cases=[dict(id='held',status='failed',receipt=str(p/'behavior.json'),captureEvidence=dict(receipt=str(p/'capture.json')),phases=dict(boundary='failed'))]);html=render_report(summary,p).read_text();self.assertIn('按住态展示截图（独立采集）',html);self.assertIn('behavior-1',html);self.assertIn('capture-1',html);self.assertIn('data-status="failed"',html);self.assertIn('missing navigation',html)
+            a['fingerprints']['planSha256']='d'*64;(p/'capture.json').write_text(json.dumps(a))
+            with self.assertRaises(ValueError):render_report(summary,p)
+
+
+if __name__=='__main__':unittest.main()

package/tools/modules/minifish/harness/test_pty_tail.py

@@ -0,0 +1,39 @@
+import io
+import os
+import pty
+import sys
+from pathlib import Path
+import threading
+import time
+import unittest
+sys.path.insert(0,str(Path(__file__).resolve().parent))
+from runtime_isolation import drain_pty
+
+class TailTests(unittest.TestCase):
+    def test_closed_slave_eio_and_large_tail(self):
+        master,slave=pty.openpty()
+        expected=b'x'*200000
+        def write_tail():
+            try:
+                view=memoryview(expected)
+                while view:
+                    n=os.write(slave,view);view=view[n:]
+            finally:os.close(slave)
+        writer=threading.Thread(target=write_tail);writer.start()
+        try:
+            log=io.BytesIO()
+            self.assertEqual(drain_pty(master,log,budget=2),len(expected))
+            self.assertEqual(log.getvalue(),expected)
+            writer.join(timeout=2)
+            self.assertFalse(writer.is_alive())
+        finally:os.close(master)
+
+    def test_live_quiet_slave_has_bounded_wait(self):
+        master,slave=pty.openpty()
+        try:
+            begin=time.monotonic()
+            self.assertEqual(drain_pty(master,io.BytesIO(),budget=.1),0)
+            self.assertLess(time.monotonic()-begin,.5)
+        finally:os.close(slave);os.close(master)
+
+if __name__=='__main__':unittest.main()

package/tools/modules/minifish/harness/test_runtime_dependencies.py

@@ -0,0 +1,49 @@
+"""Official component isolation must retain bytes and worker write ownership."""
+import io
+from pathlib import Path
+import tarfile
+import tempfile
+import unittest
+from runtime_isolation import prepare_dependencies
+
+
+class DependencyLayoutTest(unittest.TestCase):
+    def test_component_materialization_preserves_bytes_and_archive(self):
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            modules = root / 'installed'
+            official = modules / '@alipay/industry-mini/es/ErrorBlock'
+            official.mkdir(parents=True)
+            (official / 'index.json').write_bytes(b'{"component":true}')
+            other = modules / '@alipay/tool'
+            other.mkdir()
+            archive = root / 'views.tgz'
+            with tarfile.open(archive, 'w:gz') as output:
+                entry = tarfile.TarInfo('package/index.js')
+                data = b'original generated component'
+                entry.size = len(data)
+                output.addfile(entry, io.BytesIO(data))
+            destinations = [root / 'worker1/node_modules', root / 'worker2/node_modules']
+            for destination in destinations:
+                destination.parent.mkdir()
+                prepare_dependencies(modules, destination, {'alternate-views': archive})
+                component = destination / '@alipay/industry-mini/es/ErrorBlock/index.json'
+                self.assertEqual(component.read_bytes(), (official / 'index.json').read_bytes())
+                self.assertTrue(component.resolve().is_relative_to(destination.parent))
+                self.assertTrue((destination / '@alipay/tool').is_symlink())
+                self.assertEqual((destination / 'alternate-views/index.js').read_bytes(), data)
+            (destinations[0] / '@alipay/industry-mini/es/ErrorBlock/index.json').write_text('worker mutation')
+            self.assertEqual((official / 'index.json').read_bytes(), b'{"component":true}')
+            self.assertEqual((destinations[1] / '@alipay/industry-mini/es/ErrorBlock/index.json').read_bytes(), b'{"component":true}')
+
+    def test_absent_component_keeps_original_scope_link(self):
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            modules = root / 'installed'
+            (modules / '@alipay/tool').mkdir(parents=True)
+            prepare_dependencies(modules, root / 'isolated')
+            self.assertTrue((root / 'isolated/@alipay').is_symlink())
+
+
+if __name__ == '__main__':
+    unittest.main()

package/tools/modules/minifish/harness/zero-business-plan.mjs

@@ -0,0 +1,19 @@
+import assert from 'node:assert/strict';
+
+/** Exact zero-call contract. Never use as a fallback for a nonempty request plan. */
+export function zeroBusinessPlan() {
+  const attempts = [], violations = [];
+  return {
+    async receive(operation, request, wire) {
+      attempts.push({ operation, request, wire });
+      const message = `Unexpected business call in zero-call case: ${operation}`;
+      violations.push(message);
+      throw Error(message);
+    },
+    markDelivered() { violations.push('unplanned response delivered'); },
+    markConsumed() { violations.push('unplanned response consumed'); },
+    assertComplete() { assert.deepEqual(violations, [], 'zero-call boundary violations'); },
+    evidence() { return { attempts: structuredClone(attempts), violations: [...violations], expectations: [] }; },
+    close() {},
+  };
+}

package/tools/modules/minifish/identity.py

@@ -0,0 +1,6 @@
+"""Compatibility import within the tool; common identity semantics live in core."""
+import sys
+from pathlib import Path
+sys.dont_write_bytecode = True
+sys.path.insert(0, str(Path(__file__).resolve().parents[3]))
+from tools.core.package_identity import verify_package

package/tools/modules/minifish/package-lock.json

@@ -0,0 +1,74 @@
+{
+  "name": "minifish-test-tools",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "minifish-test-tools",
+      "version": "1.0.0",
+      "dependencies": {
+        "@playwright/test": "1.63.0",
+        "typescript": "5.9.3"
+      }
+    },
+    "node_modules/@playwright/test": {
+      "version": "1.63.0",
+      "resolved": "https://registry.npmjs.org/@playwright/test/-/test-1.63.0.tgz",
+      "integrity": "sha512-oxMK4vllB9RK5NQ2l1pq1IfOf2AvnEuj/vYGDj0H2nMtmtZpKtCwt/l00GEO6xjGfpBNAvjovvYdCm50dRQkpQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "playwright": "1.63.0"
+      },
+      "bin": {
+        "playwright": "cli.js"
+      },
+      "engines": {
+        "node": ">=20"
+      }
+    },
+    "node_modules/playwright": {
+      "version": "1.63.0",
+      "resolved": "https://registry.npmjs.org/playwright/-/playwright-1.63.0.tgz",
+      "integrity": "sha512-+7ziBLidS4NaNCdt57SUDT+wYmmd5fmiQejUic/kb+YsYSCPyOOE9sebzMjNmQrsnNpDJqd4WHvV/8lfKfUDUg==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "playwright-core": "1.63.0"
+      },
+      "bin": {
+        "playwright": "cli.js"
+      },
+      "engines": {
+        "node": ">=20"
+      }
+    },
+    "node_modules/playwright-core": {
+      "version": "1.63.0",
+      "resolved": "https://registry.npmjs.org/playwright-core/-/playwright-core-1.63.0.tgz",
+      "integrity": "sha512-rYCsBF/M5HjUch52bbtVONEFjv6Xu8sm8h72dNlR5bzIE1fvC/bxgspzkjSfU+MweEMmPM8KJebG6nnyxo5mCg==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "playwright-core": "cli.js"
+      },
+      "engines": {
+        "node": ">=20"
+      }
+    },
+    "node_modules/typescript": {
+      "version": "5.9.3",
+      "resolved": "https://registry.antgroup-inc.cn/typescript/-/typescript-5.9.3.tgz",
+      "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
+      "dev": true,
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    }
+  },
+  "version": "1.0.0"
+}

package/tools/modules/minifish/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "minifish-test-tools",
+  "version": "1.0.0",
+  "dependencies": {
+    "@playwright/test": "1.63.0",
+    "typescript": "5.9.3"
+  },
+  "private": true,
+  "type": "module"
+}