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

package/tools/modules/minifish/harness/run-batch.py

@@ -0,0 +1,133 @@
+#!/usr/bin/env python3
+"""Bounded parallel official runtimes; each reuses startup for independent cases."""
+import argparse
+from concurrent.futures import ThreadPoolExecutor
+import os
+from pathlib import Path
+import signal
+import subprocess
+import sys
+import threading
+import time
+from product_identity import product_identity
+from batch_cases import read_cases, save, read_result, worker_certified, product_fingerprint
+from network_isolation import add_network_arguments
+from batch_report import render_report
+from batch_plugin_groups import plugin_groups
+
+
+def main():
+    p = argparse.ArgumentParser()
+    p.add_argument('--project-root', type=Path, required=True)
+    p.add_argument('--config', type=Path, required=True)
+    p.add_argument('--manifest', type=Path, required=True, help='JSON array of exact id/package pairs')
+    p.add_argument('--product', type=Path, required=True)
+    p.add_argument('--node-modules', type=Path, required=True)
+    p.add_argument('--report-dir', type=Path, required=True)
+    p.add_argument('--workers', type=int, default=8, help='Requested concurrency (1..16, default: 8); non-8 requires --workers-reason')
+    p.add_argument('--workers-reason', help='Evidence for reducing concurrency or purpose of a higher-concurrency resource experiment')
+    p.add_argument('--screenshots', choices=['none', 'failed', 'all'], default='none')
+    p.add_argument('--case-timeout', type=int, default=90)
+    p.add_argument('--startup-budget', type=int, default=180)
+    p.add_argument('--plugin-artifacts', type=Path)
+    p.add_argument('--plugin-artifact-map', type=Path, help='JSON case-id to exact preflighted artifact directory; partitions one unified batch by plugin identity')
+    p.add_argument('--design-reference', type=Path)
+    add_network_arguments(p)
+    a = p.parse_args()
+    if not 1 <= a.workers <= 16 or a.case_timeout < 1 or a.startup_budget < 1:
+        p.error('workers must be 1..16 and time budgets positive')
+    reason = (a.workers_reason or '').strip()
+    if a.workers != 8 and not reason:
+        p.error('Non-8 workers require a nonempty --workers-reason before worker startup')
+    rows = read_cases(a.manifest)
+    if a.screenshots != 'none':
+        for row in rows:
+            runner = Path(row['package']) / 'runner/tools/harness/independent-case-runner.mjs'
+            if not runner.is_file() or 'export const screenshotPolicyVersion = 1;' not in runner.read_text():
+                p.error('Screenshot policy requires rebuilding case packages with the current compiler/runner')
+    here = Path(__file__).resolve().parent
+    report = a.report_dir.resolve()
+    from project_config import load_project
+    config = load_project(a.project_root, a.config)
+    repo = (a.project_root / config['repositoryRoot']).resolve()
+    if report == repo or repo in report.parents:
+        p.error('Reports must be outside the source repository')
+    if not a.product.is_dir() or not (a.node_modules / '.bin/minifish2').is_file():
+        p.error('Real product and installed official toolchain required')
+    partitions = plugin_groups(rows, a.workers, a.plugin_artifact_map, a.plugin_artifacts, source=a.project_root / config['pluginSource'])
+    report.mkdir(parents=True, exist_ok=False)
+    product_inputs = product_fingerprint(a.product.resolve())
+    save(report / 'product-input.json', product_inputs)
+    count = min(a.workers, len(rows))
+    shards = [group for group, artifact in partitions]
+    stopped = threading.Event()
+    active, mutex = {}, threading.Lock()
+    started = time.time()
+    concurrency_policy = {'defaultWorkers': 8, 'requestedWorkers': a.workers,
+                          'actualConcurrency': min(count, len(shards)),
+                          'workersReason': reason or None,
+                          'shardSizes': [len(group) for group in shards]}
+    save(report / 'batch-input.json', {'cases': rows, 'workers': count,
+                                     'concurrencyPolicy': concurrency_policy, 'startedAt': started})
+    def interrupt(signum, frame):
+        stopped.set()
+        with mutex:
+            for process in active.values():
+                if process.poll() is None:
+                    process.send_signal(signal.SIGTERM)
+    for sig in (signal.SIGINT, signal.SIGTERM):
+        signal.signal(sig, interrupt)
+    def worker(index):
+        group = shards[index]
+        plugin_artifact = partitions[index][1]
+        manifest = report / f'worker-{index + 1:02d}.json'
+        out = report / f'worker-{index + 1:02d}'
+        save(manifest, group)
+        command = [sys.executable, str(here / 'run-platform.py'), '--project-root', str(a.project_root.resolve()), '--config', str(a.config.resolve()), '--product', str(a.product.resolve()), '--product-manifest', str(report / 'product-input.json'), '--node-modules', str(a.node_modules.resolve()), '--independent-case-list', str(manifest), '--report-dir', str(out), '--timeout', str(a.startup_budget + len(group) * (a.case_timeout + 5)), '--case-timeout', str(a.case_timeout)]
+        for flag, value in [('slirp4netns', a.slirp4netns), ('slirp-library-path', a.slirp_library_path), ('plugin-artifacts', Path(plugin_artifact) if plugin_artifact else None), ('design-reference', a.design_reference)]:
+            if value: command.extend(['--'+flag, str(value.resolve())])
+        info = {'worker': index + 1, 'startedAt': time.time(), 'command': command}
+        try:
+            with (report / f'worker-{index + 1:02d}.log').open('wb') as log:
+                with mutex:
+                    if stopped.is_set(): return dict(info, exitCode=None, error='interrupted before start')
+                    process = subprocess.Popen(command, stdout=log, stderr=log, start_new_session=True, env=dict(os.environ, MINIFISH_SCREENSHOTS=a.screenshots, MINIFISH_FINAL_SCREENSHOTS='1' if a.screenshots == 'all' else '0', MINIFISH_FINAL_DELIVERY_SCREENSHOTS='1' if a.screenshots == 'all' else '0'))
+                    active[index] = process
+                info['exitCode'] = process.wait()
+        except OSError as error:
+            info.update(exitCode=None, error=str(error))
+        finally:
+            with mutex: active.pop(index, None)
+        info['finishedAt'] = time.time()
+        return info
+    with ThreadPoolExecutor(max_workers=count) as pool:
+        workers = list(pool.map(worker, range(len(shards))))
+    product_unchanged = product_fingerprint(a.product.resolve()) == product_inputs
+    results = []
+    import json
+    for index, group in enumerate(shards):
+        out = report / f'worker-{index + 1:02d}'
+        received = read_result(out / 'batch-results.json', list)
+        lifecycle = read_result(out / 'lifecycle.json', dict)
+        network = read_result(out / 'network-lifecycle.json', dict)
+        certified = product_unchanged and worker_certified(received, lifecycle, network, [r['id'] for r in group], workers[index].get('exitCode'))
+        workers[index]['certified'] = certified
+        by_id = {item.get('id'): item for item in (received or []) if isinstance(item, dict)}
+        for row in group:
+            item = by_id.get(row['id'], dict(row, status='not-run'))
+            item['worker'] = index + 1
+            item['workerExitCode'] = workers[index].get('exitCode')
+            if item.get('status') in ('passed','artifact-only') and not certified:
+                item.update(status='invalidated', error='worker inputs, result identities or cleanup were not certified')
+            results.append(item)
+    summary = {'startedAt': started, 'finishedAt': time.time(), 'workers': workers, 'concurrency': concurrency_policy['actualConcurrency'], 'concurrencyPolicy': concurrency_policy, 'cases': results, 'counts': {s: sum(x['status'] == s for x in results) for s in ['passed', 'failed', 'not-run', 'interrupted', 'invalidated', 'artifact-only']}}
+    summary['currentProduct'] = product_identity(product_inputs)
+    summary['screenshots'] = a.screenshots
+    save(report / 'batch-summary.json', summary)
+    render_report(summary, report)
+    print(json.dumps({'report': str(report / 'batch-summary.json'), 'seconds': summary['finishedAt']-started, 'counts': summary['counts']}, ensure_ascii=False))
+    return int(stopped.is_set() or any(x['status'] not in ('passed','artifact-only') for x in results) or any(w.get('exitCode') != 0 for w in workers))
+
+
+if __name__ == '__main__':
+    raise SystemExit(main())

package/tools/modules/minifish/harness/run-platform.py

@@ -0,0 +1,293 @@
+#!/usr/bin/env python3
+"""Run the independent official-SDK fixture; never substitutes for product E2E."""
+import argparse
+from product_identity import product_identity
+from plugin_artifact import validate_plugin_artifact
+from batch_cases import read_cases, fingerprint, product_fingerprint
+from network_isolation import add_network_arguments, active_namespace, entry
+from runtime_isolation import prepare_dependencies, dev_command, drain_pty
+import os
+from pathlib import Path
+import pty
+import re
+import select
+import shutil
+import signal
+import subprocess
+import tempfile
+import time
+import json
+import hashlib
+import threading
+from http.server import ThreadingHTTPServer, SimpleHTTPRequestHandler
+
+parser = argparse.ArgumentParser()
+parser.add_argument('--project-root', type=Path, required=True)
+parser.add_argument('--config', type=Path, required=True)
+parser.add_argument('--node-modules', type=Path, required=True, help='Explicit installed locked official SDK node_modules')
+parser.add_argument('--report-dir', type=Path, help='New directory outside repository for logs and compiled fixture')
+parser.add_argument('--check', choices=['common-input','common-plugin','expanded-common','plugin-host','foreground','platform','current-native','transport','images','header-layout','navigation','host-language','host-navigation','isolation'], default='platform', help='Independent facility check to run')
+parser.add_argument('--design-reference', type=Path, help='Independent Prototype reference.html built outside repository')
+parser.add_argument('--plugin-artifacts', type=Path, help='Officially compiled controlled external plugin assets; serves locally without replacing product')
+parser.add_argument('--product', type=Path, help='Run an unchanged product copy with current page tests')
+parser.add_argument('--suite', choices=['product'], help='Current business product fixture domain')
+parser.add_argument('--timeout', type=int, default=240, help='Whole build/check budget in seconds; use 7200 for a full product suite')
+parser.add_argument('--product-manifest', type=Path, help='Expected product input hashes for a batch')
+parser.add_argument('--independent-case-list', type=Path, help='Exact JSON id/package list, one reused runtime and fresh browser process per case')
+parser.add_argument('--case-timeout', type=int, default=90)
+parser.add_argument('--independent-case', type=Path, help='Generated standalone case package; no legacy suite discovery')
+parser.add_argument('--platform-lock-timeout', type=float, default=0, help='Deprecated compatibility no-op; runs are isolated and never locked')
+parser.add_argument('--isolation-marker', help='Independent isolation fixture marker')
+parser.add_argument('--isolation-control-dir', type=Path, help='Independent facility controller signals')
+parser.add_argument('--isolation-mode', choices=['hold','fault'], default='hold')
+parser.add_argument('--dev-verbose', action='store_true', help='Official CLI full streaming diagnostics')
+add_network_arguments(parser)
+args = parser.parse_args()
+batch = None
+if args.independent_case_list:
+    if not args.product or args.independent_case:
+        parser.error('independent-case-list requires product and excludes other case selectors')
+    args.independent_case_list = args.independent_case_list.resolve()
+    batch = read_cases(args.independent_case_list)
+    if args.case_timeout < 1:
+        parser.error('case-timeout must be positive')
+if args.independent_case:
+    args.independent_case = args.independent_case.resolve()
+    if not args.product:
+        parser.error('independent-case requires product')
+    for name in ('case.spec.mjs', 'playwright.config.mjs', 'node_modules/.bin/playwright'):
+        if not (args.independent_case / name).is_file():
+            parser.error('Independent case package missing: ' + name)
+if args.check == 'isolation':
+    if args.product or not args.isolation_marker or not re.fullmatch(r'[A-Z0-9-]+', args.isolation_marker) or not args.isolation_control_dir:
+        parser.error('isolation requires a marker/control directory and no product')
+    if not args.isolation_control_dir.is_dir():
+        parser.error('isolation control directory must exist')
+if args.product and not args.independent_case and not batch:
+    parser.error('Product execution requires --independent-case or --independent-case-list; use harness/run-batch.py')
+here = Path(__file__).resolve().parent
+from project_config import load_project
+config = load_project(args.project_root, args.config)
+if args.product:
+    args.suite = 'product'
+elif args.suite:
+    parser.error('--suite requires --product')
+
+modules = args.node_modules.resolve()
+cli = modules / '.bin/minifish2'
+if not cli.is_file():
+    parser.error('Official minifish2 executable not found')
+here = Path(__file__).resolve().parent
+if args.report_dir:
+    work = args.report_dir.resolve()
+    repository = (args.project_root / config['repositoryRoot']).resolve()
+    if work == repository or repository in work.parents:
+        parser.error('Reports must be outside source repository')
+    if not active_namespace(work):
+        work.mkdir(parents=True, exist_ok=False)
+else:
+    work = Path(tempfile.mkdtemp(prefix='minifish-platform-check-'))
+entry(work, args)
+if args.product:
+    product_inputs = product_fingerprint(args.product.resolve())
+    if args.product_manifest and product_inputs != json.loads(args.product_manifest.read_text()):
+        raise RuntimeError('Product differs from batch snapshot before copy')
+    shutil.copytree(args.product.resolve(), work / 'app', ignore=shutil.ignore_patterns('node_modules','.git','dist-*','.mini-ide'))
+    if product_fingerprint(work / 'app') != product_inputs:
+        raise RuntimeError('Product changed during runtime copy')
+    (work / 'product-source-manifest.json').write_text(json.dumps(product_inputs, indent=2))
+else:
+    shutil.copytree(args.project_root / config['facilityFixtures'][args.check], work / 'app')
+if args.check == 'isolation':
+    fixture = work / 'app/src/pages/index/index.ts'
+    fixture.write_text(fixture.read_text().replace("'00123'", repr(args.isolation_marker)))
+if args.check == 'header-layout':
+    if args.product:
+        parser.error('header-layout facility check requires the independent platform fixture')
+    config_path = work / 'app/src/app.json'
+    config = json.loads(config_path.read_text())
+    config['window'] = {'defaultTitle': '缴费账单', 'transparentTitle': 'always'}
+    config_path.write_text(json.dumps(config, ensure_ascii=False))
+component_archives = {}
+if args.product:
+    dependencies = json.loads((args.product.resolve() / 'package.json').read_text()).get('dependencies', {})
+    for name in config['localComponentPackages']:
+        dependency = dependencies.get(name)
+        if not dependency or not dependency.startswith('file:'):
+            parser.error('Explicit local component archive required: ' + name)
+        archive = (args.product.resolve() / dependency[5:]).resolve()
+        if not archive.is_file(): parser.error('Declared product component archive does not exist')
+        component_archives[name] = archive
+prepare_dependencies(modules, work / 'app/node_modules', component_archives)
+def test_source_fingerprint():
+    roots = {'project': args.project_root.resolve(), 'tool': here.parent}
+    return {kind + '/' + str(p.relative_to(base)): hashlib.sha256(p.read_bytes()).hexdigest()
+            for kind, base in roots.items() for p in sorted(base.rglob('*')) if p.is_file()
+            and not any(part in ('node_modules', '.git', '__pycache__') for part in p.relative_to(base).parts)}
+source_fingerprint = test_source_fingerprint()
+(work / 'source-manifest.json').write_text(json.dumps({'testFiles': source_fingerprint}, indent=2))
+independent_fingerprint = None
+if args.independent_case:
+    independent_fingerprint = {name: hashlib.sha256((args.independent_case / name).read_bytes()).hexdigest()
+                               for name in ['case.spec.mjs', 'playwright.config.mjs', 'package.json', 'package-lock.json',
+                                            *[str(file.relative_to(args.independent_case)) for file in sorted((args.independent_case / 'runner').rglob('*')) if file.is_file()]]}
+    (work / 'independent-case-manifest.json').write_text(json.dumps(independent_fingerprint, indent=2))
+batch_fingerprint = fingerprint(batch) if batch else None
+if batch:
+    (work / 'batch-source-manifest.json').write_text(json.dumps(batch_fingerprint, indent=2))
+plugin_server = None
+plugin_reads = []
+plugin_package_url = None
+if args.plugin_artifacts:
+    if not args.product and args.check not in ('plugin-host','common-plugin'):
+        parser.error('--plugin-artifacts requires product or independent plugin-host check')
+    plugin_root = args.plugin_artifacts.resolve()
+    compiled_plugin_manifest = validate_plugin_artifact(plugin_root, args.project_root / config['pluginSource'])
+    (work / 'compiled-plugin-manifest.json').write_text(json.dumps(compiled_plugin_manifest, indent=2))
+    for name in ('appConfig.json', 'index.worker.js', 'index.js'):
+        if not (plugin_root / name).is_file():
+            parser.error('Official compiled plugin asset missing: ' + name)
+    class PluginResources(SimpleHTTPRequestHandler):
+        def __init__(self, *values, **options):
+            super().__init__(*values, directory=str(plugin_root), **options)
+        def end_headers(self):
+            self.send_header('Access-Control-Allow-Origin', '*')
+            super().end_headers()
+        def log_message(self, pattern, *values):
+            plugin_reads.append({'path': self.path, 'message': pattern % values})
+    plugin_server = ThreadingHTTPServer(('127.0.0.1', 0), PluginResources)
+    threading.Thread(target=plugin_server.serve_forever, daemon=True).start()
+    plugin_package_url = f'http://127.0.0.1:{plugin_server.server_port}/'
+    (work / 'plugin-artifacts.json').write_text(json.dumps({'source': str(plugin_root), 'sha256': {name: hashlib.sha256((plugin_root / name).read_bytes()).hexdigest() for name in ('appConfig.json','index.worker.js','index.js')}}, indent=2))
+print(f'Facility logs: {work}', flush=True)
+master, slave = pty.openpty()
+children = []
+succeeded = False
+inputs_verified = False
+
+def interrupted(signum, frame):
+    raise InterruptedError(f'interrupted by signal {signum}')
+
+for sig in (signal.SIGTERM, signal.SIGINT):
+    signal.signal(sig, interrupted)
+
+try:
+    dev_argv = dev_command(cli, work)
+    if args.dev_verbose:
+        dev_argv.append('--verbose')
+    dev = subprocess.Popen(dev_argv, cwd=work / 'app', stdin=slave,
+                           stdout=slave, stderr=slave, start_new_session=True)
+    children.append(dev)
+    (work / 'dev-launch.json').write_text(json.dumps({
+        'argv': dev_argv, 'pid': dev.pid, 'pgid': os.getpgid(dev.pid), 'at': time.time(),
+        'cwd': str(work / 'app'),
+        'environment': {key: os.environ[key] for key in ('NODE_OPTIONS', 'MINIFISH_ISOLATION_MARKER', 'MINIFISH_ISOLATION_CONTROL_DIR') if key in os.environ}
+    }, indent=2))
+    os.close(slave)
+    slave = None
+    buffer = ''
+    sent_web = False
+    checker = None
+    deadline = time.monotonic() + args.timeout
+    with (work / 'platform.log').open('wb') as log, (work / 'check.log').open('wb') as check_log:
+        while time.monotonic() < deadline:
+            if select.select([master], [], [], 0.2)[0]:
+                try:
+                    data = os.read(master, 65536)
+                except OSError:
+                    data = b''
+                if data:
+                    log.write(data)
+                    log.flush()
+                    buffer = (buffer + data.decode('utf8', errors='replace'))[-200000:]
+            plain = re.sub(r'\x1b\[[0-9;]*[A-Za-z]', '', buffer)
+            if not sent_web and 'minifish>' in plain:
+                os.write(master, b'web\n')
+                sent_web = True
+            if 'error[Parse]:' in plain or '编译错误' in plain or 'Could not resolve import' in plain:
+                raise RuntimeError('Official fixture compilation failed; see platform.log')
+            match = re.search(r"simulator: '([^']+)'", plain)
+            if match and checker is None:
+                env = dict(os.environ, MINIFISH_FIXTURE_URL=match.group(1), MINIFISH_FIXTURE_REPORT_DIR=str(work))
+                (work / 'runtime.json').write_text(json.dumps({'url': match.group(1), 'devPid': dev.pid, 'at': time.time(), 'cacheDir': str(work / 'build-cache'), 'network': json.loads(os.environ['MINIFISH_RUN_NETWORK'])}, indent=2))
+                if args.check == 'isolation':
+                    env.update(MINIFISH_ISOLATION_MARKER=args.isolation_marker, MINIFISH_ISOLATION_CONTROL_DIR=str(args.isolation_control_dir.resolve()), MINIFISH_ISOLATION_MODE=args.isolation_mode)
+                if plugin_package_url:
+                    env['MINIFISH_PLUGIN_PACKAGE_URL'] = plugin_package_url
+                    env['MINIFISH_PLUGIN_ARTIFACT_MANIFEST'] = str(plugin_root / 'plugin-artifact.json')
+                command = [] if args.product else ['node', str(args.project_root / config['facilityChecks'][args.check])]
+                if args.product:
+                    if plugin_package_url:
+                        env['MINIFISH_PLUGIN_PACKAGE_URL'] = plugin_package_url
+                        env['MINIFISH_PLUGIN_ARTIFACT_MANIFEST'] = str(plugin_root / 'plugin-artifact.json')
+                    if args.design_reference:
+                        env['MINIFISH_DESIGN_REFERENCE_HTML'] = str(args.design_reference.resolve())
+                    env['MINIFISH_PRODUCT_IDENTITY'] = json.dumps(product_identity(product_inputs))
+                    env.update(MINIFISH_SUITE=args.suite, MINIFISH_SIMULATOR_URL=match.group(1), MINIFISH_PAGE_ROUTE=config['pageRoute'], MINIFISH_TEST_REPORT_DIR=str(work / 'results'), MINIFISH_SOURCE_MANIFEST=str(work / 'source-manifest.json'))
+                check_cwd = here.parent
+                if args.independent_case:
+                    env['MINIFISH_CASE_PACKAGE_ROOT'] = str(args.independent_case)
+                    command = [str(args.independent_case / 'node_modules/.bin/playwright'), 'test', '--config', 'playwright.config.mjs']
+                    check_cwd = args.independent_case
+                if batch:
+                    command = ['python3', str(here / 'check-independent-batch.py'), '--manifest', str(args.independent_case_list), '--report-dir', str(work), '--case-timeout', str(args.case_timeout)]
+                checker = subprocess.Popen(command, cwd=check_cwd,
+                                           env=env, stdout=check_log, stderr=check_log,
+                                           start_new_session=True)
+                children.append(checker)
+            if checker and checker.poll() is not None:
+                check_log.flush()
+                print((work / 'check.log').read_text(), flush=True)
+                if test_source_fingerprint() != source_fingerprint:
+                    raise RuntimeError('Test source changed during execution; this run cannot certify the current source')
+                if independent_fingerprint and any(hashlib.sha256((args.independent_case / name).read_bytes()).hexdigest() != digest
+                                                   for name, digest in independent_fingerprint.items()):
+                    raise RuntimeError('Independent case changed during execution')
+                if batch and fingerprint(batch) != batch_fingerprint:
+                    raise RuntimeError('Batch case source changed during execution')
+                if args.product and product_fingerprint(args.product.resolve()) != product_inputs:
+                    raise RuntimeError('Product source changed during execution')
+                inputs_verified = True
+                if checker.returncode:
+                    raise RuntimeError(f'Platform checks failed: {checker.returncode}')
+                succeeded = True
+                break
+            if dev.poll() is not None:
+                detected = time.time()
+                tail_bytes = drain_pty(master, log)
+                (work / 'dev-exit.json').write_text(json.dumps({'pid': dev.pid, 'returncode': dev.returncode, 'detectedAt': detected, 'tailDrainedAt': time.time(), 'tailBytes': tail_bytes}, indent=2))
+                raise RuntimeError(f'Official dev server exited: {dev.returncode}; see platform.log')
+        else:
+            raise TimeoutError(f'Platform build/check exceeded {args.timeout} seconds')
+finally:
+    for sig in (signal.SIGTERM, signal.SIGINT):
+        signal.signal(sig, signal.SIG_IGN)
+    # Kill process groups even when their parent exited; grandchildren may still serve ports.
+    for child in reversed(children):
+        try:
+            os.killpg(child.pid, signal.SIGTERM)
+        except ProcessLookupError:
+            pass
+    for child in reversed(children):
+        try:
+            child.wait(timeout=5)
+        except subprocess.TimeoutExpired:
+            pass
+        try:
+            os.killpg(child.pid, signal.SIGKILL)
+        except ProcessLookupError:
+            pass
+        child.wait()
+    with (work / 'platform.log').open('ab') as final_log:
+        drain_pty(master, final_log)
+    (work / 'lifecycle.json').write_text(json.dumps({
+        'success': succeeded, 'inputsVerified': inputs_verified, 'children': [{'pid': child.pid, 'returncode': child.returncode} for child in children],
+        'cleanup': 'all managed process groups terminated and reaped'
+    }, indent=2))
+    if plugin_server:
+        plugin_server.shutdown()
+        plugin_server.server_close()
+        (work / 'plugin-resource-reads.json').write_text(json.dumps(plugin_reads, indent=2))
+    os.close(master)
+    if slave is not None:
+        os.close(slave)

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

@@ -0,0 +1,71 @@
+"""Per-run writable dependencies; installed tool packages are read-only inputs."""
+import shutil
+import tarfile
+
+
+def prepare_dependencies(modules, destination, component_archives=None):
+    destination.mkdir()
+    for entry in modules.iterdir():
+        if entry.name == '.cache' or entry.name in (component_archives or {}):
+            continue
+        (destination / entry.name).symlink_to(entry.resolve(), target_is_directory=entry.is_dir())
+    (destination / '.cache').mkdir()
+    # Minifish's component resolver rejects realpaths outside projectRoot.
+    # Keep the locked official component package inside each worker; never
+    # write through the shared @alipay scope link or modify package bytes.
+    official = modules / '@alipay' / 'industry-mini'
+    if official.is_dir():
+        scope = destination / '@alipay'
+        scope.unlink()
+        scope.mkdir()
+        for package in (modules / '@alipay').iterdir():
+            target = scope / package.name
+            if package.name == 'industry-mini':
+                shutil.copytree(package.resolve(), target)
+            else:
+                target.symlink_to(package.resolve(), target_is_directory=package.is_dir())
+    for package_name, archive_path in (component_archives or {}).items():
+        generated = destination / package_name
+        with tarfile.open(archive_path) as archive:
+            archive.extractall(generated, filter='data')
+        nested = generated / 'package'
+        if nested.exists():
+            for entry in nested.iterdir():
+                shutil.move(str(entry), generated / entry.name)
+            nested.rmdir()
+
+
+def dev_command(cli, work):
+    # Minifish 2.40.1 detectPort maps CLI port 0 to port 1, not an ephemeral port.
+    # Give its official allocator an OS-selected per-run starting port instead.
+    import socket
+    with socket.socket() as reservation:
+        reservation.bind(('127.0.0.1', 0))
+        port = reservation.getsockname()[1]
+    return [str(cli), 'dev', '--port', str(port), '--host', '127.0.0.1',
+            '--cacheDir', str(work / 'build-cache')]
+
+
+def drain_pty(fd, log, budget=0.5):
+    """Bounded tail collection; PTY EIO means the final slave has closed."""
+    import errno
+    import os
+    import select
+    import time
+    end = time.monotonic() + budget
+    total = 0
+    while time.monotonic() < end:
+        if not select.select([fd], [], [], min(0.05, max(0, end-time.monotonic())))[0]:
+            continue
+        try:
+            data = os.read(fd, 65536)
+        except OSError as error:
+            if error.errno == errno.EIO:
+                break
+            raise
+        if not data:
+            break
+        log.write(data)
+        total += len(data)
+    log.flush()
+    return total

package/tools/modules/minifish/harness/scroll-container-observation.mjs

@@ -0,0 +1,40 @@
+import assert from 'node:assert/strict';
+
+// Read-only public layout evidence. No scroll assignment, events or Page data.
+export async function observeScrollContainers(node){
+ return node.evaluate(target=>{
+  const doc=target.ownerDocument,win=doc.defaultView,rows=[];
+  for(let el=target;el;el=el.parentElement){
+   const s=win.getComputedStyle(el),r=el.getBoundingClientRect();
+   rows.push({depth:rows.length,anchor:el.getAttribute('data-anchor-id'),
+    documentScroller:el===doc.scrollingElement,scrollTop:el.scrollTop,scrollLeft:el.scrollLeft,
+    scrollHeight:el.scrollHeight,clientHeight:el.clientHeight,
+    overflowX:s.overflowX,overflowY:s.overflowY,
+    rect:{x:r.x,y:r.y,width:r.width,height:r.height},
+    visible:s.display!=='none'&&s.visibility==='visible'&&Number(s.opacity)>0});
+  }
+  return {url:win.location.href,window:{x:win.scrollX,y:win.scrollY},viewport:{width:win.innerWidth,height:win.innerHeight},rows};
+ });
+}
+
+export function validateScrollArrival(before,after,{minimumMovement=0,targetInViewport=true}={}){
+ assert(Number.isFinite(minimumMovement)&&minimumMovement>=0,'Finite nonnegative movement required');
+ assert.equal(after.url,before.url,'Scroll must preserve the public page identity');
+ assert(before.rows.length&&after.rows.length,'Real target and ancestry required');
+ assert.equal(after.rows.length,before.rows.length,'Scroll ancestry changed');
+ const moved=[];
+ for(const [i,row]of after.rows.entries()){
+  const old=before.rows[i];
+  assert.deepEqual([row.depth,row.anchor,row.documentScroller],[old.depth,old.anchor,old.documentScroller],'Scroll container identity changed');
+  for(const key of ['scrollTop','scrollHeight','clientHeight'])assert(Number.isFinite(row[key])&&Number.isFinite(old[key]),'Finite public scroll metrics required');
+  const scrollable=row.documentScroller||['auto','scroll','overlay'].includes(row.overflowY);
+  if(scrollable&&row.visible&&row.scrollHeight>row.clientHeight&&Math.abs(row.scrollTop-old.scrollTop)>minimumMovement)moved.push(i);
+ }
+ assert(moved.length,'Successful callback without actual scroll movement is not arrival');
+ const t=after.rows[0];assert(t.visible&&t.rect.width>0&&t.rect.height>0,'Target must actually paint');
+ if(targetInViewport){
+  const clips=[{x:0,y:0,...after.viewport},...after.rows.slice(1).filter(r=>['auto','scroll','hidden','clip','overlay'].includes(r.overflowY)).map(r=>r.rect)];
+  for(const r of clips)assert(t.rect.y+t.rect.height>r.y&&t.rect.y<r.y+r.height,'Target must intersect every public clipping container');
+ }
+ return {movedContainers:moved,target:t.rect};
+}