| """Bounded staged input discovery from pinned inventory and inert build declarations.""" |
| import json |
| import posixpath |
|
|
| from build_module_overlay import parse_module_source |
| from chameleon_core.adaptation_contracts import Intake, Residual |
| from chameleon_core.contracts import digest |
| from chameleon_core.entry_capture import capture_entry |
| from chameleon_core.module_resolution import resolve_relative_import |
| from chameleon_core.repository_capture import fetch_bytes, tree_files, verify_package |
| from plan_saved_build import plan_saved_build |
|
|
|
|
| def capture_build_inputs(source, entry, importer, *, additional_paths=(), fetch=fetch_bytes): |
| """Runs in isolated capture worker; cache frozen GETs and cap the entire chain.""" |
| cache, trees, plans = {}, {}, [] |
| wire = reads = 0 |
| def bounded_fetch(url, limit): |
| nonlocal wire, reads |
| if url not in cache: |
| if reads >= 64: |
| raise Residual('BUILD_DISCOVERY_REQUEST_BUDGET') |
| reads += 1 |
| body = fetch(url, limit) |
| wire += len(body) |
| if len(body) > limit or wire > 6*1024*1024: |
| raise Residual('BUILD_DISCOVERY_WIRE_BUDGET') |
| cache[url] = body |
| if '?recursive=1' in url: |
| tree = json.loads(body) |
| trees[tree['sha']] = tree |
| if len(cache[url]) > limit: |
| raise Residual('BUILD_DISCOVERY_WIRE_BUDGET') |
| return cache[url] |
| paths = sorted(set(additional_paths) | {importer}) |
| previous = None |
| for _ in range(8): |
| package = capture_entry(source, entry, bounded_fetch, additional_paths=paths) |
| repo = package['repository'] |
| if previous and (any(repo[k] != previous[k] for k in ('source', 'commit_sha', 'tree_sha', 'entry')) |
| or any(repo['files'].get(p) != r for p, r in previous['files'].items())): |
| raise Residual('BUILD_DISCOVERY_RECAPTURE_MISMATCH') |
| tree = trees.get(repo['tree_sha']) |
| if tree is None: |
| raise Residual('BUILD_COMPLETE_INVENTORY_REQUIRED') |
| try: |
| plan = discover_build_inputs(package, importer, tree) |
| except ValueError as exc: |
| raise Residual(str(exc)) from exc |
| plans.append(plan) |
| if plan['status'] == 'READY': |
| repo['projection'].update(additional_local_paths=list(additional_paths), |
| build_importer=importer, build_discovered_paths=paths, build_discovery=plans) |
| repo['acquisition'].update(external_reads=reads, wire_bytes=wire) |
| package['digest'] = digest(repo) |
| verify_package(package) |
| return package |
| new_paths = sorted(set(paths) | set(plan['missing_paths'])) |
| if new_paths == paths: |
| raise Residual('BUILD_DISCOVERY_STALLED') |
| paths, previous = new_paths, repo |
| raise Residual('BUILD_DISCOVERY_PASS_BUDGET') |
|
|
|
|
| def discover_build_inputs(package, importer, tree): |
| files = verify_package(package) |
| repo = package['repository'] |
| if tree.get('sha') != repo['tree_sha']: |
| raise ValueError('BUILD_TREE_BINDING_MISMATCH') |
| inventory = tree_files(tree, metadata_only=True) |
| for name, record in repo['files'].items(): |
| if (name not in inventory or inventory[name]['sha'] != record['git_blob_sha'] |
| or inventory[name]['size'] != record['bytes']): |
| raise ValueError('BUILD_HELD_TREE_MISMATCH') |
| if importer not in files or not importer.endswith(('.js', '.mjs')): |
| raise ValueError('BUILD_CAPTURED_IMPORTER_REQUIRED') |
| metadata = {'package.json', 'rollup.config.js'} |
| if not metadata <= inventory.keys(): |
| raise ValueError('BUILD_DECLARATION_FILES_ABSENT') |
| missing = metadata - files.keys() |
| visited, edges = set(), [] |
| if not missing: |
| plan = plan_saved_build(package)['plan'] |
| aliases = {} |
| for row in plan['mappings']: |
| if row['format'] != 'es': |
| continue |
| destination = row.get('destination', row['output']) |
| if destination in aliases or destination in inventory: |
| raise ValueError('BUILD_ALIAS_AMBIGUOUS') |
| aliases[destination] = row['input'] |
| if not aliases: |
| raise ValueError('BUILD_ES_MAPPING_REQUIRED') |
| pending = [importer] |
| while pending: |
| current = pending.pop() |
| if current in visited: |
| continue |
| visited.add(current) |
| if len(visited) > 64: |
| raise ValueError('BUILD_GRAPH_BUDGET') |
| if current not in inventory: |
| raise ValueError('BUILD_DECLARED_INPUT_ABSENT') |
| if current not in files: |
| missing.add(current) |
| continue |
| syntax = parse_module_source(files[current]) |
| if syntax['dynamic_imports']: |
| raise ValueError('BUILD_DYNAMIC_IMPORT_UNSUPPORTED') |
| for ref in syntax['references']: |
| |
| virtual = {**inventory, **{p: {'sha': '0'*40, 'size': 0} for p in aliases if p not in inventory}} |
| resolution = resolve_relative_import(current, ref['specifier'], virtual) |
| if resolution['status'] != 'RESOLVED': |
| raise ValueError('BUILD_MODULE_' + resolution['status']) |
| destination = resolution['matches'][0]['path'] |
| source = destination if destination in inventory else aliases[destination] |
| if not posixpath.splitext(source)[1] in ('.js', '.mjs'): |
| raise ValueError('BUILD_SOURCE_TYPE_UNSUPPORTED') |
| edges.append({'importer': current, 'specifier': ref['specifier'], |
| 'destination': destination, 'source': source}) |
| pending.append(source) |
| paths = sorted(set(repo.get('projection', {}).get('additional_local_paths', [])) | missing) |
| if len(paths) > 16: |
| raise ValueError('BUILD_CAPTURE_PATH_BUDGET') |
| intake = Intake(source=repo['source']+'/tree/'+repo['commit_sha'], source_type='repository', |
| repository_scope='entry', repository_entry=repo['entry'], |
| repository_assets=paths, build_counterpart=True) |
| return {'version': 'build-input-discovery-v1', 'source_digest': package['digest'], |
| 'inventory_digest': digest(tree), 'status': 'CAPTURE_REQUIRED' if missing else 'READY', |
| 'missing_paths': sorted(missing), 'visited': sorted(visited), 'edges': edges, |
| 'intake': intake.model_dump(mode='json'), 'verified_application': False} |
|
|
