@tsplc/build 0.0.0-stage → 0.1.0

package/python/test_installer_packages.py

@@ -0,0 +1,216 @@
+"""Exercise the installer's extraction against the pinned MSI package inventory."""
+import csv
+import io
+import json
+import os
+import re
+import subprocess
+import sys
+import tempfile
+import unittest
+import zipfile
+from pathlib import Path
+
+
+installer = (Path(__file__).parent.parent / 'docker' / 'install' / 'install.sh').read_text()
+marker = 'python3 - "$msi" "$work/setup-files.tsv" "$WINEPREFIX/drive_c" <<\'PY\'\n'
+extractor = installer.split(marker, 1)[1].split('\nPY\n', 1)[0]
+
+# These identities are from the SP22 Patch 3 MSI's ISSetupFile table.
+packages = {
+    'CODESYS Scripting 4.2.0.0': 'scripting',
+    'CODESYS RISC Front End 4.0.2.0': 'risc',
+    'CODESYS Code Generator ARM64 4.0.1.0': 'arm64',
+    'CODESYS Library Dependency Inspection 1.1.0.0': 'library-inspection',
+    'CODESYS Base Libraries 4.0.1.0': 'base-libraries',
+    'CODESYS Visualization Support 4.7.0.0': 'visualization-support',
+    'CODESYS Math Libraries 4.0.0.0': 'math-libraries',
+    'CODESYS Recipes 4.7.0.0': 'recipes',
+    'CODESYS Trace 4.4.0.0': 'trace',
+    'CODESYS Communication 4.8.0.0': 'communication',
+    'CODESYS Visualization 4.10.0.0': 'visualization',
+    'CODESYS Ethernet Adapter 4.2.0.0': 'ethernet-adapter',
+    'CODESYS EDS Import 4.3.0.0': 'eds-import',
+    'CODESYS NetX 4.1.0.0': 'netx',
+    'CODESYS EtherNetIP 4.9.1.0': 'ethernetip',
+    'CODESYS SoftMotion 4.20.2.0': 'softmotion',
+}
+
+
+class InstallerPackageTests(unittest.TestCase):
+    def setUp(self):
+        temporary = tempfile.TemporaryDirectory()
+        self.addCleanup(temporary.cleanup)
+        self.root = Path(temporary.name)
+        self.output = self.root / 'output'
+        self.output.mkdir()
+        self.table = self.root / 'setup-files.tsv'
+        self.rows = []
+        for name, output in packages.items():
+            stream = 'ISSetupFile.' + output
+            self.rows.append({'FileName': 'Packages\\' + name + '.package', 'Stream': stream})
+            with zipfile.ZipFile(self.root / stream, 'w') as archive:
+                archive.writestr('package.manifest', '<Package/>')
+        tool = self.root / 'msiinfo'
+        tool.write_text(
+            '#!' + sys.executable + '\n'
+            'import pathlib, sys\n'
+            'sys.stdout.buffer.write((pathlib.Path(sys.argv[2]) / sys.argv[3]).read_bytes())\n'
+        )
+        tool.chmod(0o755)
+
+    def extract(self):
+        with self.table.open('w', newline='') as output:
+            writer = csv.DictWriter(output, ['FileName', 'Stream'], delimiter='\t')
+            writer.writeheader()
+            writer.writerows(self.rows)
+        return subprocess.run(
+            [sys.executable, '-c', extractor, str(self.root), str(self.table), str(self.output)],
+            env={**os.environ, 'PATH': str(self.root) + os.pathsep + os.environ['PATH']},
+            capture_output=True,
+            text=True,
+        )
+
+    def test_extracts_complete_symbol_publishing_dependencies_in_installable_order(self):
+        result = self.extract()
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertEqual(
+            {path.stem for path in self.output.iterdir()},
+            set(packages.values()),
+        )
+        # Component selection must preserve the original vendor archive bytes.
+        for name in packages.values():
+            self.assertEqual(
+                (self.output / (name + '.package')).read_bytes(),
+                (self.root / ('ISSetupFile.' + name)).read_bytes(),
+            )
+        order = re.search(r'for package in (.+); do', installer).group(1).split()
+        self.assertEqual(set(order), set(packages.values()))
+        self.assertLess(order.index('library-inspection'), order.index('math-libraries'))
+        for prerequisite in (
+            'visualization-support', 'trace', 'recipes', 'communication',
+            'base-libraries', 'math-libraries',
+        ):
+            self.assertLess(order.index(prerequisite), order.index('visualization'))
+
+    def test_visualization_uses_official_headless_components(self):
+        self.assertIn('set "packageComponents="', installer)
+        self.assertIn(
+            'if "%~1"=="visualization" set "packageComponents=--components=2;3;4"',
+            installer,
+        )
+        self.assertIn('"C:\\%~1.package" %packageComponents%', installer)
+
+    def test_rejects_missing_visualization_prerequisite_before_package_installation(self):
+        self.rows = [row for row in self.rows if row['Stream'] != 'ISSetupFile.trace']
+        result = self.extract()
+        self.assertNotEqual(result.returncode, 0)
+        self.assertIn('Missing bundled packages: Packages\\CODESYS Trace 4.4.0.0.package', result.stderr)
+
+    def test_rejects_corrupt_embedded_package_data(self):
+        archive = io.BytesIO()
+        with zipfile.ZipFile(archive, 'w') as package:
+            package.writestr('package.manifest', 'unchanged manifest')
+        corrupted = archive.getvalue().replace(b'unchanged manifest', b'corrupted manifest', 1)
+        (self.root / 'ISSetupFile.visualization').write_bytes(corrupted)
+        result = self.extract()
+        self.assertNotEqual(result.returncode, 0)
+        self.assertIn('Corrupt package: Packages\\CODESYS Visualization 4.10.0.0.package', result.stderr)
+
+    def test_generated_package_command_captures_windows_status_before_printing(self):
+        prefix = self.output / 'drive_c'
+        prefix.mkdir()
+        start = installer.index("printf '%s\\r\\n' '@echo off'")
+        end = installer.index('# Symbol publishing', start)
+        result = subprocess.run(
+            ['sh', '-eu', '-c', installer[start:end]],
+            env={**os.environ, 'WINEPREFIX': str(self.output)},
+            capture_output=True, text=True,
+        )
+        self.assertEqual(result.returncode, 0, result.stderr)
+        command = (prefix / 'install-package.cmd').read_bytes().decode().splitlines()
+        call = next(index for index, line in enumerate(command) if line.startswith('PackageManagerCLI.exe '))
+        self.assertEqual(command[call + 1], 'set "packageStatus=%errorlevel%"')
+        self.assertEqual(command[call + 2],
+            'if not "%packageStatus%"=="0" echo PackageManagerCLI Windows exit status: %packageStatus%')
+        self.assertEqual(command[call + 3], 'exit /b %packageStatus%')
+
+    def run_package_loop(self, failed_package, log_bytes='Finalizing the original package'.encode('utf-16'), failed_logger=False):
+        prefix = self.output / 'drive_c'
+        prefix.mkdir()
+        log = prefix / 'package-install.log'
+        if log_bytes is None:
+            log.mkdir()  # A path that exists but cannot be read as a log file.
+        else:
+            log.write_bytes(log_bytes)
+        calls = self.root / 'calls.jsonl'
+        tool = self.root / 'timeout'
+        tool.write_text(
+            '#!' + sys.executable + '\n'
+            'import json, os, pathlib, shlex, sys\n'
+            'command = sys.argv[sys.argv.index("-c") + 1]\n'
+            'package = shlex.split(command)[-1]\n'
+            'debug = os.environ.get("WINEDEBUG", "")\n'
+            'with pathlib.Path(os.environ["INSTALLER_TEST_CALLS"]).open("a") as out:\n'
+            ' out.write(json.dumps({"package": package, "debug": debug}) + "\\n")\n'
+            'if package == os.environ["INSTALLER_TEST_FAILURE"]:\n'
+            ' if "err+seh" in debug: print("fixture err:seh:NtRaiseException Unhandled exception code c0000005", file=sys.stderr)\n'
+            ' sys.exit(5)\n'
+        )
+        tool.chmod(0o755)
+        if failed_logger:
+            logger = self.root / 'python3'
+            logger.write_text('#!/bin/sh\necho "Fixture log helper failed" >&2\nexit 19\n')
+            logger.chmod(0o755)
+        start = installer.index('for package in ')
+        end = installer.index('\ndone\n', start) + len('\ndone\n')
+        # Exercise the real shell failure/logging loop with a controlled process result.
+        script = installer[:installer.index('work=/tmp/codesys-setup')] + installer[start:end]
+        result = subprocess.run(
+            ['sh', '-c', script],
+            env={**os.environ, 'WINEPREFIX': str(self.output), 'WINEDEBUG': '-all',
+                'PATH': str(self.root) + os.pathsep + os.environ['PATH'],
+                'INSTALLER_TEST_CALLS': str(calls), 'INSTALLER_TEST_FAILURE': failed_package},
+            capture_output=True, text=True,
+        )
+        return result, [json.loads(line) for line in calls.read_text().splitlines()]
+
+    def test_package_failure_keeps_exit_status_and_fatal_diagnostics_without_continuing(self):
+        result, calls = self.run_package_loop('visualization-support')
+        self.assertEqual(result.returncode, 5)
+        self.assertIn('Unhandled exception code c0000005', result.stderr)
+        self.assertIn('Package visualization-support installer exited with status 5', result.stdout)
+        self.assertIn('Finalizing the original package', result.stdout)
+        self.assertEqual(calls[-1]['package'], 'visualization-support')
+        self.assertNotIn('Installed visualization-support package', result.stdout)
+        self.assertTrue(all(call['debug'] == '-all,err+seh' for call in calls))
+
+    def test_successful_package_loop_remains_successful(self):
+        result, calls = self.run_package_loop('')
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertEqual({call['package'] for call in calls}, set(packages.values()))
+        self.assertEqual(result.stdout.count('Installed '), len(packages))
+        self.assertEqual(result.stderr, '')
+
+    def test_truncated_utf16_log_never_masks_package_failure(self):
+        result, calls = self.run_package_loop('visualization-support', b'\xff\xfe\x00')
+        self.assertEqual(result.returncode, 5)
+        self.assertIn('Package visualization-support installer exited with status 5', result.stdout)
+        self.assertNotIn('UnicodeDecodeError', result.stderr)
+        self.assertEqual(calls[-1]['package'], 'visualization-support')
+
+    def test_unreadable_package_log_never_masks_package_failure(self):
+        result, calls = self.run_package_loop('visualization-support', None)
+        self.assertEqual(result.returncode, 5)
+        self.assertIn('Could not read package install log', result.stderr)
+        self.assertEqual(calls[-1]['package'], 'visualization-support')
+
+    def test_failed_log_helper_never_masks_package_failure(self):
+        result, calls = self.run_package_loop('visualization-support', failed_logger=True)
+        self.assertEqual(result.returncode, 5)
+        self.assertIn('Fixture log helper failed', result.stderr)
+        self.assertEqual(calls[-1]['package'], 'visualization-support')
+
+
+if __name__ == '__main__':
+    unittest.main()

package/python/test_installer_verification.py

@@ -0,0 +1,307 @@
+import importlib.util
+import io
+import json
+import os
+import runpy
+import subprocess
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+from contextlib import redirect_stderr, redirect_stdout
+from types import SimpleNamespace
+from unittest.mock import Mock, patch
+
+
+path = Path(__file__).parent.parent / 'docker' / 'install' / 'verify.py'
+spec = importlib.util.spec_from_file_location('installer_verification', path)
+verification = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(verification)
+
+
+# The bundled ARM64 Virtual Control description, which leaves byte-addressing at its default.
+DEVICE_DESCRIPTION = (
+    Path(__file__).parent.parent / 'docker' / 'install' / 'device' / 'codesyscontrol.devdesc.xml'
+).read_text(encoding='utf-8')
+
+
+def target_setting(name, value):
+    return (
+        '<ts:section name="memory-layout"><ts:setting name="{0}" type="boolean" access="hide">'
+        '<ts:value>{1}</ts:value></ts:setting></ts:section>'
+    ).format(name, value)
+
+
+class InstallerVerificationTests(unittest.TestCase):
+    def setUp(self):
+        patcher = patch.dict(sys.modules, {
+            'System': SimpleNamespace(Guid=lambda value: value),
+        })
+        patcher.start()
+        self.addCleanup(patcher.stop)
+        self.description = DEVICE_DESCRIPTION
+        opener = patch.object(io, 'open', side_effect=lambda path, encoding: io.StringIO(self.description))
+        opener.start()
+        self.addCleanup(opener.stop)
+        self.events = []
+        self.messages = []
+        self.program = SimpleNamespace(
+            textual_declaration=SimpleNamespace(replace=Mock()),
+            textual_implementation=SimpleNamespace(replace=Mock()),
+        )
+        self.task = SimpleNamespace(pous=SimpleNamespace(add=Mock()))
+        self.manager = SimpleNamespace(
+            get_libraries=Mock(side_effect=lambda **args: self.events.append('libraries')),
+        )
+        task_configuration = SimpleNamespace(create_task=Mock(return_value=self.task))
+        self.application = SimpleNamespace(
+            create_program=Mock(return_value=self.program),
+            create_task_configuration=Mock(return_value=task_configuration),
+            create_symbol_config=Mock(),
+            get_library_manager=Mock(return_value=self.manager),
+            clean=Mock(side_effect=lambda: self.events.append('clean')),
+            rebuild=Mock(side_effect=lambda: self.events.append('compile')),
+            generate_code=Mock(side_effect=lambda: self.events.append('generate')),
+            create_boot_application=Mock(side_effect=lambda *args: self.events.append('boot')),
+        )
+        self.project = SimpleNamespace(
+            active_application=self.application,
+            add=Mock(),
+            save=Mock(),
+            close=Mock(side_effect=lambda: self.events.append('close')),
+        )
+
+        def opened(*args, **kwargs):
+            self.events.append('open')
+            return self.project
+
+        self.engine = SimpleNamespace(
+            projects=SimpleNamespace(
+                create=Mock(return_value=self.project),
+                open=Mock(side_effect=opened),
+            ),
+            device_repository=SimpleNamespace(
+                import_device=Mock(), sources=['repository'],
+                create_device_identification=lambda *identity: identity, get_device=Mock(return_value=object()),
+            ),
+            KindOfTask=SimpleNamespace(Cyclic='cyclic'),
+            Severity=SimpleNamespace(Error=1, FatalError=2),
+            ScriptPromptHandling=SimpleNamespace(LogPrompts='log'),
+            system=SimpleNamespace(
+                get_message_categories=lambda: ['compiler', 'libraries'],
+                get_message_objects=lambda category, severity: self.messages if category == 'libraries' else [],
+                clear_messages=lambda category: self.messages.clear(),
+                delay=Mock(side_effect=lambda duration: self.events.append('delay')),
+            ),
+        )
+
+    def test_compiles_published_program_for_each_controller_and_reopens_the_project(self):
+        verification.verify(self.engine)
+        self.assertEqual(
+            [call.kwargs['path'] for call in self.engine.device_repository.import_device.call_args_list],
+            [r'C:\codesys-device\codesyscontrol.devdesc.xml', r'C:\codesys-device-linux-sl\codesyscontrol.devdesc.xml'],
+        )
+        self.assertEqual([call.args for call in self.project.add.call_args_list], [
+            ('Device', 4096, '0000 1008', '4.22.0.0'), ('Device', 4102, '0000 0005', '4.22.0.0'),
+        ])
+        self.assertIn(
+            "{attribute 'symbol' := 'readwrite'}",
+            self.program.textual_declaration.replace.call_args.args[0],
+        )
+        self.assertEqual(self.task.kind_of_task, 'cyclic')
+        self.assertEqual(self.task.interval, '20')
+        self.task.pous.add.assert_called_with('PLC_PRG')
+        self.assertEqual(self.application.create_symbol_config.call_args.args[:2], (True, True))
+        self.assertEqual(self.events, [
+            'clean', 'compile', 'generate', 'boot', 'close',
+            'open', 'libraries', 'delay', 'close',
+            'clean', 'compile', 'generate', 'boot', 'close',
+        ])
+        self.manager.get_libraries.assert_called_with(recursive=True)
+
+    def test_reads_byte_addressing_like_codesys(self):
+        self.assertFalse(verification.uses_byte_addressing(DEVICE_DESCRIPTION))
+        self.assertTrue(verification.uses_byte_addressing(target_setting('byte-addressing', 'TRUE')))
+        self.assertFalse(verification.uses_byte_addressing(target_setting('byte-addressing', 'false')))
+        self.assertFalse(verification.uses_byte_addressing(target_setting('bit-byte-addressing', 'true')))
+
+    def test_rejects_a_controller_that_numbers_words_by_byte_before_importing_it(self):
+        self.description = target_setting('byte-addressing', 'true')
+        with self.assertRaisesRegex(RuntimeError, 'sets byte-addressing'):
+            verification.verify(self.engine)
+        self.engine.device_repository.import_device.assert_not_called()
+
+    def test_rejects_transitive_library_errors_reported_when_reopening_saved_project(self):
+        def report_late_errors(duration):
+            self.messages.append(SimpleNamespace(
+                text="Could not open library '#VisuShared'.",
+                project=SimpleNamespace(path=r'C:\Managed Libraries\AlarmManager.compiled-library-v3'),
+            ))
+        self.engine.system.delay.side_effect = report_late_errors
+        with self.assertRaisesRegex(
+            RuntimeError,
+            "AlarmManager.compiled-library-v3: Could not open library '#VisuShared'",
+        ):
+            verification.verify(self.engine)
+        self.engine.projects.open.assert_called_once()
+        self.assertEqual(self.project.close.call_count, 2)
+
+    def test_compile_error_stops_before_boot_artifact_and_saved_project_reopen(self):
+        self.application.rebuild.side_effect = lambda: self.messages.append(SimpleNamespace(text='Invalid source'))
+        with self.assertRaisesRegex(RuntimeError, 'Invalid source'):
+            verification.verify(self.engine)
+        self.application.generate_code.assert_not_called()
+        self.application.create_boot_application.assert_not_called()
+        self.engine.projects.open.assert_not_called()
+        self.project.close.assert_called_once()
+
+    def run_verifier_main(self):
+        owner = self
+
+        class Kernel:
+            @property
+            def ExitProcess(self):
+                owner.assertEqual(owner.events, [], 'Bind native exit before compiler work')
+                return lambda status: sys.exit(status)
+
+        output = io.StringIO()
+        errors = io.StringIO()
+        with patch.dict(sys.modules, {
+            'ctypes': SimpleNamespace(windll=SimpleNamespace(kernel32=Kernel())),
+            'scriptengine': self.engine,
+        }), redirect_stdout(output), redirect_stderr(errors):
+            with self.assertRaises(SystemExit) as exit:
+                runpy.run_path(str(path), run_name='__main__')
+        return exit.exception.code, output.getvalue(), errors.getvalue()
+
+    def test_main_prebinds_native_exit_and_returns_zero_after_verification(self):
+        status, output, errors = self.run_verifier_main()
+        self.assertEqual(status, 0)
+        self.assertIn('project reopen: PASS', output)
+        self.assertEqual(errors, '')
+
+    def test_main_keeps_compile_failure_and_returns_one_using_prebound_native_exit(self):
+        self.application.rebuild.side_effect = lambda: self.messages.append(SimpleNamespace(text='Invalid source'))
+        status, output, errors = self.run_verifier_main()
+        self.assertEqual(status, 1)
+        self.assertNotIn('PASS', output)
+        self.assertIn('Invalid source', errors)
+        self.application.create_boot_application.assert_not_called()
+
+
+class InstallerVerificationCommandTests(unittest.TestCase):
+    """Run the maintained shell gate with only Wine's process boundary replaced."""
+
+    def setUp(self):
+        temporary = tempfile.TemporaryDirectory(prefix='tsplc verification ')
+        self.addCleanup(temporary.cleanup)
+        self.root = Path(temporary.name)
+        self.prefix = self.root / 'wine prefix'
+        (self.prefix / 'drive_c').mkdir(parents=True)
+        self.calls = self.root / 'calls.jsonl'
+        timeout = self.root / 'timeout'
+        timeout.write_text(
+            '#!' + sys.executable + '\n'
+            'import json, os, pathlib, sys\n'
+            'prefix = pathlib.Path(os.environ["WINEPREFIX"]) / "drive_c"\n'
+            'for extension, content in json.loads(os.environ["TSPLC_VERIFICATION_FILES"]).items():\n'
+            ' (prefix / ("codesys-verification." + extension)).write_text(content)\n'
+            'with pathlib.Path(os.environ["TSPLC_VERIFICATION_CALLS"]).open("a") as output:\n'
+            ' output.write(json.dumps({"command": sys.argv[1:], "debug": os.environ["WINEDEBUG"]}) + "\\n")\n'
+            'pathlib.Path(sys.argv[-1]).write_text(os.environ["TSPLC_VERIFICATION_TRANSCRIPT"])\n'
+            'print("Fixture vendor verification result")\n'
+            'sys.exit(int(os.environ["TSPLC_VERIFICATION_STATUS"]))\n'
+        )
+        timeout.chmod(0o755)
+        wineserver = self.root / 'wineserver'
+        wineserver.write_text(
+            '#!' + sys.executable + '\n'
+            'import json, os, pathlib, sys\n'
+            'with pathlib.Path(os.environ["TSPLC_VERIFICATION_CALLS"]).open("a") as output:\n'
+            ' output.write(json.dumps({"wineserver": sys.argv[1:]}) + "\\n")\n'
+        )
+        wineserver.chmod(0o755)
+
+    def run_verifier(self, status=0, files=None, transcript='Fixture vendor verification result\n'):
+        if files is None:
+            files = {extension: 'Vendor artifact' for extension in ('project', 'app', 'crc')}
+        result = subprocess.run(
+            ['sh', str(path.with_name('verify.sh'))],
+            env={**os.environ, 'PATH': str(self.root) + os.pathsep + os.environ['PATH'],
+                'WINEPREFIX': str(self.prefix), 'TSPLC_VERIFICATION_STATUS': str(status),
+                'TSPLC_VERIFICATION_FILES': json.dumps(files),
+                'TSPLC_VERIFICATION_TRANSCRIPT': transcript,
+                'TSPLC_VERIFICATION_CALLS': str(self.calls)},
+            capture_output=True, text=True,
+        )
+        calls = [json.loads(line) for line in self.calls.read_text().splitlines()] if self.calls.exists() else []
+        return result, calls
+
+    def test_success_requires_all_boot_files_before_stopping_the_template_wine_server(self):
+        result, calls = self.run_verifier()
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertEqual(calls[0]['debug'], '-all,err+seh')
+        self.assertEqual(calls[0]['command'], [
+            '--foreground', '15m', 'script', '-q', '-e', '-c',
+            "wine cmd /d /c 'C:\\verify.cmd'", str(self.prefix / 'drive_c' / 'codesys-verification.log'),
+        ])
+        self.assertEqual(calls[1:], [{'wineserver': ['-k']}, {'wineserver': ['-w']}])
+        command = (self.prefix / 'drive_c' / 'verify.cmd').read_text()
+        self.assertIn('--runscript="C:\\verify.py"', command)
+        self.assertEqual(command.splitlines()[-1], 'exit /b %errorlevel%')
+
+    def test_vendor_failure_is_preserved_even_when_old_boot_artifacts_exist(self):
+        for extension in ('project', 'app', 'crc'):
+            (self.prefix / 'drive_c' / ('codesys-verification.' + extension)).write_text('Old boot artifact')
+        result, calls = self.run_verifier(status=5, files={})
+        self.assertEqual(result.returncode, 5)
+        self.assertEqual(len(calls), 1)
+
+    def test_old_boot_artifacts_cannot_satisfy_a_process_that_skips_verification(self):
+        for extension in ('project', 'app', 'crc'):
+            (self.prefix / 'drive_c' / ('codesys-verification.' + extension)).write_text('Old boot artifact')
+        result, calls = self.run_verifier(files={})
+        self.assertEqual(result.returncode, 1)
+        self.assertEqual(len(calls), 1)
+
+    def test_native_signal_assertion_rejects_zero_exit_and_fresh_boot_artifacts(self):
+        for ending in ('\r\n', '\r\r\n'):
+            with self.subTest(line_ending=ending):
+                self.calls.write_text('')
+                transcript = ending.join([
+                    'assertion failed [x86_avx_state_ptr->xsave_header.xfeatures == kSupportedXFeatureBits]: ',
+                    '(ThreadContextSignals.cpp:414 rt_sigreturn)',
+                    'Compile complete -- 0 errors, 0 warnings',
+                    '',
+                ])
+                result, calls = self.run_verifier(transcript=transcript)
+                self.assertEqual(result.returncode, 1)
+                self.assertIn('Wine translation aborted', result.stderr)
+                self.assertIn('codesys-verification.log', result.stderr)
+                self.assertEqual(len(calls), 1)
+                self.assertEqual((self.prefix / 'drive_c' / 'codesys-verification.log').read_bytes().decode(), transcript)
+
+    def test_ordinary_compiler_assertion_text_does_not_match_native_signal_failure(self):
+        result, calls = self.run_verifier(transcript='Compiler diagnostic: assertion failed\n')
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertEqual(len(calls), 3)
+
+    def test_missing_or_empty_boot_file_rejects_an_apparently_successful_vendor_exit(self):
+        for extension in ('project', 'app', 'crc'):
+            for content in (None, ''):
+                with self.subTest(extension=extension, content=content):
+                    for artifact in (self.prefix / 'drive_c').glob('codesys-verification.*'):
+                        artifact.unlink()
+                    self.calls.write_text('')
+                    files = {name: 'Vendor artifact' for name in ('project', 'app', 'crc')}
+                    if content is None:
+                        del files[extension]
+                    else:
+                        files[extension] = content
+                    result, calls = self.run_verifier(files=files)
+                    self.assertEqual(result.returncode, 1)
+                    self.assertEqual(len(calls), 1)
+
+
+if __name__ == '__main__':
+    unittest.main()

package/python/test_worker.py

@@ -0,0 +1,142 @@
+import builtins
+import contextlib
+import io
+import json
+import os
+import runpy
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+from types import SimpleNamespace
+from unittest.mock import patch
+from build import CompilerError
+from worker import serve
+
+
+class WorkerTests(unittest.TestCase):
+	def run_worker(self, actions, compile):
+		with tempfile.TemporaryDirectory() as temporary:
+			root = Path(temporary)
+			session = root / "build" / ".codesys" / "worker"
+			session.mkdir(parents=True)
+			commands = []
+			for index, action in enumerate(actions + ["stop"]):
+				command = {"id": str(index), "action": action}
+				if action == "build":
+					output = session.parent / "build"
+					output.mkdir(exist_ok=True)
+					(output / "request.json").write_text(json.dumps({
+						"mode": "build", "objects": [], "project": "BottlingLine.project",
+						
+						"output": "runtime/Application.app", "receipt": "compiled.json",
+						"template": "Template.project", "templateHash": "template-fixture",
+					}))
+				commands.append(command)
+			pending = iter(commands)
+			def wait(milliseconds):
+				(session / "request.json").write_text(json.dumps(next(pending)))
+			engine = SimpleNamespace(system=SimpleNamespace(delay=wait))
+			with patch("worker.build", side_effect=compile):
+				serve(engine, str(session))
+			responses = [json.loads((session / (command["id"] + ".json")).read_text()) for command in commands]
+			errors = [path.read_text() for path in (session.parent / "build").glob("error.txt")]
+			return responses, errors
+
+	def test_handles_multiple_builds_and_health_checks_without_exiting(self):
+		requests = []
+		def compile(engine, request, loaded, workspace):
+			requests.append(request)
+		responses, errors = self.run_worker(["ping", "build", "ping", "build"], compile)
+		self.assertTrue(all(response["ok"] for response in responses))
+		self.assertEqual(errors, [])
+		self.assertEqual(len(requests), 2)
+		self.assertEqual(requests[0]["project"], requests[1]["project"])
+		for request in requests:
+			project = Path(request["project"])
+			self.assertTrue(project.is_absolute())
+			self.assertEqual(Path(request["template"]).parent, project.parent)
+			self.assertEqual(Path(request["output"]).parent.parent, project.parent)
+
+	def test_reports_a_failed_build_and_processes_the_next_request(self):
+		failure = "Fixture compiler failure after writing a receipt"
+		requests = []
+		def compile(engine, request, loaded, workspace):
+			requests.append(request)
+			if len(requests) == 1:
+				Path(request["receipt"]).write_text(json.dumps({"mode": "build"}))
+				raise RuntimeError(failure)
+		responses, errors = self.run_worker(["build", "build"], compile)
+		self.assertFalse(responses[0]["ok"])
+		self.assertIn(failure, responses[0]["error"])
+		self.assertTrue(responses[1]["ok"])
+		self.assertTrue(responses[2]["ok"])
+		self.assertEqual(len(errors), 1)
+		self.assertIn(failure, errors[0])
+
+	def test_preserves_structured_compiler_diagnostics_in_failure_response(self):
+		diagnostics = [{"text": "Invalid type", "position": "18446744073709551615", "positionText": "vendor context", "object": None}]
+		def compile(engine, request, loaded, workspace):
+			raise CompilerError(diagnostics)
+		responses, errors = self.run_worker(["build", "ping"], compile)
+		self.assertEqual(responses[0]["diagnostics"], diagnostics)
+		self.assertIn("Invalid type", responses[0]["error"])
+		self.assertTrue(responses[1]["ok"])
+		self.assertIn("Invalid type", errors[0])
+
+
+class WorkerMainTests(unittest.TestCase):
+	def test_native_exit_is_preloaded_before_serving_and_preserves_success_and_failure(self):
+		worker_path = Path(__file__).with_name("worker.py").resolve()
+		for native in (True, False):
+			for invalid in (True, False):
+				with self.subTest(native=native, invalid=invalid), tempfile.TemporaryDirectory() as temporary:
+					root = Path(temporary)
+					(root / "request.json").write_text("{invalid" if invalid else json.dumps({"id": "stop", "action": "stop"}))
+					phase = "startup"
+					events = []
+					def exited(api, code):
+						events.append((api, phase, code))
+						raise SystemExit(code)
+					class NativeLibrary:
+						@property
+						def ExitProcess(self):
+							events.append(("bind", phase))
+							return lambda code: exited("native", code)
+					ctypes = SimpleNamespace(windll=SimpleNamespace(kernel32=NativeLibrary()))
+					engine = SimpleNamespace(
+						system=SimpleNamespace(exit=lambda code: exited("scriptengine", code)),
+						ScriptPromptHandling=SimpleNamespace(LogPrompts="LogPrompts"))
+					actual_import = builtins.__import__
+					def imported(name, *args, **kwargs):
+						if name == "ctypes":
+							events.append(("import", phase))
+							return ctypes
+						return actual_import(name, *args, **kwargs)
+					def profiled(frame, event, _argument):
+						nonlocal phase
+						if frame.f_code.co_filename == str(worker_path) and frame.f_code.co_name == "serve":
+							if event == "call": phase = "serving"
+							elif event == "return": phase = "after-serve"
+					previous_profile = sys.getprofile()
+					previous_path = list(sys.path)
+					try:
+						with patch.dict(sys.modules, {"scriptengine": engine}), patch.dict(os.environ, {
+							"CODESYS_BUILD_SESSION": str(root), "CODESYS_BUILD_NATIVE_EXIT": str(native).lower(),
+						}), patch("builtins.__import__", side_effect=imported), contextlib.redirect_stderr(io.StringIO()):
+							sys.setprofile(profiled)
+							with self.assertRaises(SystemExit) as result:
+								runpy.run_path(str(worker_path), run_name="__main__")
+					finally:
+						sys.setprofile(previous_profile)
+						sys.path[:] = previous_path
+					self.assertEqual(result.exception.code, int(invalid))
+					self.assertEqual(events, ([
+						("import", "startup"), ("bind", "startup"), ("native", "after-serve", int(invalid)),
+					] if native else [("scriptengine", "after-serve", int(invalid))]))
+					if not invalid:
+						self.assertEqual(json.loads((root / "stop.json").read_text()), {"id": "stop", "ok": True})
+
+
+if __name__ == "__main__":
+	unittest.main()