"""Independent extraction/replay of the frozen legacy APL component.

Only the initializer prefix before ``self.base`` and two original APL update
statements are executed. No old simulator is instantiated, no learning code is
executed, and no frozen artifact is written. The Torch replay is a component
oracle, not an independent CPU whole-brain closed-loop oracle.
"""
from __future__ import annotations

import argparse
import ast
import copy
from functools import lru_cache
import hashlib
import json
import math
from pathlib import Path
import struct
import types

import numpy as np
import pyarrow.parquet as pq
import torch


ROOT = Path('/data/digital-drosophila')
CANONICAL = ROOT/'datasets/male-cns-v1.0/processed/neuron-only'
SOURCE = ROOT/'models/male-cns-lif/deterministic-runtime-v2/phase4p_revalidate.py'
SOURCE_SHA256 = 'c7e693a2da70acdce4f53af5c2853e52e8333acc93f88a46a5e8083eac639346'
N, A, K = 166700, 2, 4064
BUNDLE_ARRAYS = {
    'input_matrix': (np.float32, (A, N)), 'output_matrix': (np.float32, (A, K)),
    'input_raw': (np.float32, (A, N)), 'output_raw': (np.float32, (A, K)),
    'kc_globals': (np.int32, (K,)), 'apl_globals': (np.int32, (A,)),
    'pn_globals': (np.int32, None), 'apl_out_ids': (np.int64, (5845,)),
}


def require(condition, message):
    if not condition:
        raise ValueError(message)


def digest(path):
    h = hashlib.sha256()
    with Path(path).open('rb') as source:
        for block in iter(lambda: source.read(8 << 20), b''):
            h.update(block)
    return h.hexdigest()


def array_hash(value):
    return hashlib.sha256(np.ascontiguousarray(value).tobytes()).hexdigest()


def bit_equal(a, b):
    a, b = np.asarray(a), np.asarray(b)
    return bool(a.dtype == b.dtype and a.shape == b.shape and
        np.array_equal(np.ascontiguousarray(a).view(np.uint8),
                       np.ascontiguousarray(b).view(np.uint8)))


def save(path, value):
    path = Path(path)
    path.parent.mkdir(parents=True, exist_ok=True)
    with path.open('x', encoding='utf-8') as target:
        json.dump(value, target, indent=2, sort_keys=True, allow_nan=False)
        target.write('\n')


class ReadOnlyNamespace:
    """The extracted prefix can read rt, but cannot mutate or add rt fields."""
    def __init__(self, **values):
        object.__setattr__(self, '_values', types.MappingProxyType(values))

    def __getattr__(self, name):
        return self._values[name]

    def __setattr__(self, name, value):
        raise AttributeError('Read-only canonical runtime view')


def _code(nodes, filename):
    module = ast.Module(body=copy.deepcopy(nodes), type_ignores=[])
    return compile(ast.fix_missing_locations(module), str(filename), 'exec')


def _self_attribute(target, field):
    return isinstance(target, ast.Attribute) and isinstance(target.value, ast.Name) and \
        target.value.id == 'self' and target.attr == field


def extract_statements():
    data = SOURCE.read_bytes()
    require(hashlib.sha256(data).hexdigest() == SOURCE_SHA256, 'Frozen legacy source SHA-256 mismatch')
    text = data.decode('utf-8')
    tree = ast.parse(text, filename=str(SOURCE))
    classes = [node for node in tree.body if isinstance(node, ast.ClassDef) and node.name == 'DeterministicAPLSim']
    require(len(classes) == 1, 'Expected exactly one frozen DeterministicAPLSim')
    methods = {node.name: node for node in classes[0].body if isinstance(node, ast.FunctionDef)}
    init, run = methods['__init__'], methods['run']
    cuts = [i for i, node in enumerate(init.body) if isinstance(node, ast.Assign) and
            any(_self_attribute(target, 'base') for target in node.targets)]
    require(len(cuts) == 1 and cuts[0] > 0, 'Missing/ambiguous self.base cutoff')
    prefix = init.body[:cuts[0]]
    # Executing no import or file-writing call is allowed in the extracted prefix.
    require(not any(isinstance(node, (ast.Import, ast.ImportFrom, ast.With, ast.AsyncWith))
                    for stmt in prefix for node in ast.walk(stmt)), 'Unexpected side-effect construct in initializer prefix')
    expressions = [node for node in ast.walk(run) if isinstance(node, ast.Expr) and
        isinstance(node.value, ast.Call) and isinstance(node.value.func, ast.Attribute) and
        node.value.func.attr == 'add_' and isinstance(node.value.func.value, ast.Call) and
        isinstance(node.value.func.value.func, ast.Attribute) and
        isinstance(node.value.func.value.func.value, ast.Name) and
        node.value.func.value.func.value.id == 'apl_state' and node.value.func.value.func.attr == 'mul_']
    inhibition = [node for node in ast.walk(run) if isinstance(node, ast.Assign) and
                  any(isinstance(target, ast.Name) and target.id == 'inhibition' for target in node.targets)]
    decay = [node for node in ast.walk(run) if isinstance(node, ast.Assign) and
             any(isinstance(target, ast.Name) and target.id == 'apl_decay' for target in node.targets)]
    require(len(expressions) == len(inhibition) == len(decay) == 1, 'Ambiguous frozen APL operator extraction')
    require(expressions[0].lineno < inhibition[0].lineno, 'Unexpected frozen APL update order')
    rhs = inhibition[0].value
    require(isinstance(rhs, ast.BinOp) and isinstance(rhs.op, ast.Mult), 'Unexpected inhibition gain expression')
    gain_expression = ast.Expression(copy.deepcopy(rhs.right))
    provenance = {'source': str(SOURCE), 'sha256': SOURCE_SHA256,
        'initializer_line_start': prefix[0].lineno, 'initializer_line_end': prefix[-1].end_lineno,
        'excluded_self_base_line': init.body[cuts[0]].lineno,
        'decay_line': decay[0].lineno, 'state_update_line': expressions[0].lineno,
        'inhibition_line': inhibition[0].lineno,
        'initializer_source': '\n'.join(ast.get_source_segment(text, node) for node in prefix),
        'decay_source': ast.get_source_segment(text, decay[0]),
        'state_update_source': ast.get_source_segment(text, expressions[0]),
        'inhibition_source': ast.get_source_segment(text, inhibition[0]),
        'learning_initializer_suffix_executed': False, 'original_run_loop_executed': False}
    return (_code(prefix, SOURCE), _code(decay, SOURCE),
            _code([expressions[0], inhibition[0]], SOURCE),
            compile(ast.fix_missing_locations(gain_expression), str(SOURCE), 'eval'), provenance)


def _canonical_files():
    return {name: CANONICAL/path for name, path in {
        'metadata': 'neuron-index/unified-metadata.parquet',
        'indptr': 'gpu/csr-indptr.int64.npy', 'indices': 'gpu/csr-indices.int32.npy',
        'raw': 'gpu/csr-weights.int64.npy'}.items()}


@lru_cache(maxsize=2)
def reconstruct(canonical_hashes, device_name):
    """Cache only reconstructions tied to exact canonical bytes and source hash."""
    files = _canonical_files()
    require(dict(canonical_hashes) == {name: digest(path) for name, path in files.items()},
            'Canonical bytes changed before matrix reconstruction')
    arrays = {name: np.load(files[name], mmap_mode='r', allow_pickle=False)
              for name in ('indptr', 'indices', 'raw')}
    require(arrays['indptr'].dtype == np.int64 and arrays['indices'].dtype == np.int32 and
            arrays['raw'].dtype == np.int64, 'Canonical CSR dtypes changed')
    require(arrays['indptr'].shape == (N + 1,) and arrays['indptr'][-1] == 25582938 and
            arrays['indices'].shape == arrays['raw'].shape == (25582938,), 'Canonical graph shape changed')
    require(int(arrays['raw'].sum()) == 124177617 and bool(np.all(arrays['raw'] > 0)), 'Canonical raw weights changed')
    table = pq.read_table(files['metadata'])
    require(table.num_rows == N, 'Canonical metadata count changed')
    rt = ReadOnlyNamespace(n=N, dt=.1, device=torch.device(device_name), table=table,
        indptr_np=arrays['indptr'], indices_np=arrays['indices'], raw_np=arrays['raw'])
    view = types.SimpleNamespace()
    init_code, decay_code, update_code, gain_code, provenance = extract_statements()
    scope = {'self': view, 'rt': rt, 'np': np, 'torch': torch}
    exec(init_code, scope)
    require(not hasattr(view, 'base') and not hasattr(view, 'identity'), 'Initializer crossed the learning cutoff')
    expected = {'input_matrix': view.input_gpu.detach().cpu().numpy().copy(),
        'output_matrix': view.output_gpu.detach().cpu().numpy().copy(),
        'input_raw': scope['input_matrix'], 'output_raw': scope['output_matrix'],
        'kc_globals': view.kc, 'apl_globals': view.apl, 'pn_globals': view.pn,
        'apl_out_ids': view.apl_out_ids}
    for value in expected.values():
        value.flags.writeable = False
    return view, expected, provenance, (decay_code, update_code, gain_code)


class TorchObservationProxy:
    """Observe the result of the actual extracted torch.mv call unchanged."""
    def __init__(self):
        self.drive = None
        self.calls = 0

    def __getattr__(self, name):
        return getattr(torch, name)

    def mv(self, *args, **kwargs):
        value = torch.mv(*args, **kwargs)
        self.drive = value
        self.calls += 1
        return value


def _up(value):
    return np.nextafter(np.asarray(value, dtype=np.float64), np.inf)


def _add(a, b):
    return _up(np.asarray(a, dtype=np.float64) + np.asarray(b, dtype=np.float64))


def _mul(a, b):
    return _up(np.asarray(a, dtype=np.float64) * np.asarray(b, dtype=np.float64))


def _gamma(count, unit_roundoff):
    require(count * unit_roundoff < 1, 'Gamma bound is undefined')
    # Outward rounding on the division; the denominator is rounded downward.
    numerator = _mul(count, unit_roundoff)
    denominator = np.nextafter(1.0 - numerator, -np.inf)
    return _up(numerator / denominator)


def _positive_dot_upper(state, matrix):
    result = np.zeros(matrix.shape[1], np.float64)
    for index in range(len(state)):
        result = _add(result, _mul(state[index], matrix[index]))
    return result


def _normal_or_zero(value, tiny):
    value = np.asarray(value)
    return bool(np.all((value == 0) | (value >= tiny)))


def _new_metric():
    return {'max_abs_error': 0.0, 'sum_abs_error': 0.0, 'elements': 0,
            'max_relative_error_nonzero_reference': 0.0, 'zero_reference_nonzero_actual': 0,
            'max_error_bound': 0.0, 'max_bound_utilization': 0.0, 'bound_violations': 0}


def _accumulate(metric, actual, reference, bound):
    error = np.abs(np.asarray(actual, np.float64) - reference)
    error_upper = np.where(error == 0, 0.0, _up(error))
    nonzero = reference != 0
    ratio = np.divide(error, np.abs(reference), out=np.zeros_like(error), where=nonzero)
    usage = np.divide(error_upper, bound, out=np.zeros_like(error), where=bound > 0)
    metric['max_abs_error'] = max(metric['max_abs_error'], float(error.max(initial=0)))
    metric['sum_abs_error'] += float(error.sum(dtype=np.float64))
    metric['elements'] += error.size
    metric['max_relative_error_nonzero_reference'] = max(metric['max_relative_error_nonzero_reference'], float(ratio.max(initial=0)))
    metric['zero_reference_nonzero_actual'] += int(np.count_nonzero((~nonzero) & (error != 0)))
    metric['max_error_bound'] = max(metric['max_error_bound'], float(np.max(bound, initial=0)))
    metric['max_bound_utilization'] = max(metric['max_bound_utilization'], float(usage.max(initial=0)))
    metric['bound_violations'] += int(np.count_nonzero(error_upper > bound))


def validate(gpu_case_dir, bundle_dir, out_json):
    """Validate one completed fixture; write one exclusive pure-JSON audit."""
    gpu_case_dir, bundle_dir, out_json = Path(gpu_case_dir), Path(bundle_dir), Path(out_json)
    require(not out_json.exists(), 'Refusing to overwrite an existing component audit')
    report = {'pass_all': False, 'scope': 'Frozen APL component extraction and recorded-spike replay only',
        'independent_cpu_closed_loop_oracle': False, 'brain_or_learning_parameters_changed': False,
        'candidate_function_called': False, 'gpu_case_dir': str(gpu_case_dir), 'bundle_dir': str(bundle_dir)}
    try:
        require(digest(SOURCE) == SOURCE_SHA256, 'Frozen source changed before component validation')
        require(torch.cuda.is_available() and torch.cuda.device_count() == 1 and
                '4090' in torch.cuda.get_device_name(), 'Require the one declared RTX4090')
        environment = {'torch': str(torch.__version__), 'numpy': np.__version__,
            'gpu': torch.cuda.get_device_name(), 'cuda': torch.version.cuda,
            'cuda_matmul_allow_tf32': torch.backends.cuda.matmul.allow_tf32,
            'float32_matmul_precision': torch.get_float32_matmul_precision(),
            'deterministic_algorithms': torch.are_deterministic_algorithms_enabled(),
            'precision_flags_changed': False}
        report['environment'] = environment
        canonical_hashes = tuple(sorted((name, digest(path)) for name, path in _canonical_files().items()))
        view, reconstructed, provenance, code = reconstruct(canonical_hashes, 'cuda:0')
        bundle = {}
        matrix_checks = {}
        for name, (dtype, shape) in BUNDLE_ARRAYS.items():
            value = np.load(bundle_dir/(name+'.npy'), mmap_mode='r', allow_pickle=False)
            require(value.dtype == dtype and value.ndim == len(shape or (0,)) and
                    (shape is None or value.shape == shape), 'Bundle schema mismatch: '+name)
            bundle[name] = value
            matrix_checks[name] = bit_equal(value, reconstructed[name])
        scales = json.loads((bundle_dir/'scales.json').read_text())
        for name in ('input_scale', 'output_scale'):
            matrix_checks[name] = struct.pack('<d', float(scales[name])) == struct.pack('<d', float(getattr(view, name)))
        report['matrix_checks'] = matrix_checks
        report['extracted_source'] = provenance
        report['canonical_sha256'] = dict(canonical_hashes)
        report['bundle_sha256'] = {name+'.npy': digest(bundle_dir/(name+'.npy')) for name in BUNDLE_ARRAYS}
        report['bundle_sha256']['scales.json'] = digest(bundle_dir/'scales.json')
        report['reconstructed_array_sha256'] = {name: array_hash(value) for name, value in reconstructed.items()}
        bundle_provenance = json.loads((bundle_dir/'provenance.json').read_text())
        require(Path(bundle_provenance['canonical_root']).resolve() == CANONICAL.resolve(),
                'Bundle provenance names another canonical dataset')
        report['bundle_sha256']['provenance.json'] = digest(bundle_dir/'provenance.json')
        require(all(matrix_checks.values()), 'Bundle differs from the actual frozen initializer prefix')

        traces = {name: np.load(gpu_case_dir/('apl-'+name+'.float32.npy'), mmap_mode='r', allow_pickle=False)
                  for name in ('drive', 'state', 'inhibition')}
        steps = len(traces['state'])
        require(steps > 0, 'Empty APL trajectory cannot pass')
        for name, width in (('drive', A), ('state', A), ('inhibition', K)):
            require(traces[name].dtype == np.float32 and traces[name].shape == (steps, width) and
                    bool(np.isfinite(traces[name]).all()) and bool(np.all(traces[name] >= 0)), 'Invalid APL trace: '+name)
        summary = json.loads((gpu_case_dir/'summary.json').read_text())
        require(summary.get('complete') is True and summary.get('pass_all') is True and
                summary.get('steps') == steps and summary.get('completed_ticks') == steps,
                'GPU fixture did not complete its internal execution checks')
        with np.load(gpu_case_dir/'state.npz', allow_pickle=False) as archive:
            event_step, event_node = archive['step'].copy(), archive['neuron_idx'].copy()
        require(event_step.dtype == event_node.dtype == np.int32 and event_step.ndim == 1 and
                event_step.shape == event_node.shape, 'Invalid sparse actual spike event schema')
        require(bool(np.all((event_step >= 0) & (event_step < steps))) and
                bool(np.all((event_node >= 0) & (event_node < N))), 'Sparse event outside its clock/identity range')
        require(np.array_equal(np.lexsort((event_node, event_step)), np.arange(len(event_step))), 'Actual events not sorted')
        keys = event_step.astype(np.int64)*N + event_node
        require(len(keys) < 2 or bool(np.all(np.diff(keys) > 0)), 'Duplicate actual spikes')
        boundaries = np.searchsorted(event_step, np.arange(steps + 1))

        proxy = TorchObservationProxy()
        # Reconstructed original matrices are already on the original GPU/dtype.
        replay_rt = types.SimpleNamespace(spike_u8=torch.zeros(N, dtype=torch.uint8, device=view.device))
        shadow = types.SimpleNamespace(input_gpu=view.input_gpu, output_gpu=view.output_gpu, rt=replay_rt, dt=.1)
        scope = {'self': shadow, 'np': np, 'math': math, 'torch': proxy,
                 'apl_state': torch.zeros(A, dtype=torch.float32, device=view.device)}
        decay_code, update_code, gain_code = code
        exec(decay_code, scope)
        decay32 = np.float32(scope['apl_decay'])
        gain32 = np.float32(eval(gain_code, {'np': np}))
        require(0 < decay32 < 1 and gain32 > 0, 'Invalid extracted positive APL constants')
        exact = {name: True for name in traces}
        first_difference = None
        I64 = np.asarray(bundle['input_matrix'], np.float64)
        O64 = np.asarray(bundle['output_matrix'], np.float64)
        require(bool(np.all(I64 >= 0)) and bool(np.all(O64 >= 0)), 'Positive-sum theory requires nonnegative matrices')
        d, q = float(decay32), float(gain32)
        u32, u64 = 2.0**-24, 2.0**-53
        gd32, gd64 = _gamma(N-1, u32), _gamma(N-1, u64)
        g232, g264 = _gamma(2, u32), _gamma(2, u64)
        gh32, gh64 = _gamma(2*A+1, u32), _gamma(2*A+1, u64)
        state64 = np.zeros(A, np.float64)
        e32 = np.zeros(A, np.float64)
        e64 = np.zeros(A, np.float64)
        previous32 = np.zeros(A, np.float64)
        statistics = {name: _new_metric() for name in traces}
        normal_arithmetic = _normal_or_zero(I64, np.finfo(np.float32).tiny) and _normal_or_zero(O64, np.finfo(np.float32).tiny)
        max_active_terms = 0
        with torch.no_grad():
            for tick in range(steps):
                fired = event_node[boundaries[tick]:boundaries[tick+1]]
                replay_rt.spike_u8.zero_()
                if len(fired):
                    replay_rt.spike_u8[torch.as_tensor(fired.astype(np.int64), device=view.device)] = 1
                before_calls = proxy.calls
                exec(update_code, scope)
                require(proxy.calls == before_calls + 1, 'Original update did not issue exactly one mv')
                actual = {'drive': proxy.drive.detach().cpu().numpy(),
                    'state': scope['apl_state'].detach().cpu().numpy(),
                    'inhibition': scope['inhibition'].detach().cpu().numpy()}
                for name in traces:
                    same = bit_equal(actual[name], traces[name][tick])
                    exact[name] &= same
                    if not same and first_difference is None:
                        first_difference = {'tick': tick, 'field': name,
                            'max_abs_error': float(np.max(np.abs(actual[name].astype(np.float64)-traces[name][tick])))}
                # Float64 reference is measurement only and never feeds either brain.
                selected = I64[:, fired]
                drive64 = selected.sum(axis=1, dtype=np.float64)
                max_active_terms = max(max_active_terms, int(np.count_nonzero(selected, axis=1).max(initial=0)))
                Dupper = _up(drive64 / np.nextafter(1.0-gd64, -np.inf))
                drive_bound = _add(_mul(gd32, Dupper), _mul(gd64, Dupper))
                state32 = traces['state'][tick].astype(np.float64)
                normal_arithmetic &= _normal_or_zero(d*previous32, np.finfo(np.float32).tiny)
                normal_arithmetic &= _normal_or_zero(O64*state32[:, None], np.finfo(np.float32).tiny)
                e32 = _add(_mul(d, e32), _add(_mul(g232, _add(_mul(d, previous32), Dupper)),
                    _mul(1.0+u32, _mul(gd32, Dupper))))
                e64 = _add(_mul(d, e64), _add(_mul(g264, _add(_mul(d, state64), Dupper)),
                    _mul(1.0+u64, _mul(gd64, Dupper))))
                state64 = d*state64 + drive64
                inhibition64 = np.matmul(state64, O64)*q
                h32bound = _add(_mul(q, _positive_dot_upper(e32, O64)),
                    _mul(gh32, _mul(q, _positive_dot_upper(state32, O64))))
                h64bound = _add(_mul(q, _positive_dot_upper(e64, O64)),
                    _mul(gh64, _mul(q, _positive_dot_upper(state64, O64))))
                normal_arithmetic &= _normal_or_zero(q*np.matmul(state32, O64), np.finfo(np.float32).tiny)
                _accumulate(statistics['drive'], traces['drive'][tick], drive64, drive_bound)
                _accumulate(statistics['state'], traces['state'][tick], state64, _add(e32, e64))
                _accumulate(statistics['inhibition'], traces['inhibition'][tick], inhibition64, _add(h32bound, h64bound))
                previous32 = state32
        for metric in statistics.values():
            metric['mean_abs_error'] = metric.pop('sum_abs_error') / metric['elements']
        theory_applicable = bool(normal_arithmetic and not environment['cuda_matmul_allow_tf32'] and
                                 environment['float32_matmul_precision'] == 'highest')
        report.update(steps=steps, actual_spike_events=len(event_step),
            ast_replay_bitwise_exact=exact, first_ast_difference=first_difference,
            value_units={'drive': 'legacy normalized-contact spike drive',
                         'state': 'legacy normalized-drive accumulator', 'inhibition': 'legacy mV'},
            decay_f32_bits=f'{int(decay32.view(np.uint32)):08x}', gain_f32_bits=f'{int(gain32.view(np.uint32)):08x}',
            float64_measurement=statistics,
            theoretical_bound={'applicable': theory_applicable, 'normal_or_zero_arithmetic': bool(normal_arithmetic),
                'gamma_definition': 'gamma_n=(n*u)/(1-n*u), upward-rounded; u32=2^-24,u64=2^-53',
                'drive_n': N-1, 'max_observed_nonzero_drive_terms': max_active_terms,
                'gamma_drive_f32': float(gd32), 'gamma_drive_f64': float(gd64),
                'state_recurrence': 'E_p[t] <= d*E_p[t-1] + gamma_2,p*(d*abs(s_p[t-1])+D_upper) + (1+u_p)*gamma_(N-1),p*D_upper',
                'output_bound': 'q*sum(B*E_p) + gamma_(2*A+1),p*q*sum(B*abs(s_p)); compare with E32+E64',
                'assumptions': 'nonnegative f32 matrices, spikes exactly 0/1, fixed stored f32 decay/gain, normal finite RN binary32/64 operations; no reduced-precision matmul',
                'bound_arithmetic': 'Each positive bound operation is rounded toward +infinity via nextafter; denominator toward -infinity',
                'tolerance_fitted_to_observed_error': False,
                'f64_values_used_to_drive_brain': False,
                'no_cpu_gpu_bitwise_expectation_for_f64_measurement': True},
            input_sha256={name: digest(gpu_case_dir/name) for name in
                ('state.npz', 'summary.json', 'apl-drive.float32.npy', 'apl-state.float32.npy', 'apl-inhibition.float32.npy')})
        report['pass_all'] = bool(all(matrix_checks.values()) and all(exact.values()) and theory_applicable and
                                  all(value['bound_violations'] == 0 for value in statistics.values()))
        report['limitations'] = [
            'AST shadow and candidate use the same original Torch/CUDA primitives; this validates preserved component semantics, not an independent CPU whole-brain oracle.',
            'Float64 is a non-feedback mathematical measurement with explicit gamma error bounds, not replacement APL dynamics.',
            'Replay uses the recorded actual spike train; it does not establish equivalence for untested closed-loop inputs.',
            'The N-1 positive-sum bound is deliberately conservative; passing it does not prove physiological validity or learning.']
        save(out_json, report)
        return report
    except Exception as error:
        report['error'] = {'type': type(error).__name__, 'message': str(error)}
        if not out_json.exists():
            save(out_json, report)
        raise


if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument('gpu_case_dir', type=Path)
    parser.add_argument('bundle_dir', type=Path)
    parser.add_argument('out_json', type=Path)
    args = parser.parse_args()
    result = validate(args.gpu_case_dir, args.bundle_dir, args.out_json)
    print(json.dumps({'pass_all': result['pass_all'], 'steps': result['steps']}), flush=True)
    if not result['pass_all']:
        raise SystemExit(1)