diff --git a/Makefile b/Makefile index 30de5a82..982ed7e7 100644 --- a/Makefile +++ b/Makefile @@ -7,6 +7,7 @@ PREFIX ?= /usr/local CC ?= cc AR ?= ar +PYTHON3 ?= python3 # Fixture-cell concurrency is separate from caller-owned Make scheduling. JOBS ?= 1 @@ -636,7 +637,11 @@ test-platform: $(WRAPPER_TOOLS) $(PLATFORM_WRAPPER_BINS) # byte identity and self-host fixed points are never hidden prerequisites. test: test-unit test-compiler-smoke -test-commit: test-unit test-compiler test-package test-lang test-library +test-protocol: + @PYTHONDONTWRITEBYTECODE=1 LC_ALL=C $(PYTHON3) -B protocol/check.py + +test-commit: test-unit test-compiler test-package test-lang test-library \ + test-protocol # Compiler-output identity stops after w6c has emitted every package `.s`. # Driver -S still performs discovery, unit composition, dependency ordering, @@ -969,7 +974,7 @@ nocc: @echo "NOCC OK: $(STAGE0)/* reproduces itself from source. cc not invoked." .PHONY: all cstage wwstage wwfixture test-wwfixture-process test-wwfixture \ - test test-unit test-compiler-smoke test-compiler test-package \ + test test-unit test-compiler-smoke test-compiler test-package test-protocol \ test-lang test-library test-commit test-lang-byteid \ $(LANG_TEST_TARGETS) $(BYTEID_WW_TARGETS) \ $(SEP_WW_TARGETS) test-data-byteid test-byteid \ diff --git a/protocol/README.md b/protocol/README.md new file mode 100644 index 00000000..7557246c --- /dev/null +++ b/protocol/README.md @@ -0,0 +1,138 @@ +# WWAR v1 Phase 0 conformance + +This directory freezes the byte-level interoperability surface of WWAR v1. It +does not describe or execute the WW package manager, compiler, action graph, +scheduler, provider system, cache, or bootstrap process. + +Phase 0 follows one rule: schemas describe representation, executable WW/C +code owns behavior, and tests observe that behavior. The Python programs here +are development-time conformance tools. They are not part of a production WW +build and are not a second build-system implementation. + +## Contents + +- `schema/wire.json` fixes the WWAR envelope, primitive frames, container + frames, canonical Unicode rules, limits, and malformed-input precedence. +- `schema/records.json` fixes scalar representations, record fields and tags, + enum values, union discriminants, encoded defaults, record kinds, wrapper + assignments, and artifact-to-digest identities. +- `schema/digests.json` fixes the twelve domain separators and their finite, + non-nestable byte formulas. +- `schema/wwar-v1.sha256` fixes the exact bytes of those three schemas. +- `tool.py` strictly validates the schemas, encodes and decodes WWAR values and + typed records, computes the frozen digests, and generates data-only lookup + tables. +- `generated/wwar_v1_tables.json` is a compact, pre-indexed codec table compiled + from the three schemas. It contains no executable policy or schema prose. +- `vectors/` contains compact wire, typed-record, wrapper, and digest goldens. +- `check.py` is the aggregate conformance gate and contains a small independent + raw-wire/hash oracle. That oracle does not load or interpret record schemas. + +Run the complete gate from the repository root: + +```sh +make test-protocol +``` + +Regenerate the checked-in data after an intentional schema change: + +```sh +python3 -B protocol/tool.py write-manifest +python3 -B protocol/tool.py emit-tables --output protocol/generated/wwar_v1_tables.json +python3 -B protocol/check.py +``` + +Generation is deterministic. The gate regenerates in two fresh directories, +compares their bytes, and compares both with the checked-in output. All JSON is +UTF-8, duplicate keys are rejected, and schema strings must already be NFC. + +The generated table removes repetitive lookup construction from future codecs +instead of copying the authoring schemas. Its positional columns are fixed: + +- a type is `[kind, scalar-or-name-or-element-type]`; +- a scalar is `[base, length, maximum, values, path-class, nonempty]`; +- a path is `[shape, absolute, allow-dot, allow-dotdot, ASCII, roots]`; +- a record is `[top-level-kind, fields]`; +- a field is `[tag, name, type, cardinality, default, order, order-by]`; +- a union is `[discriminator, case-table]`; +- a digest is `[algorithm, separator, input, formula, entry-encoding]`. + +The generator also turns enum, kind, artifact, and wrapper arrays into direct +keyed lookup tables. The checked-in output carries the exact input-file hashes +and bundle digest, and the gate proves it equals a fresh compilation. +Path lexical checks are derived from the closed path columns; there is no +second free-form `rules` list that can disagree with the codec. + +## Frozen surface + +The v1 catalog contains: + +- seven primitive/container wire type codes; +- 165 representation records and 809 field tags; +- 41 enums with 202 numeric values; +- three structural unions with 35 arms; +- 22 top-level record-kind assignments, all at schema version 1; +- 12 domain-separated SHA-256 formulas; +- four compact wrapper assignments. + +Every declared record field is present on the wire in increasing tag order. +An optional field's `encoded_default` is its encoded empty value, not permission +to omit the field. A decoder therefore reports `MISSING_FIELD` when a declared +tag is absent. Union-inactive fields likewise remain present with their encoded +empty defaults. + +The generic WWAR envelope carries exactly one complete value. Typed record +identity and wrapper operations additionally require the record named by their +schema. This resolves an inconsistency in the experiment: its envelope prose +said “record”, while both readers and nearly all primitive/container goldens +accepted a generic root value. + +The only experimental record deliberately not retained is +`NativeTypeGraphContextV1`. It was unreachable from every top-level record, +digest preimage, and signature preimage, and existed only as context for the +discarded projection proof runtime. The other digest-preimage records remain +as wire layouts; how later phases construct them is not Phase 0 behavior. + +The migration compared a canonical assignment catalog against the archived +experimental IDL. Its SHA-256 was +`7b8660b451cc5260e9c7ad8d45da8e62313ff1f9b54259e211ff04b49c38671f`. +The comparison covers retained record names, field names/types/tags/defaults, +scalar wire refinements, path classes, enum numbers, union arms, record kinds, +digest formulas, artifact mappings, and wrapper assignments. In particular, it +preserves intentional numeric holes; +for example, `FinalLinkTokenKind` has no value 4. + +## What is deferred + +Phase 0 retains only bytes and identities. The implementation phases own the +following behavior and test it when it exists: + +- Phase 1: source import extraction, package loading and cycles, compiler export + production/consumption, public type closure, and ABI projection construction. +- Phase 2: action construction, action graphs, scheduling, failure propagation, + CAS/cache storage and validation, sandboxing, and environment policy. +- Phase 3: manifest/lock/work/vendor text parsers, module and source resolution, + fetching, source-store policy, and source-tree filesystem construction. +- Phase 4: native providers, recursive provider expansion, lowering, link-plan + construction, tool adapters, and platform/native policy. +- Phase 6: bootstrap-plan execution, staged rebuilds, and byte-for-byte + fixed-point comparison. + +There is intentionally no predicate language, context lookup mechanism, +projection proof system, lowering program, graph interpreter, text-parser AST, +semantic answer table, or bootstrap proof record in this directory. Digest +preimage layouts and byte formulas do not prescribe how those values are +derived. + +## Change discipline + +WWAR v1 assignments are compatibility data. Do not renumber or silently reuse +tags, enum values, union discriminants, record kinds, wrapper versions, or +digest separators. An incompatible representation change requires a new wire +or schema version and new vectors. + +Declarative additions must remain closed data shapes and must remove more +handwritten complexity than they introduce. Build behavior belongs in ordinary +typed WW/C functions with focused tests. A generator may remove repetitive +codec tables, but it must remain generic, deterministic, reviewable, and +byte-for-byte reproducible. diff --git a/protocol/check.py b/protocol/check.py new file mode 100644 index 00000000..b1c3f083 --- /dev/null +++ b/protocol/check.py @@ -0,0 +1,1198 @@ +#!/usr/bin/env python3 +"""Aggregate WWAR v1 Phase 0 conformance gate.""" + +from __future__ import annotations + +import ast +import copy +import hashlib +import json +import os +import pathlib +import struct +import subprocess +import sys +import tempfile +import unicodedata +from typing import Any + +import tool + + +ROOT = pathlib.Path(__file__).resolve().parent +SCHEMA = ROOT / "schema" +GENERATED = ROOT / "generated" / "wwar_v1_tables.json" +VECTORS = ROOT / "vectors" +EXPECTED_FILES = { + "README.md", + "check.py", + "tool.py", + "schema/digests.json", + "schema/records.json", + "schema/wire.json", + "schema/wwar-v1.sha256", + "generated/wwar_v1_tables.json", + "vectors/digests.json", + "vectors/records.json", + "vectors/wire-invalid.json", + "vectors/wire-valid.json", +} +ARCHIVED_ASSIGNMENT_SHA256 = "7b8660b451cc5260e9c7ad8d45da8e62313ff1f9b54259e211ff04b49c38671f" + + +def fail(message: str) -> None: + raise AssertionError(message) + + +def exact_keys(value: Any, expected: set[str], where: str) -> None: + if not isinstance(value, dict) or set(value) != expected: + actual = set(value) if isinstance(value, dict) else set() + fail( + f"{where}: keys differ: missing={sorted(expected-actual)} " + f"unknown={sorted(actual-expected)}" + ) + + +def register_case_id(case: Any, seen: set[str], where: str) -> None: + if not isinstance(case, dict): + fail(f"{where}: expected object") + case_id = case.get("id") + if ( + not isinstance(case_id, str) + or not case_id + or len(case_id.encode("utf-8")) > 255 + or case_id in seen + ): + fail(f"{where}: invalid or duplicate case id") + seen.add(case_id) + + +def check_files() -> None: + actual = { + path.relative_to(ROOT).as_posix() + for path in ROOT.rglob("*") + if path.is_file() + } + if actual != EXPECTED_FILES: + fail(f"protocol file set differs: missing={sorted(EXPECTED_FILES-actual)} extra={sorted(actual-EXPECTED_FILES)}") + + +def check_no_bytecode() -> None: + bad = [ + path.relative_to(ROOT).as_posix() + for path in ROOT.rglob("*") + if path.is_file() and (path.suffix in {".pyc", ".pyo"} or "__pycache__" in path.parts) + ] + if bad: + fail(f"Python bytecode under protocol/: {bad}") + + +def run_tool(*arguments: str, expect: int = 0) -> subprocess.CompletedProcess[str]: + env = os.environ.copy() + env["PYTHONDONTWRITEBYTECODE"] = "1" + env["LC_ALL"] = "C" + completed = subprocess.run( + [sys.executable, "-B", str(ROOT / "tool.py"), *arguments], + cwd=ROOT, + env=env, + text=True, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + check=False, + ) + if completed.returncode != expect: + fail( + f"tool command returned {completed.returncode}, wanted {expect}: {arguments}\n" + f"stdout={completed.stdout}\nstderr={completed.stderr}" + ) + return completed + + +def oracle_encode(ast_value: Any, wire: dict[str, Any], depth: int = 1) -> bytes: + if depth > wire["limits"]["nesting_depth_max"]: + raise ValueError("depth") + if not isinstance(ast_value, dict) or len(ast_value) != 1: + raise ValueError("shape") + name, value = next(iter(ast_value.items())) + codes = {row["name"]: row["code"] for row in wire["wire_types"]} + if name == "bool": + payload = bytes([int(value)]) + elif name == "bytes": + payload = bytes.fromhex(value) + elif name == "string": + payload = value.encode("utf-8") + elif name == "uint": + number = int(value) + payload = number.to_bytes(max(1, (number.bit_length() + 7) // 8), "big") + elif name == "list": + children = [oracle_encode(child, wire, depth + 1) for child in value] + payload = struct.pack(">I", len(children)) + b"".join( + struct.pack(">Q", len(child)) + child for child in children + ) + elif name == "map": + parts = [struct.pack(">I", len(value))] + for key, child_value in value: + key_bytes = key.encode("utf-8") + child = oracle_encode(child_value, wire, depth + 1) + parts.extend((struct.pack(">Q", len(key_bytes)), key_bytes, struct.pack(">Q", len(child)), child)) + payload = b"".join(parts) + elif name == "record": + parts = [struct.pack(">I", len(value))] + for tag, child_value in value: + child = oracle_encode(child_value, wire, depth + 1) + parts.extend((struct.pack(">I", tag), struct.pack(">Q", len(child)), child)) + payload = b"".join(parts) + else: + raise ValueError(name) + return bytes([codes[name]]) + struct.pack(">Q", len(payload)) + payload + + +def oracle_envelope(ast_value: Any, wire: dict[str, Any]) -> bytes: + return bytes.fromhex(wire["magic_hex"]) + struct.pack(">H", wire["schema_version"]) + oracle_encode(ast_value, wire) + + +def load_vectors( + name: str, expected_format: str, expected_keys: set[str] +) -> dict[str, Any]: + value = tool.load_json(VECTORS / name) + exact_keys(value, expected_keys, name) + if value.get("format") != expected_format or value.get("version") != 1: + fail(f"{name}: bad vector format/version") + return value + + +def check_wire_vectors(bundle: tool.SchemaBundle) -> None: + valid = load_vectors( + "wire-valid.json", "wwar-v1-wire-valid", {"format", "version", "cases"} + ) + ids: set[str] = set() + covered_types: set[str] = set() + for case in valid["cases"]: + if set(case) != {"id", "value", "wwar_hex", "sha256"} or case["id"] in ids: + fail("wire-valid: malformed or duplicate case") + ids.add(case["id"]) + encoded = tool.encode_envelope(case["value"], bundle.wire) + oracle = oracle_envelope(case["value"], bundle.wire) + if encoded != oracle or encoded.hex() != case["wwar_hex"]: + fail(f"wire-valid {case['id']}: encoder/oracle/golden mismatch") + if hashlib.sha256(encoded).hexdigest() != case["sha256"]: + fail(f"wire-valid {case['id']}: SHA-256 mismatch") + if tool.decode_envelope(encoded, bundle.wire) != case["value"]: + fail(f"wire-valid {case['id']}: round-trip mismatch") + covered_types.add(next(iter(case["value"]))) + if covered_types != set(bundle.type_codes): + fail(f"wire-valid: type coverage differs: {covered_types}") + + invalid = load_vectors( + "wire-invalid.json", "wwar-v1-wire-invalid", {"format", "version", "cases"} + ) + ids.clear() + required = { + "bytes-limit-before-truncation", + "bytes-truncated", + "bool-truncated-before-length", + "bool-length-mismatch", + "list-child-length-mismatch", + "nesting-limit", + } + for case in invalid["cases"]: + if set(case) != {"id", "input_hex", "error"} or case["id"] in ids: + fail("wire-invalid: malformed or duplicate case") + exact_keys(case["error"], {"code", "path"}, f"wire-invalid {case['id']}.error") + ids.add(case["id"]) + try: + tool.decode_envelope(bytes.fromhex(case["input_hex"]), bundle.wire) + except tool.ProtocolError as exc: + if {"code": exc.code, "path": exc.path} != case["error"]: + fail(f"wire-invalid {case['id']}: got {exc.code} {exc.path}, wanted {case['error']}") + else: + fail(f"wire-invalid {case['id']}: accepted") + if not required <= ids: + fail(f"wire-invalid: missing precedence cases {sorted(required-ids)}") + + +def assignment_catalog(bundle: tool.SchemaBundle) -> dict[str, Any]: + return { + "scalar_types": { + row["name"]: {key: value for key, value in row.items() if key != "name"} + for row in bundle.records_data["scalar_types"] + }, + "path_classes": { + row["name"]: {key: value for key, value in row.items() if key != "name"} + for row in bundle.records_data["path_classes"] + }, + "records": { + record["name"]: { + "top_level_kind": record["top_level_kind"], + "fields": { + str(field["tag"]): { + key: field[key] + for key in ("name", "type", "cardinality", "encoded_default", "order", "order_by") + } + for field in record["fields"] + }, + } + for record in bundle.records_data["records"] + }, + "enums": { + enum["name"]: {str(value["value"]): value["name"] for value in enum["values"]} + for enum in bundle.records_data["enums"] + }, + "unions": { + union["name"]: { + "record": union["record"], + "discriminator": union["discriminator"], + "cases": { + case["value"]: { + key: sorted(case[key]) for key in ("required", "allowed", "nonempty", "empty") + } + for case in union["cases"] + }, + } + for union in bundle.records_data["unions"] + }, + "record_kinds": { + str(row["kind"]): {"name": row["name"], "schema": row["schema"]} + for row in bundle.records_data["record_kinds"] + }, + "digests": { + row["name"]: { + key: row[key] + for key in ("algorithm", "separator_utf8_hex", "input", "entry_encoding", "formula", "result") + if key in row + } + for row in bundle.digests_data["domains"] + }, + "artifact_digest_mapping": { + row["artifact_kind"]: { + key: row[key] for key in ("domain", "record_kind", "record_schema") + } + for row in bundle.records_data["artifact_digest_mapping"] + }, + "wrappers": { + row["name"]: {key: row[key] for key in ("body_record", "magic_hex", "identity")} + for row in bundle.records_data["wrappers"] + }, + } + + +def expect_protocol_error(operation: Any, expected: dict[str, str], case_id: str) -> None: + try: + operation() + except tool.ProtocolError as exc: + if {"code": exc.code, "path": exc.path} != expected: + fail(f"{case_id}: got {exc.code} {exc.path}, wanted {expected}") + else: + fail(f"{case_id}: accepted") + + +def check_record_vectors(bundle: tool.SchemaBundle) -> None: + vectors = load_vectors( + "records.json", + "wwar-v1-record-vectors", + { + "format", + "version", + "archived_assignment_sha256", + "assignment_sha256", + "coverage", + "cases", + "union_cases", + "wrapper_cases", + "invalid_cases", + }, + ) + if vectors["archived_assignment_sha256"] != ARCHIVED_ASSIGNMENT_SHA256: + fail("records: archived assignment fingerprint changed") + catalog = assignment_catalog(bundle) + digest = hashlib.sha256( + json.dumps(catalog, ensure_ascii=False, sort_keys=True, separators=(",", ":")).encode("utf-8") + ).hexdigest() + if digest != vectors["assignment_sha256"]: + fail("records: assignment catalog fingerprint changed") + expected_coverage = { + "scalar_types": len(bundle.scalars), + "path_classes": len(bundle.paths), + "records": len(bundle.records), + "fields": sum(len(row["fields"]) for row in bundle.records.values()), + "encoded_defaults": sum( + field["encoded_default"] is not None + for row in bundle.records.values() + for field in row["fields"] + ), + "enums": len(bundle.enums), + "enum_values": sum(len(row["values"]) for row in bundle.enums.values()), + "unions": len(bundle.records_data["unions"]), + "union_arms": sum(len(row["cases"]) for row in bundle.records_data["unions"]), + "record_kinds": len(bundle.kinds), + "artifact_mappings": len(bundle.records_data["artifact_digest_mapping"]), + "wrappers": len(bundle.wrappers), + } + exact_keys(vectors["coverage"], set(expected_coverage), "records.coverage") + if vectors["coverage"] != expected_coverage: + fail(f"records: coverage mismatch {vectors['coverage']} != {expected_coverage}") + for enum in bundle.enums.values(): + for member in enum["values"]: + type_spec = {"kind": "enum", "name": enum["name"]} + ast_value = bundle._semantic_ast(type_spec, member["name"], "$.enum") + if ast_value != {"uint": str(member["value"])}: + fail(f"enum {enum['name']}.{member['name']}: typed numeric mismatch") + encoded = tool.encode_envelope(ast_value, bundle.wire) + decoded_ast = tool.decode_envelope(encoded, bundle.wire) + if bundle._decode_semantic_ast(type_spec, decoded_ast, "$.enum") != member["name"]: + fail(f"enum {enum['name']}.{member['name']}: typed round-trip mismatch") + case_ids: set[str] = set() + for case in vectors["cases"]: + allowed = {"id", "record", "value", "wwar_hex", "decoded", "record_id"} + required = {"id", "record", "value", "wwar_hex"} + if not isinstance(case, dict) or not required <= set(case) <= allowed: + fail("records: malformed ordinary case") + register_case_id(case, case_ids, "records ordinary case") + encoded = bundle.encode_record(case["record"], case["value"]) + if encoded.hex() != case["wwar_hex"]: + fail(f"record {case['id']}: golden mismatch") + decoded = bundle.decode_record(case["record"], encoded) + if "decoded" in case and decoded != case["decoded"]: + fail(f"record {case['id']}: decoded mismatch") + if "record_id" in case: + kind = bundle.records[case["record"]]["top_level_kind"] + if bundle.record_id(case["record"], kind, 1, case["value"]).hex() != case["record_id"]: + fail(f"record {case['id']}: identity mismatch") + actual_union_cases: set[tuple[str, str]] = set() + for case in vectors["union_cases"]: + exact_keys(case, {"id", "record", "value", "wwar_hex"}, "records.union case") + register_case_id(case, case_ids, "records union case") + encoded = bundle.encode_record(case["record"], case["value"]) + if encoded.hex() != case["wwar_hex"] or bundle.decode_record(case["record"], encoded) != case["value"]: + fail(f"union {case['id']}: golden/round-trip mismatch") + actual_union_cases.add((case["record"], case["value"][bundle.unions[case["record"]]["discriminator"]])) + expected_union_cases = { + (union["record"], case["value"]) + for union in bundle.records_data["unions"] + for case in union["cases"] + } + if actual_union_cases != expected_union_cases or len(actual_union_cases) != len(vectors["union_cases"]): + fail("union vectors do not cover every arm exactly once") + for case in vectors["wrapper_cases"]: + exact_keys(case, {"id", "wrapper", "value", "bytes_hex"}, "records.wrapper case") + register_case_id(case, case_ids, "records wrapper case") + encoded = bundle.encode_wrapper(case["wrapper"], case["value"]) + if encoded.hex() != case["bytes_hex"]: + fail(f"wrapper {case['id']}: golden mismatch") + if bundle.decode_wrapper(case["wrapper"], encoded) != bundle._materialize_record( + bundle.wrappers[case["wrapper"]]["body_record"], case["value"], "$" + ): + fail(f"wrapper {case['id']}: round-trip mismatch") + for case in vectors["invalid_cases"]: + register_case_id(case, case_ids, "records invalid case") + if case["operation"] == "record-id": + exact_keys( + case, + {"id", "operation", "record", "kind", "schema", "value", "error"}, + "records.invalid record-id", + ) + operation = lambda case=case: bundle.record_id( + case["record"], case["kind"], case["schema"], case["value"] + ) + elif case["operation"] == "decode-record": + exact_keys( + case, + {"id", "operation", "record", "input_hex", "error"}, + "records.invalid decode-record", + ) + operation = lambda case=case: bundle.decode_record( + case["record"], bytes.fromhex(case["input_hex"]) + ) + elif case["operation"] == "decode-wrapper": + exact_keys( + case, + {"id", "operation", "wrapper", "input_hex", "error"}, + "records.invalid decode-wrapper", + ) + operation = lambda case=case: bundle.decode_wrapper( + case["wrapper"], bytes.fromhex(case["input_hex"]) + ) + else: + fail(f"record invalid case {case['id']}: unknown operation") + exact_keys(case["error"], {"code", "path"}, f"records.invalid {case['id']}.error") + expect_protocol_error(operation, case["error"], case["id"]) + + +def check_assignment_probes(bundle: tool.SchemaBundle) -> None: + covered_records: set[str] = set() + covered_fields: set[tuple[str, int]] = set() + covered_defaults: set[tuple[str, int]] = set() + covered_kinds: set[int] = set() + for name, record in bundle.records.items(): + full = bundle.conformance_sample(name) + encoded = bundle.encode_record(name, full) + raw = tool.decode_envelope(encoded, bundle.wire) + tags = [tag for tag, _ in raw["record"]] + expected_tags = [field["tag"] for field in record["fields"]] + if tags != expected_tags: + fail(f"assignment probe {name}: encoded tags differ") + decoded = bundle.decode_record(name, encoded) + if bundle.encode_record(name, decoded) != encoded: + fail(f"assignment probe {name}: typed codec is not byte-idempotent") + covered_records.add(name) + covered_fields.update((name, tag) for tag in tags) + + minimal = { + field["name"]: copy.deepcopy(full[field["name"]]) + for field in record["fields"] + if field["encoded_default"] is None + } + union = bundle.unions.get(name) + if union: + selected = full[union["discriminator"]] + case = next(row for row in union["cases"] if row["value"] == selected) + for field_name in case["nonempty"]: + minimal[field_name] = copy.deepcopy(full[field_name]) + default_encoded = bundle.encode_record(name, minimal) + default_raw = tool.decode_envelope(default_encoded, bundle.wire) + if [tag for tag, _ in default_raw["record"]] != expected_tags: + fail(f"assignment probe {name}: defaulted tags were omitted") + default_decoded = bundle.decode_record(name, default_encoded) + for field in record["fields"]: + if field["encoded_default"] is None: + continue + if field["name"] not in minimal and default_decoded[field["name"]] != field["encoded_default"]: + fail(f"assignment probe {name}.{field['name']}: encoded default differs") + + candidates = union["cases"] if union else [None] + for candidate in candidates: + case_name = candidate["value"] if candidate else None + omitted = bundle.conformance_sample(name, case_name) + omitted.pop(field["name"]) + try: + omitted_encoded = bundle.encode_record(name, omitted) + omitted_decoded = bundle.decode_record(name, omitted_encoded) + except (tool.ProtocolError, tool.SchemaError): + continue + omitted_raw = tool.decode_envelope(omitted_encoded, bundle.wire) + if field["tag"] not in {tag for tag, _ in omitted_raw["record"]}: + fail(f"assignment probe {name}.{field['name']}: default tag was omitted") + if omitted_decoded[field["name"]] != field["encoded_default"]: + fail(f"assignment probe {name}.{field['name']}: omitted default differs") + covered_defaults.add((name, field["tag"])) + break + else: + fail(f"assignment probe {name}.{field['name']}: no valid omission probe") + + kind = record["top_level_kind"] + if kind is not None: + if len(bundle.record_id(name, kind, 1, full)) != 32: + fail(f"assignment probe {name}: record identity length differs") + covered_kinds.add(kind) + + expected_fields = { + (name, field["tag"]) + for name, record in bundle.records.items() + for field in record["fields"] + } + expected_defaults = { + (name, field["tag"]) + for name, record in bundle.records.items() + for field in record["fields"] + if field["encoded_default"] is not None + } + if covered_records != set(bundle.records): + fail("assignment probes do not cover every record") + if covered_fields != expected_fields: + fail("assignment probes do not cover every field tag") + if covered_defaults != expected_defaults: + fail("assignment probes do not cover every encoded default") + if covered_kinds != set(bundle.kinds): + fail("assignment probes do not cover every record kind") + + covered_wrappers = set() + for name, wrapper in bundle.wrappers.items(): + value = bundle.conformance_sample(wrapper["body_record"]) + encoded = bundle.encode_wrapper(name, value) + decoded = bundle.decode_wrapper(name, encoded) + if bundle.encode_wrapper(name, decoded) != encoded: + fail(f"assignment probe wrapper {name}: codec is not byte-idempotent") + covered_wrappers.add(name) + if covered_wrappers != set(bundle.wrappers): + fail("assignment probes do not cover every wrapper") + + order_probe = None + for name, record in bundle.records.items(): + for field in record["fields"]: + if field["order"] == "sorted": + order_probe = (name, field) + break + if order_probe: + break + if order_probe is None: + fail("assignment probes found no sorted field") + record_name, field = order_probe + value = bundle.conformance_sample(record_name) + item = bundle._sample_type(field["type"]["item"], (record_name,)) + value[field["name"]] = [item, copy.deepcopy(item)] + expect_protocol_error( + lambda: bundle.encode_record(record_name, value), + {"code": "CONSTRAINT_VIOLATION", "path": f"$.{field['name']}[1]"}, + "derived-duplicate-sort-key", + ) + + +def oracle_source_tree(entries: list[dict[str, Any]]) -> bytes: + out = bytearray() + for index, entry in enumerate(entries): + exact_keys( + entry, + {"path", "type", "executable", "content"}, + f"digests.source-tree entry {index}", + ) + path = entry["path"].encode("utf-8") + out += struct.pack(">Q", len(path)) + path + if entry["type"] == "dir": + out += b"\x01\x00" + struct.pack(">Q", 0) + else: + content = bytes.fromhex(entry["content"]) + out += b"\x02" + bytes([int(entry["executable"])]) + struct.pack(">Q", len(content)) + content + return bytes(out) + + +def check_digest_vectors(bundle: tool.SchemaBundle) -> None: + vectors = load_vectors( + "digests.json", "wwar-v1-digest-vectors", {"format", "version", "cases"} + ) + if {case["domain"] for case in vectors["cases"]} != set(bundle.domains) or len(vectors["cases"]) != len(bundle.domains): + fail("digests: every domain must have exactly one vector") + action_domains = { + domain["name"] + for domain in bundle.domains.values() + if tuple(domain["formula"]) == tool.FORMULA_WWAR + and set(domain["result"]) == {"kind", "scalar"} + } + if len(action_domains) != 1: + fail("digests: expected one scalar-result WWAR action-key formula") + action_seen: set[str] = set() + case_ids: set[str] = set() + for case in vectors["cases"]: + if not isinstance(case, dict) or "domain" not in case or case["domain"] not in bundle.domains: + fail("digests: malformed or unknown domain case") + register_case_id(case, case_ids, "digests case") + domain = bundle.domains[case["domain"]] + formula = tuple(domain["formula"]) + separator = bytes.fromhex(domain["separator_utf8_hex"]) + if formula == tool.FORMULA_BYTES: + exact_keys(case, {"id", "domain", "input_hex", "digest"}, "digests.bytes case") + value: Any = bytes.fromhex(case["input_hex"]) + expected = hashlib.sha256(separator + struct.pack(">Q", len(value)) + value).digest() + actual = bundle.digest(case["domain"], value) + elif formula == tool.FORMULA_WWAR: + exact_keys( + case, + {"id", "domain", "record", "value", "wwar_hex", "digest"}, + "digests.WWAR case", + ) + encoded = bundle.encode_record(case["record"], case["value"]) + if encoded.hex() != case["wwar_hex"]: + fail(f"digest {case['id']}: WWAR golden mismatch") + expected = hashlib.sha256(separator + struct.pack(">Q", len(encoded)) + encoded).digest() + actual = bundle.digest(case["domain"], case["value"], record_name=case["record"]) + if case["domain"] in action_domains: + action_seen.add(case["domain"]) + elif formula == tool.FORMULA_RECORD: + exact_keys( + case, + {"id", "domain", "record", "kind", "schema", "value", "wwar_hex", "digest"}, + "digests.record case", + ) + encoded = bundle.encode_record(case["record"], case["value"]) + if encoded.hex() != case["wwar_hex"]: + fail(f"digest {case['id']}: WWAR golden mismatch") + expected = hashlib.sha256( + separator + + struct.pack(">I", case["kind"]) + + struct.pack(">I", case["schema"]) + + struct.pack(">Q", len(encoded)) + + encoded + ).digest() + actual = bundle.digest( + case["domain"], + case["value"], + record_name=case["record"], + kind=case["kind"], + schema=case["schema"], + ) + elif formula == tool.FORMULA_SOURCE_TREE: + exact_keys(case, {"id", "domain", "entries", "digest"}, "digests.source-tree case") + value = case["entries"] + expected = hashlib.sha256(separator + oracle_source_tree(value)).digest() + actual = bundle.digest(case["domain"], value) + else: + fail(f"digest {case['id']}: unknown formula") + if actual != expected or actual.hex() != case["digest"]: + fail(f"digest {case['id']}: tool/oracle/golden mismatch") + if action_seen != action_domains: + fail("digests: missing action-key vector") + probe = b"domain separation probe" + separated = [] + for domain in bundle.domains.values(): + separator = bytes.fromhex(domain["separator_utf8_hex"]) + formula = tuple(domain["formula"]) + if formula in {tool.FORMULA_BYTES, tool.FORMULA_WWAR}: + preimage = separator + struct.pack(">Q", len(probe)) + probe + elif formula == tool.FORMULA_RECORD: + preimage = separator + struct.pack(">I", 1) + struct.pack(">I", 1) + struct.pack(">Q", len(probe)) + probe + else: + preimage = separator + probe + separated.append(hashlib.sha256(preimage).digest()) + if len(separated) != len(set(separated)): + fail("digests: domain separation collision in fixed probe") + + +def write_schema_set(directory: pathlib.Path, wire: Any, records: Any, digests: Any) -> None: + directory.mkdir(parents=True) + for name, value in (("wire.json", wire), ("records.json", records), ("digests.json", digests)): + (directory / name).write_text(json.dumps(value, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + tool.write_schema_manifest(directory) + + +def expect_schema_error(operation: Any, label: str) -> None: + try: + operation() + except tool.SchemaError: + return + fail(f"schema mutation accepted: {label}") + + +def expect_assertion(operation: Any, label: str) -> None: + try: + operation() + except AssertionError: + return + fail(f"checker mutation accepted: {label}") + + +def synthetic_records( + record_name: str, + enum_name: str, + field_name: str, + tag: int = 7, + default: str = "red", +) -> dict[str, Any]: + return { + "format": "wwar-v1-record-schema", + "version": 1, + "scalar_types": [], + "path_classes": [], + "enums": [{"name": enum_name, "values": [{"name": "red", "value": 1}, {"name": "blue", "value": 2}]}], + "record_kinds": [{"kind": 1, "name": record_name, "schema": 1}], + "records": [ + { + "name": record_name, + "top_level_kind": 1, + "fields": [ + { + "tag": tag, + "name": field_name, + "type": {"kind": "enum", "name": enum_name}, + "cardinality": "1", + "encoded_default": default, + "order": "none", + "order_by": [], + } + ], + } + ], + "unions": [], + "artifact_digest_mapping": [], + "wrappers": [], + } + + +def synthetic_digests(record_name: str) -> dict[str, Any]: + return { + "format": "wwar-v1-digest-schema", + "version": 1, + "domains": [ + { + "name": "raw", + "algorithm": "sha256", + "separator_utf8_hex": "53594e2d52415700", + "input": {"kind": "bytes"}, + "formula": list(tool.FORMULA_BYTES), + "result": {"kind": "bytes", "length": 32}, + }, + { + "name": "shape", + "algorithm": "sha256", + "separator_utf8_hex": "53594e2d534841504500", + "input": {"record": record_name, "encoding": "WWAR"}, + "formula": list(tool.FORMULA_WWAR), + "result": {"kind": "bytes", "length": 32}, + }, + { + "name": "identity", + "algorithm": "sha256", + "separator_utf8_hex": "53594e2d4944454e5449545900", + "input": {"record": "top-level record", "encoding": "WWAR"}, + "formula": list(tool.FORMULA_RECORD), + "result": {"kind": "bytes", "length": 32}, + }, + ], + } + + +def replace_exact_strings(value: Any, mapping: dict[str, str]) -> Any: + if isinstance(value, str): + return mapping.get(value, value) + if isinstance(value, list): + return [replace_exact_strings(item, mapping) for item in value] + if isinstance(value, dict): + return { + mapping.get(key, key): replace_exact_strings(child, mapping) + for key, child in value.items() + } + return value + + +def check_genericity_and_mutations(bundle: tool.SchemaBundle) -> None: + with tempfile.TemporaryDirectory(prefix="wwar-schema-mutations-") as raw_tmp: + base = pathlib.Path(raw_tmp) + wire = copy.deepcopy(bundle.wire) + records = copy.deepcopy(bundle.records_data) + digests = copy.deepcopy(bundle.digests_data) + + mutation = copy.deepcopy(records) + mutation["predicate_programs"] = [] + directory = base / "unknown-root" + write_schema_set(directory, wire, mutation, digests) + expect_schema_error(lambda: tool.SchemaBundle.from_dir(directory), "semantic root") + + mutation = copy.deepcopy(wire) + mutation["error_precedence"] = { + "op": "context-lookup", + "relation": "provider-table", + } + directory = base / "wire-policy-object" + write_schema_set(directory, mutation, records, digests) + expect_schema_error(lambda: tool.SchemaBundle.from_dir(directory), "wire policy object") + + mutation = copy.deepcopy(wire) + mutation["root"] = "X" * 1_000_000 + directory = base / "giant-wire-root" + write_schema_set(directory, mutation, records, digests) + expect_schema_error(lambda: tool.SchemaBundle.from_dir(directory), "giant wire root") + + mutation = copy.deepcopy(records) + mutation["records"][0]["fields"][0]["constraint"] = {"op": "context-lookup"} + directory = base / "field-expression" + write_schema_set(directory, wire, mutation, digests) + expect_schema_error(lambda: tool.SchemaBundle.from_dir(directory), "field expression") + + mutation = copy.deepcopy(records) + mutation["wrappers"][0]["identity"] = { + "op": "graph-dfs", + "policy": "bootstrap", + } + directory = base / "wrapper-policy-object" + write_schema_set(directory, wire, mutation, digests) + expect_schema_error(lambda: tool.SchemaBundle.from_dir(directory), "wrapper policy object") + + mutation = copy.deepcopy(records) + mutation["path_classes"][0]["rules"] = [ + {"op": "call", "operation": "provider-expand"} + ] + directory = base / "path-policy-object" + write_schema_set(directory, wire, mutation, digests) + expect_schema_error(lambda: tool.SchemaBundle.from_dir(directory), "path policy object") + + mutation = copy.deepcopy(records) + mutation["path_classes"][0]["rules"] = ["no-backslash"] + directory = base / "redundant-path-rules" + write_schema_set(directory, wire, mutation, digests) + expect_schema_error(lambda: tool.SchemaBundle.from_dir(directory), "redundant path rules") + + mutation = copy.deepcopy(records) + scalar_field = next( + field + for record in mutation["records"] + for field in record["fields"] + if field["type"]["kind"] == "string" and field["cardinality"] == "1" + ) + scalar_field["cardinality"] = "*" + directory = base / "scalar-list-cardinality" + write_schema_set(directory, wire, mutation, digests) + expect_schema_error(lambda: tool.SchemaBundle.from_dir(directory), "scalar list cardinality") + + mutation = copy.deepcopy(records) + scalar_field = next( + field + for record in mutation["records"] + for field in record["fields"] + if field["type"]["kind"] == "string" and field["order"] == "none" + ) + scalar_field["order"] = "ordered" + directory = base / "scalar-ordered" + write_schema_set(directory, wire, mutation, digests) + expect_schema_error(lambda: tool.SchemaBundle.from_dir(directory), "scalar ordered field") + + mutation = copy.deepcopy(records) + scalar_field = next( + field + for record in mutation["records"] + for field in record["fields"] + if field["type"]["kind"] == "string" + and field["cardinality"] == "1" + and field["encoded_default"] is None + and not field["type"].get("scalar") + ) + scalar_field["encoded_default"] = "x" * 100_000 + directory = base / "giant-string-default" + write_schema_set(directory, wire, mutation, digests) + expect_schema_error(lambda: tool.SchemaBundle.from_dir(directory), "giant string default") + + mutation = copy.deepcopy(records) + list_field = next( + field + for record in mutation["records"] + for field in record["fields"] + if field["type"]["kind"] == "list" + and field["type"]["item"]["kind"] == "string" + ) + list_field["encoded_default"] = ["x"] * 2000 + directory = base / "giant-list-default" + write_schema_set(directory, wire, mutation, digests) + expect_schema_error(lambda: tool.SchemaBundle.from_dir(directory), "giant list default") + + mutation = copy.deepcopy(records) + map_field = next( + field + for record in mutation["records"] + for field in record["fields"] + if field["type"]["kind"] == "map" + ) + map_field["encoded_default"] = {f"k{index}": "" for index in range(1100)} + directory = base / "giant-map-default" + write_schema_set(directory, wire, mutation, digests) + expect_schema_error(lambda: tool.SchemaBundle.from_dir(directory), "giant map default") + + mutation = copy.deepcopy(digests) + mutation["domains"][0]["formula"] = {"op": "call"} + directory = base / "digest-expression" + write_schema_set(directory, wire, records, mutation) + expect_schema_error(lambda: tool.SchemaBundle.from_dir(directory), "digest expression") + + mutation = copy.deepcopy(digests) + mutation["domains"][0]["result"] = {"scalar": "context-lookup"} + directory = base / "digest-result-policy" + write_schema_set(directory, wire, records, mutation) + expect_schema_error(lambda: tool.SchemaBundle.from_dir(directory), "digest result policy") + + mutation = copy.deepcopy(records) + incomplete = next( + field + for record in mutation["records"] + for field in record["fields"] + if field["type"]["kind"] == "record" + and isinstance(field["encoded_default"], dict) + and field["encoded_default"] + ) + incomplete["encoded_default"].pop(next(iter(incomplete["encoded_default"]))) + directory = base / "incomplete-record-default" + write_schema_set(directory, wire, mutation, digests) + expect_schema_error(lambda: tool.SchemaBundle.from_dir(directory), "incomplete record default") + + mutation = copy.deepcopy(records) + mutation["records"][0]["fields"][1]["tag"] = mutation["records"][0]["fields"][0]["tag"] + directory = base / "duplicate-tag" + write_schema_set(directory, wire, mutation, digests) + expect_schema_error(lambda: tool.SchemaBundle.from_dir(directory), "duplicate tag") + + mutation = copy.deepcopy(records) + mutation["enums"][0]["values"][1]["value"] = mutation["enums"][0]["values"][0]["value"] + directory = base / "duplicate-enum" + write_schema_set(directory, wire, mutation, digests) + expect_schema_error(lambda: tool.SchemaBundle.from_dir(directory), "duplicate enum value") + + mutation = copy.deepcopy(digests) + mutation["domains"][1]["separator_utf8_hex"] = mutation["domains"][0]["separator_utf8_hex"] + directory = base / "duplicate-domain" + write_schema_set(directory, wire, records, mutation) + expect_schema_error(lambda: tool.SchemaBundle.from_dir(directory), "duplicate digest separator") + + mutation = copy.deepcopy(digests) + mutation["domains"][0]["separator_utf8_hex"] = "ff00" + directory = base / "invalid-utf8-separator" + write_schema_set(directory, wire, records, mutation) + expect_schema_error(lambda: tool.SchemaBundle.from_dir(directory), "invalid UTF-8 separator") + + mutation = copy.deepcopy(digests) + mutation["domains"][0]["separator_utf8_hex"] = "78007900" + directory = base / "interior-nul-separator" + write_schema_set(directory, wire, records, mutation) + expect_schema_error(lambda: tool.SchemaBundle.from_dir(directory), "interior NUL separator") + + wrong_result_record = next(name for name in bundle.records if name not in bundle.unions) + for formula, label in ( + (tool.FORMULA_BYTES, "blob"), + (tool.FORMULA_RECORD, "record"), + ): + mutation = copy.deepcopy(digests) + result_domain = next( + domain + for domain in mutation["domains"] + if tuple(domain["formula"]) == formula and "record" in domain["result"] + ) + result_domain["result"]["record"] = wrong_result_record + directory = base / f"wrong-{label}-result-record" + write_schema_set(directory, wire, records, mutation) + expect_schema_error( + lambda directory=directory: tool.SchemaBundle.from_dir(directory), + f"wrong {label} result record", + ) + + mutation = copy.deepcopy(records) + union_case = mutation["unions"][0]["cases"][0] + union_case["allowed"].append(union_case["empty"][0]) + directory = base / "union-allowed-empty-overlap" + write_schema_set(directory, wire, mutation, digests) + expect_schema_error(lambda: tool.SchemaBundle.from_dir(directory), "union allowed/empty overlap") + + mutation = copy.deepcopy(records) + union_case = next( + case + for union in mutation["unions"] + for case in union["cases"] + if case["nonempty"] + ) + union_case["required"].remove(union_case["nonempty"][0]) + directory = base / "union-nonempty-not-required" + write_schema_set(directory, wire, mutation, digests) + expect_schema_error(lambda: tool.SchemaBundle.from_dir(directory), "union nonempty not required") + + duplicate = base / "duplicate.json" + duplicate.write_text('{"format":"x","format":"y"}\n', encoding="utf-8") + expect_schema_error(lambda: tool.load_json(duplicate), "duplicate JSON key") + + first_dir = base / "alpha-a" + second_dir = base / "alpha-b" + write_schema_set(first_dir, wire, synthetic_records("Box", "Shade", "hue"), synthetic_digests("Box")) + write_schema_set(second_dir, wire, synthetic_records("Crate", "Tone", "tint"), synthetic_digests("Crate")) + first_table = first_dir / "table.json" + second_table = second_dir / "table.json" + tool.generate_table(first_dir, first_table) + tool.generate_table(second_dir, second_table) + first = tool.load_json(first_table) + second = tool.load_json(second_table) + first.pop("schema_digest") + first.pop("schema_files") + second.pop("schema_digest") + second.pop("schema_files") + second = replace_exact_strings(second, {"Crate": "Box", "Tone": "Shade", "tint": "hue"}) + if first != second: + fail("alpha-renamed synthetic schemas changed generator behavior") + + third_dir = base / "different-tag-default" + write_schema_set( + third_dir, + wire, + synthetic_records("Vessel", "Hue", "shade", tag=23, default="blue"), + synthetic_digests("Vessel"), + ) + third = tool.SchemaBundle.from_dir(third_dir) + encoded = third.encode_record("Vessel", {}) + raw = tool.decode_envelope(encoded, third.wire) + if raw["record"][0][0] != 23 or third.decode_record("Vessel", encoded) != {"shade": "blue"}: + fail("synthetic changed tag/default did not drive the generic codec") + + expect_assertion( + lambda: exact_keys( + {"format": "x", "version": 1, "cases": [], "provider_policy": {}}, + {"format", "version", "cases"}, + "synthetic vector", + ), + "vector policy root", + ) + + duplicate_ids: set[str] = set() + register_case_id({"id": "same"}, duplicate_ids, "synthetic vector") + expect_assertion( + lambda: register_case_id({"id": "same"}, duplicate_ids, "synthetic vector"), + "duplicate vector id", + ) + + stale = tool.load_json(GENERATED) + first_record = next(iter(stale["records"].values())) + if not first_record[1]: + fail("cannot construct stale-output mutation") + first_record[1][0][0] += 100 + stale_path = base / "stale.json" + stale_path.write_bytes(tool.canonical_json(stale)) + run_tool("check-output", "--schema-dir", str(SCHEMA), "--output", str(stale_path), expect=2) + + +def check_tool_independence(bundle: tool.SchemaBundle) -> None: + source = (ROOT / "tool.py").read_text(encoding="utf-8") + tree = ast.parse(source, filename="tool.py") + allowed_imports = { + "argparse", + "copy", + "hashlib", + "json", + "pathlib", + "struct", + "sys", + "unicodedata", + "dataclasses", + "typing", + "__future__", + } + forbidden_calls = {"eval", "exec", "compile", "getattr", "setattr", "delattr", "id"} + for node in ast.walk(tree): + if isinstance(node, ast.Import): + for alias in node.names: + if alias.name.split(".")[0] not in allowed_imports: + fail(f"tool.py imports disallowed module {alias.name}") + elif isinstance(node, ast.ImportFrom): + if (node.module or "").split(".")[0] not in allowed_imports: + fail(f"tool.py imports from disallowed module {node.module}") + elif isinstance(node, ast.Call) and isinstance(node.func, ast.Name) and node.func.id in forbidden_calls: + fail(f"tool.py uses forbidden dynamic call {node.func.id}") + action_spellings = { + value["name"] + for enum in bundle.enums.values() + if any("." in value["name"] for value in enum["values"]) + for value in enum["values"] + } + semantic_identifiers = ( + set(bundle.records) + | set(bundle.enums) + | {row["name"] for row in bundle.records_data["unions"]} + | set(bundle.wrappers) + | (set(bundle.domains) - {"blob", "record"}) + | action_spellings + | { + value["name"] + for enum in bundle.enums.values() + for value in enum["values"] + if "." in value["name"] + } + ) + for filename in ("tool.py", "check.py"): + parsed = ast.parse((ROOT / filename).read_text(encoding="utf-8"), filename=filename) + for node in ast.walk(parsed): + if isinstance(node, ast.Call) and isinstance(node.func, ast.Name): + if node.func.id in forbidden_calls: + fail(f"{filename} uses forbidden dynamic/object-identity call {node.func.id}") + if ( + isinstance(node, ast.Constant) + and isinstance(node.value, str) + and node.value in semantic_identifiers + ): + fail(f"{filename} hard-codes schema semantic identifier {node.value}") + + +def check_deterministic_generation(bundle: tool.SchemaBundle) -> None: + checked = GENERATED.read_bytes() + expected = tool.expected_table(SCHEMA) + if checked != expected: + fail("checked-in generated output is stale") + generated = tool.load_json(GENERATED) + exact_keys( + generated, + { + "format", + "version", + "schema_digest", + "schema_files", + "wire", + "scalars", + "paths", + "enums", + "records", + "unions", + "kinds", + "artifacts", + "wrappers", + "digests", + }, + "generated table", + ) + if generated != bundle.generated_table(): + fail("generated table is not the exact compiled codec projection") + with tempfile.TemporaryDirectory(prefix="wwar-generate-a-") as first_tmp, tempfile.TemporaryDirectory( + prefix="wwar-generate-b-" + ) as second_tmp: + first = pathlib.Path(first_tmp) / "generated" / GENERATED.name + second = pathlib.Path(second_tmp) / "generated" / GENERATED.name + run_tool("emit-tables", "--schema-dir", str(SCHEMA), "--output", str(first)) + run_tool("emit-tables", "--schema-dir", str(SCHEMA), "--output", str(second)) + run_tool("check-output", "--schema-dir", str(SCHEMA), "--output", str(first)) + run_tool("check-output", "--schema-dir", str(SCHEMA), "--output", str(second)) + if first.read_bytes() != second.read_bytes() or first.read_bytes() != checked: + fail("two clean generations and checked-in output are not byte-identical") + + +def check_size_budgets() -> None: + byte_limits = { + "README.md": 64 * 1024, + "check.py": 256 * 1024, + "tool.py": 256 * 1024, + "schema/digests.json": 128 * 1024, + "schema/records.json": 1024 * 1024, + "schema/wire.json": 64 * 1024, + "schema/wwar-v1.sha256": 1024, + "generated/wwar_v1_tables.json": 512 * 1024, + "vectors/digests.json": 512 * 1024, + "vectors/records.json": 1024 * 1024, + "vectors/wire-invalid.json": 256 * 1024, + "vectors/wire-valid.json": 256 * 1024, + } + schema_lines = 0 + human_lines = 0 + human_bytes = 0 + total_bytes = 0 + for path in sorted(EXPECTED_FILES): + full = ROOT / path + raw = full.read_bytes() + lines = len(raw.splitlines()) + total_bytes += len(raw) + if len(raw) > byte_limits[path]: + fail(f"Phase 0 file exceeds byte budget: {path} ({len(raw)} bytes)") + if not path.startswith("generated/"): + human_lines += lines + human_bytes += len(raw) + if path.startswith("schema/") and path.endswith(".json"): + schema_lines += lines + if lines > 5000: + fail(f"human-authored schema file exceeds 5000 lines: {path}") + if schema_lines >= 5000 or human_lines >= 15000 or human_bytes >= 2 * 1024 * 1024: + fail( + "Phase 0 human-authored budget exceeded: " + f"schema_lines={schema_lines}, human_lines={human_lines}, human_bytes={human_bytes}" + ) + if total_bytes >= 4 * 1024 * 1024: + fail(f"Phase 0 total byte budget exceeded: {total_bytes}") + + +def main() -> int: + check_no_bytecode() + check_files() + bundle = tool.SchemaBundle.from_dir(SCHEMA) + check_tool_independence(bundle) + check_deterministic_generation(bundle) + check_wire_vectors(bundle) + check_record_vectors(bundle) + check_assignment_probes(bundle) + check_digest_vectors(bundle) + check_genericity_and_mutations(bundle) + check_size_budgets() + check_no_bytecode() + print( + "WWAR v1 protocol OK: " + f"{len(bundle.records)} records, " + f"{sum(len(row['fields']) for row in bundle.records.values())} fields, " + f"{len(bundle.enums)} enums, {len(bundle.domains)} digest domains" + ) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/protocol/generated/wwar_v1_tables.json b/protocol/generated/wwar_v1_tables.json new file mode 100644 index 00000000..c9d8a509 --- /dev/null +++ b/protocol/generated/wwar_v1_tables.json @@ -0,0 +1 @@ +{"artifacts":{"action-record":["record",11,1],"action-result":["record",12,1],"archive":["blob",0,0],"crt":["blob",0,0],"export":["record",18,1],"file":["blob",0,0],"import-library":["blob",0,0],"loader":["blob",0,0],"native-abi":["record",16,1],"native-sidecar":["record",15,1],"object":["blob",0,0],"package-link":["record",19,1],"script":["blob",0,0],"shared":["blob",0,0],"tree":["record",1,1]},"digests":{"action-key":["sha256","57572d414354494f4e2d4b455900",{"encoding":"WWAR","record":"ActionRecordV1"},["separator","u64be(encoded-length)","encoded-bytes"],null],"blob":["sha256","57572d424c4f4200",{"kind":"bytes"},["separator","u64be(input-length)","input-bytes"],null],"calling-conventions":["sha256","57572d43414c4c494e472d434f4e56454e54494f4e532d563100",{"encoding":"WWAR","record":"CallingConventionTableProjectionV1"},["separator","u64be(encoded-length)","encoded-bytes"],null],"export-declaration-abi":["sha256","57572d4558504f52542d4445434c2d4142492d563100",{"encoding":"WWAR","record":"ExportDeclarationABIProjectionV1"},["separator","u64be(encoded-length)","encoded-bytes"],null],"native-data-layout":["sha256","57572d4e41544956452d444154412d4c41594f55542d563100",{"encoding":"WWAR","record":"NativeDataLayoutProjectionV1"},["separator","u64be(encoded-length)","encoded-bytes"],null],"native-header-contract":["sha256","57572d4e41544956452d4845414445522d434f4e54524143542d563100",{"encoding":"WWAR","record":"NativeHeaderContractProjectionV1"},["separator","u64be(encoded-length)","encoded-bytes"],null],"native-type-contract":["sha256","57572d4e41544956452d545950452d434f4e54524143542d563100",{"encoding":"WWAR","record":"NativeTypeContractProjectionV1"},["separator","u64be(encoded-length)","encoded-bytes"],null],"origin-type-contract":["sha256","57572d4f524947494e2d545950452d434f4e54524143542d563100",{"encoding":"WWAR","record":"OriginTypeContractProjectionV1"},["separator","u64be(encoded-length)","encoded-bytes"],null],"public-abi":["sha256","57572d5055424c49432d4142492d563100",{"encoding":"WWAR","record":"PublicABIProjectionV1"},["separator","u64be(encoded-length)","encoded-bytes"],null],"public-type":["sha256","57572d5055424c49432d545950452d563100",{"encoding":"WWAR","record":"PublicTypeProjectionV1"},["separator","u64be(encoded-length)","encoded-bytes"],null],"record":["sha256","57572d5245434f524400",{"encoding":"WWAR","record":"top-level record"},["separator","u32be(record-kind)","u32be(record-schema)","u64be(encoded-length)","encoded-bytes"],null],"source-tree":["sha256","77772d736f757263652d747265652d763100",{"encoding":"special-source-tree-v1","record":"SourceTreeProjectionV1"},["separator","concatenate entry path,type,executable,content frames"],{"content":{"dir":["u64be",0],"file":["u64be",32,"raw-sha256"]},"executable":{"directory":0,"false":0,"true":1},"order":"raw-utf8-path-bytes","path":["u64be-byte-length","raw-nfc-utf8"],"type":{"dir":1,"file":2}}]},"enums":{"ActionKind":[[1,"ww.package"],[2,"ww.init"],[3,"native.compile"],[4,"archive"],[5,"link"],[6,"generate"],[7,"doc"],[8,"bootstrap.compare"]],"ArtifactKind":[[1,"file"],[2,"tree"],[3,"object"],[4,"archive"],[5,"shared"],[6,"import-library"],[7,"script"],[8,"crt"],[9,"loader"],[10,"native-sidecar"],[11,"native-abi"],[12,"export"],[13,"package-link"],[14,"action-record"],[15,"action-result"]],"ArtifactNamespace":[[1,"source"],[2,"generated"],[3,"package"],[4,"toolchain"],[5,"sysroot"],[6,"provider-output"],[7,"cas"],[8,"graph"]],"Binding":[[1,"strong"],[2,"weak"]],"BootstrapHostClosureRole":[[1,"preprocessor-compiler"],[2,"headers"],[3,"libc"],[4,"assembler"],[5,"linker"],[6,"loader-resources"]],"BootstrapRawRecordKind":[[11,"action-record"],[12,"action-result"]],"DigestAlgorithm":[[1,"sha256"]],"DigestDomain":[[1,"blob"],[2,"record"]],"EdgeKind":[[1,"package-import"],[2,"generated-input"],[3,"tool"],[4,"native-provider"],[5,"runtime"],[6,"ordered-link"],[7,"source-input"],[8,"bootstrap-record"]],"Endian":[[1,"little"],[2,"big"]],"EvidenceSource":[[1,"inspected"],[2,"declared"]],"Exposure":[[1,"opaque"],[2,"layout"]],"FinalLinkTokenKind":[[1,"object"],[2,"archive"],[3,"shared"],[5,"group"],[6,"whole"],[7,"as-needed"],[8,"linker-script"],[9,"version-script"],[10,"export-map"],[11,"def-file"],[12,"runtime-search"],[13,"install-name"],[14,"dynamic-loader"],[15,"entry"],[16,"retain"]],"IncludeClass":[[1,"quote"],[2,"user"],[3,"system"],[4,"framework"]],"InputDeclKind":[[1,"file"],[2,"tree"],[3,"artifact"],[4,"tool"]],"LinkTokenKind":[[1,"object"],[2,"archive"],[3,"shared"],[4,"provider"],[5,"group"],[6,"whole"],[7,"as-needed"],[8,"linker-script"],[9,"version-script"],[10,"export-map"],[11,"def-file"],[12,"runtime-search"],[13,"install-name"],[14,"dynamic-loader"],[15,"entry"],[16,"retain"],[17,"splice"],[18,"script-slot"]],"Linkage":[[1,"dynamic"],[2,"pie"],[3,"static"],[4,"static-pie"],[5,"shared"],[6,"none"]],"LtoMode":[[1,"none"],[2,"thin"],[3,"full"]],"Optimization":[[1,"0"],[2,"1"],[3,"2"],[4,"3"],[5,"size"]],"OutputKind":[[1,"file"],[2,"tree"]],"OverflowMode":[[1,"trap"],[2,"wrap"]],"PanicMode":[[1,"abort"],[2,"runtime"]],"PicPolicy":[[1,"any"],[2,"required"],[3,"forbidden"]],"PreprocessingMode":[[1,"none"],[2,"c-preprocessor"]],"ProductKind":[[1,"exe"],[2,"static"],[3,"shared"],[4,"object"],[5,"generated"]],"RelocationRequirement":[[1,"required"],[2,"forbidden"]],"Reproducibility":[[1,"required"],[2,"impure"]],"RuntimePhase":[[1,"link"],[2,"load"],[3,"both"]],"SemanticMode":[[1,"data"],[2,"executable"]],"SharedLibraryKind":[[1,"elf-shared"],[2,"macho-dylib"],[3,"pe-import"]],"SourceEntryType":[[1,"dir"],[2,"file"]],"StripMode":[[1,"none"],[2,"debug"],[3,"all"]],"SymbolKind":[[1,"function"],[2,"data"],[3,"tls"],[4,"ifunc"]],"SymbolRole":[[1,"define"],[2,"require"]],"TreeEntryKind":[[1,"file"],[2,"tree"]],"TypeContractKind":[[1,"opaque"],[2,"scalar"],[3,"enum"],[4,"struct"],[5,"union"],[6,"function"]],"TypeFieldRole":[[1,"field"],[2,"base"],[3,"opaque"]],"TypeNodeKind":[[1,"void"],[2,"bool"],[3,"rune"],[4,"i8"],[5,"i16"],[6,"i32"],[7,"i64"],[8,"u8"],[9,"u16"],[10,"u32"],[11,"u64"],[12,"uint"],[13,"int"],[14,"uintptr"],[15,"size"],[16,"f32"],[17,"f64"],[18,"str"],[19,"ptr"],[20,"slice"],[21,"array"],[22,"struct"],[23,"function"],[24,"channel"],[25,"named"],[26,"tuple"],[27,"tagged"],[28,"error"],[29,"never"],[30,"enum"],[31,"opaque"]],"TypeRepr":[[1,"ww"],[2,"c"],[3,"opaque"]],"TypeVisibility":[[1,"exported"],[2,"private"]],"Visibility":[[1,"default"],[2,"protected"],[3,"hidden"]]},"format":"wwar-v1-tables","kinds":{"1":["TreeV1",1],"10":["ActionTemplateV1",1],"11":["ActionRecordV1",1],"12":["ActionResultV1",1],"13":["ObservationV1",1],"14":["GraphSnapshotV1",1],"15":["NativeSidecarV1",1],"16":["NativeABIContractV1",1],"17":["LinkPlanV1",1],"18":["ExportV1",1],"19":["PackageLinkV1",1],"2":["ManifestV1",1],"20":["InstallManifestV1",1],"21":["BootstrapPlanV1",1],"22":["SelectedToolClosureV1",1],"3":["LockV1",1],"4":["WorkV1",1],"5":["VendorV1",1],"6":["NativeMapV1",1],"7":["PlatformDescriptorV1",1],"8":["ToolchainV1",1],"9":["ProfileV1",1]},"paths":{"artifact-relative":["path",false,false,false,false,null],"bundle-relative":["path",false,false,false,false,null],"install-destination":["path",false,false,false,false,null],"package-relative":["path",false,true,false,false,null],"sandbox-execution":["path",true,false,false,true,["/data","/in","/out","/tool","/work"]],"source-relative":["path",false,false,false,false,null],"target-runtime":["path",true,false,false,false,null],"tree-segment":["single-segment",false,false,false,false,null],"vendor-relative":["path",false,false,false,false,null],"workspace-location":["path","either",true,true,false,null]},"records":{"ABIProtocolSetV1":[null,[[1,"object",["string","ProtocolId"],"1",null,"none",[]],[2,"runtime",["string","ProtocolId"],"1",null,"none",[]]]],"ActionIdentityV1":[null,[[1,"logical-identity",["string","Identity"],"1",null,"none",[]],[2,"cwd",["string","PathSandbox"],"1","/work","none",[]]]],"ActionKindVersionV1":[null,[[1,"kind",["enum","ActionKind"],"1",null,"none",[]],[2,"version",["uint",null],"1",1,"none",[]]]],"ActionOutputV1":[null,[[1,"name",["string","PathArtifact"],"1",null,"none",[]],[2,"path",["string","PathArtifact"],"1",null,"none",[]],[3,"artifact-kind",["enum","ArtifactKind"],"1",null,"none",[]],[4,"mode",["enum","SemanticMode"],"1","data","none",[]],[5,"canonicalization",["string","CapabilityId"],"1",null,"none",[]]]],"ActionRecordV1":[11,[[1,"schema",["uint",null],"1",1,"none",[]],[2,"kind-version",["record","ActionKindVersionV1"],"1",null,"none",[]],[3,"protocols",["record","ProtocolBundleV1"],"1",null,"none",[]],[4,"platform-roles",["record","PlatformRolesV1"],"1",null,"none",[]],[5,"selected-tool-closure",["record","SelectedClosureRefV1"],"1",null,"none",[]],[6,"profile",["record","ProfileV1"],"1",null,"none",[]],[7,"identity",["record","ActionIdentityV1"],"1",null,"none",[]],[8,"argv",["list",["string",null]],"*",[],"ordered",[]],[9,"environment",["map",["string",null]],"map",{},"raw-utf8",["key"]],[10,"inputs",["list",["record","ResolvedInputV1"]],"*",[],"sorted",["name"]],[11,"source-selection",["record","SourceSelectionV1"],"1",{"members":[],"target-tags":[]},"none",[]],[12,"native-link",["record","ResolvedNativeLinkV1"],"1",{"link-plan":{},"providers":[],"required-provider-slots":[]},"none",[]],[13,"outputs",["list",["record","ActionOutputV1"]],"*",[],"sorted",["name"]],[14,"sandbox",["record","SandboxPolicyV1"],"1",null,"none",[]]]],"ActionResultV1":[12,[[1,"schema",["uint",null],"1",1,"none",[]],[2,"action-key",["bytes","ActionKey"],"1",null,"none",[]],[3,"action-record",["record","TypedDigestV1"],"1",null,"none",[]],[4,"outputs",["list",["record","ResultOutputV1"]],"*",[],"sorted",["name"]]]],"ActionTemplateV1":[10,[[1,"schema",["uint",null],"1",1,"none",[]],[2,"kind-version",["record","ActionKindVersionV1"],"1",null,"none",[]],[3,"protocols",["record","ProtocolBundleV1"],"1",null,"none",[]],[4,"platform-roles",["record","PlatformRolesV1"],"1",null,"none",[]],[5,"selected-tool-closure",["record","SelectedClosureRefV1"],"1",null,"none",[]],[6,"profile",["record","ProfileV1"],"1",null,"none",[]],[7,"identity",["record","ActionIdentityV1"],"1",null,"none",[]],[8,"argv",["list",["string",null]],"*",[],"ordered",[]],[9,"environment",["map",["string",null]],"map",{},"raw-utf8",["key"]],[10,"inputs",["list",["record","TemplateInputV1"]],"*",[],"sorted",["name"]],[11,"source-selection",["record","SourceSelectionV1"],"1",{"members":[],"target-tags":[]},"none",[]],[12,"native-link",["record","TemplateNativeLinkV1"],"1",{"link-policy":{},"providers":[],"required-provider-slots":[]},"none",[]],[13,"outputs",["list",["record","ActionOutputV1"]],"*",[],"sorted",["name"]],[14,"sandbox",["record","SandboxPolicyV1"],"1",null,"none",[]]]],"ArchiveMemberV1":[null,[[1,"name",["string",null],"1",null,"none",[]],[2,"member",["record","TypedDigestV1"],"1",null,"none",[]],[3,"sidecar",["record","ArtifactRefV1"],"1",null,"none",[]]]],"ArchiveV1":[null,[[1,"name",["string","Identifier"],"1",null,"none",[]],[2,"archive",["record","ArtifactRefV1"],"1",null,"none",[]],[3,"sidecar",["record","ArtifactRefV1"],"1",null,"none",[]],[4,"members",["list",["record","ArchiveMemberV1"]],"*",[],"ordered",[]],[5,"contract",["record","ArtifactRefV1"],"1",null,"none",[]]]],"ArtifactLocatorV1":[null,[[1,"namespace",["enum","ArtifactNamespace"],"1",null,"none",[]],[2,"owner",["string","IdentityOrEmpty"],"1","","none",[]],[3,"name",["string","PathArtifact"],"1",null,"none",[]],[4,"artifact-kind",["enum","ArtifactKind"],"1",null,"none",[]]]],"ArtifactRefV1":[null,[[1,"namespace",["enum","ArtifactNamespace"],"1",null,"none",[]],[2,"owner",["string","IdentityOrEmpty"],"1","","none",[]],[3,"name",["string","PathArtifact"],"1",null,"none",[]],[4,"artifact-kind",["enum","ArtifactKind"],"1",null,"none",[]],[5,"expected",["record","TypedDigestV1"],"0/1",{},"none",[]],[6,"mode",["enum","SemanticMode"],"1","data","none",[]]]],"BootstrapHostClosureEntryV1":[null,[[1,"role",["enum","BootstrapHostClosureRole"],"1",null,"none",[]],[2,"digest",["record","TypedDigestV1"],"1",null,"none",[]]]],"BootstrapHostClosureV1":[null,[[1,"command",["record","RecordedCommandV1"],"1",null,"none",[]],[2,"entries",["list",["record","BootstrapHostClosureEntryV1"]],"*",[],"sorted",["role"]]]],"BootstrapHostContractV1":[null,[[1,"c-standard",["string","BootstrapCStandard"],"1","C99","none",[]],[2,"char-bit",["uint","BootstrapCharBit"],"1",8,"none",[]],[3,"integer-contract",["string","BootstrapIntegerContract"],"1","exact-u8-u32-u64-twos-complement","none",[]],[4,"address-bits-min",["uint",null],"1",32,"none",[]],[5,"required-headers",["list",["string",null]],"*",[],"sorted",["value"]],[6,"implementation-modes",["list",["string",null]],"*",[],"sorted",["value"]],[7,"source-size-max",["uint",null],"1",null,"none",[]],[8,"object-size-max",["uint",null],"1",null,"none",[]]]],"BootstrapOutputRoleV1":[null,[[1,"role",["string","Identifier"],"1",null,"none",[]],[2,"artifact-kind",["enum","ArtifactKind"],"1",null,"none",[]]]],"BootstrapPlanV1":[21,[[1,"schema",["uint",null],"1",1,"none",[]],[2,"bootstrap-host",["record","BootstrapHostContractV1"],"1",null,"none",[]],[3,"sources",["list",["record","ArtifactRefV1"]],"*",[],"ordered",[]],[4,"portable-c-settings",["record","PortableCSettingsV1"],"1",null,"none",[]],[5,"host-c-closure",["record","BootstrapHostClosureV1"],"1",null,"none",[]],[6,"stage1-outputs",["list",["record","ActionOutputV1"]],"*",[],"sorted",["name"]],[7,"production-toolchain",["record","SelectedClosureRefV1"],"1",null,"none",[]],[8,"fixed-point-roots",["list",["record","ArtifactRefV1"]],"*",[],"ordered",[]],[9,"semantic-roles",["list",["record","BootstrapOutputRoleV1"]],"*",[],"sorted",["role"]],[10,"raw-record-roles",["list",["record","BootstrapRawRecordRoleV1"]],"*",[],"sorted",["role"]]]],"BootstrapRawRecordRoleV1":[null,[[1,"role",["string","Identifier"],"1",null,"none",[]],[2,"record-kind",["enum","BootstrapRawRecordKind"],"1",null,"none",[]]]],"BundleProvenanceV1":[null,[[1,"tree",["record","TypedDigestV1"],"1",null,"none",[]],[2,"signature",["bytes",null],"0/1","","none",[]],[3,"provenance",["string",null],"0/1","","none",[]]]],"CABIDataModelV1":[null,[[1,"c-abi",["string","CapabilityId"],"1",null,"none",[]],[2,"data-model",["string","CapabilityId"],"1",null,"none",[]],[3,"calling-conventions",["map",["string",null]],"map",{},"raw-utf8",["key"]]]],"CPUCapabilitiesV1":[null,[[1,"baseline",["string","CapabilityId"],"1",null,"none",[]],[2,"required",["list",["string",null]],"*",[],"sorted",["value"]],[3,"forbidden",["list",["string",null]],"*",[],"sorted",["value"]],[4,"atomics",["list",["string",null]],"*",[],"sorted",["value"]]]],"CallingConventionTableProjectionV1":[null,[[1,"c-abi",["string","CapabilityId"],"1",null,"none",[]],[2,"data-model",["string","CapabilityId"],"1",null,"none",[]],[3,"conventions",["map",["string",null]],"map",{},"raw-utf8",["key"]]]],"DataLayoutV1":[null,[[1,"integer-widths",["map",["uint",null]],"map",{},"raw-utf8",["key"]],[2,"alignments",["map",["uint",null]],"map",{},"raw-utf8",["key"]],[3,"aggregate-algorithm",["string","CapabilityId"],"1",null,"none",[]]]],"DeclarationABIRefV1":[null,[[1,"kind",["string","CapabilityId"],"1",null,"none",[]],[2,"name",["string","Identifier"],"1",null,"none",[]],[3,"overload",["string",null],"1","","none",[]],[4,"abi-digest",["bytes","DigestBytes"],"1",null,"none",[]]]],"EnumMemberV1":[null,[[1,"name",["string","Identifier"],"1",null,"none",[]],[2,"negative",["bool",null],"1",false,"none",[]],[3,"magnitude",["uint",null],"1",0,"none",[]]]],"EvidencedAttributeMapV1":[null,[[1,"evidence",["enum","EvidenceSource"],"1",null,"none",[]],[2,"value",["map",["string",null]],"map",{},"raw-utf8",["key"]]]],"EvidencedNativeABIPlatformV1":[null,[[1,"evidence",["enum","EvidenceSource"],"1",null,"none",[]],[2,"value",["record","NativeABIPlatformV1"],"1",null,"none",[]]]],"EvidencedNativeMachineFactsV1":[null,[[1,"evidence",["enum","EvidenceSource"],"1",null,"none",[]],[2,"value",["record","NativeMachineFactsV1"],"1",null,"none",[]]]],"EvidencedRelocationFactV1":[null,[[1,"evidence",["enum","EvidenceSource"],"1",null,"none",[]],[2,"value",["record","RelocationFactV1"],"1",null,"none",[]]]],"EvidencedSectionFactV1":[null,[[1,"evidence",["enum","EvidenceSource"],"1",null,"none",[]],[2,"value",["record","SectionFactV1"],"1",null,"none",[]]]],"EvidencedSymbolFactV1":[null,[[1,"evidence",["enum","EvidenceSource"],"1",null,"none",[]],[2,"value",["record","SymbolFactV1"],"1",null,"none",[]]]],"ExportABIV1":[null,[[1,"product-platform",["record","TypedDigestV1"],"1",null,"none",[]],[2,"c-abi",["string","CapabilityId"],"1",null,"none",[]],[3,"object-abi",["string","ProtocolId"],"1",null,"none",[]],[4,"runtime-abi",["string","ProtocolId"],"1",null,"none",[]]]],"ExportDeclarationABIProjectionV1":[null,[[1,"abi",["record","ExportABIV1"],"1",null,"none",[]],[2,"package",["record","PackageNameV1"],"1",null,"none",[]],[3,"kind",["string","CapabilityId"],"1",null,"none",[]],[4,"name",["string","Identifier"],"1",null,"none",[]],[5,"overload",["string",null],"1","","none",[]],[6,"root",["uint",null],"1",1,"none",[]],[7,"type-closure",["list",["record","TypeGraphNodeV1"]],"*",[],"ordered",[]],[8,"foreign",["record","NativeSymbolContractV1"],"0/1",{},"none",[]]]],"ExportDeclarationV1":[null,[[1,"kind",["string","CapabilityId"],"1",null,"none",[]],[2,"name",["string","Identifier"],"1",null,"none",[]],[3,"overload",["string",null],"1","","none",[]],[4,"type-node",["uint",null],"1",null,"none",[]],[5,"constant-bits",["bytes",null],"0/1","","none",[]],[6,"foreign",["record","NativeSymbolContractV1"],"0/1",{},"none",[]],[7,"abi-digest",["bytes","DigestBytes"],"1",null,"none",[]]]],"ExportOriginTypeV1":[null,[[1,"package",["string","PackageIdentity"],"1",null,"none",[]],[2,"type",["string","Identifier"],"1",null,"none",[]],[3,"contract",["bytes","DigestBytes"],"1",null,"none",[]]]],"ExportV1":[18,[[1,"schema",["uint",null],"1",1,"none",[]],[2,"reader-capabilities",["list",["string",null]],"*",[],"sorted",["value"]],[3,"language-type-protocol",["record","LanguageTypeProtocolV1"],"1",null,"none",[]],[4,"abi",["record","ExportABIV1"],"1",null,"none",[]],[5,"package",["record","PackageNameV1"],"1",null,"none",[]],[6,"origin-types",["list",["record","ExportOriginTypeV1"]],"*",[],"sorted",["package","type"]],[7,"type-graph",["list",["record","TypeGraphNodeV1"]],"*",[],"ordered",[]],[8,"declarations",["list",["record","ExportDeclarationV1"]],"*",[],"sorted",["kind","name","overload"]],[9,"public-init-abi",["record","PublicInitABIFactsV1"],"1",{"abi-facts":{},"foreign-providers":[],"init-symbols":[]},"none",[]],[10,"public-type-digest",["bytes","DigestBytes"],"1",null,"none",[]],[11,"public-abi-digest",["bytes","DigestBytes"],"1",null,"none",[]]]],"FloatVariadicNameV1":[null,[[1,"float-abi",["string","CapabilityId"],"1",null,"none",[]],[2,"variadic-abi",["string","CapabilityId"],"1",null,"none",[]],[3,"name-decoration",["string","CapabilityId"],"1",null,"none",[]]]],"GenerateDeclV1":[null,[[1,"name",["string","Identifier"],"1",null,"none",[]],[2,"tool",["record","ArtifactRefV1"],"1",null,"none",[]],[3,"platform",["string","BuildPlatform"],"1","build","none",[]],[4,"when",["record","TargetConstraintV1"],"0/1",{},"none",[]],[5,"inputs",["map",["record","InputDeclV1"]],"map",{},"raw-utf8",["key"]],[6,"outputs",["map",["record","OutputDeclV1"]],"map",{},"raw-utf8",["key"]],[7,"argv",["list",["string",null]],"*",[],"ordered",[]],[8,"environment",["map",["string",null]],"map",{},"raw-utf8",["key"]],[9,"resources",["record","ResourcePolicyV1"],"1",{"cpu-count":0,"memory-bytes":0,"output-bytes":0,"process-count":0},"none",[]],[10,"reproducibility",["enum","Reproducibility"],"1","required","none",[]]]],"GraphEdgeV1":[null,[[1,"consumer",["string","Identity"],"1",null,"none",[]],[2,"consumer-slot",["string","Identifier"],"1",null,"none",[]],[3,"producer",["string","Identity"],"1",null,"none",[]],[4,"producer-output",["string","PathArtifact"],"1",null,"none",[]],[5,"edge-kind",["enum","EdgeKind"],"1",null,"none",[]]]],"GraphNodeV1":[null,[[1,"node",["string","Identity"],"1",null,"none",[]],[2,"action-template",["record","TypedDigestV1"],"1",null,"none",[]],[3,"action-key",["bytes","ActionKey"],"0/1","","none",[]],[4,"action-record",["record","TypedDigestV1"],"0/1",{},"none",[]],[5,"action-result",["record","TypedDigestV1"],"0/1",{},"none",[]]]],"GraphSnapshotV1":[14,[[1,"schema",["uint",null],"1",1,"none",[]],[2,"root",["string","Identity"],"1",null,"none",[]],[3,"nodes",["list",["record","GraphNodeV1"]],"*",[],"sorted",["node"]],[4,"edges",["list",["record","GraphEdgeV1"]],"*",[],"sorted",["consumer","consumer-slot","producer","producer-output","edge-kind"]]]],"HeaderTreeProjectionV1":[null,[[1,"tree",["record","TypedDigestV1"],"1",null,"none",[]],[2,"class",["enum","IncludeClass"],"1",null,"none",[]],[3,"subdirectory",["string","PathPackage"],"1",".","none",[]]]],"HostedPolicyV1":[null,[[1,"hosted",["bool",null],"1",null,"none",[]],[2,"capabilities",["list",["string",null]],"*",[],"sorted",["value"]]]],"IncludeTreeRefV1":[null,[[1,"tree",["record","ArtifactRefV1"],"1",null,"none",[]],[2,"class",["enum","IncludeClass"],"1",null,"none",[]],[3,"subdirectory",["string","PathPackage"],"1",".","none",[]]]],"InitDependencyFactV1":[null,[[1,"init-symbol",["string",null],"1",null,"none",[]],[2,"dependencies",["list",["string",null]],"*",[],"sorted",["value"]],[3,"retain",["bool",null],"1",true,"none",[]]]],"InputDeclV1":[null,[[1,"kind",["enum","InputDeclKind"],"1",null,"none",[]],[2,"reference",["record","ArtifactLocatorV1"],"1",null,"none",[]],[3,"expected",["record","TypedDigestV1"],"0/1",{},"none",[]],[4,"mode",["enum","SemanticMode"],"1","data","none",[]]]],"InputSlotRefV1":[null,[[1,"slot",["string","Identifier"],"1",null,"none",[]],[2,"artifact-kind",["enum","ArtifactKind"],"1",null,"none",[]]]],"InstallEntryV1":[null,[[1,"artifact",["record","TypedDigestV1"],"1",null,"none",[]],[2,"mode",["enum","SemanticMode"],"1",null,"none",[]],[3,"destination",["string","PathInstall"],"1",null,"none",[]]]],"InstallManifestV1":[20,[[1,"schema",["uint",null],"1",1,"none",[]],[2,"product",["record","ProductKeyV1"],"1",null,"none",[]],[3,"entries",["list",["record","InstallEntryV1"]],"*",[],"sorted",["destination"]],[4,"runtime-policy",["record","RuntimeResolutionPolicyV1"],"1",null,"none",[]],[5,"runtime-closure",["list",["record","RuntimeClosureEntryV1"]],"*",[],"sorted",["runtime-identity"]],[6,"provenance",["record","TargetToolchainProvenanceV1"],"1",null,"none",[]]]],"LanguageTypeProtocolV1":[null,[[1,"language",["string","ProtocolId"],"1",null,"none",[]],[2,"type-system",["string","ProtocolId"],"1",null,"none",[]]]],"LinkPlanSelectionV1":[null,[[1,"product-platform",["record","TypedDigestV1"],"1",null,"none",[]],[2,"product-kind",["enum","ProductKind"],"1",null,"none",[]],[3,"linkage",["enum","Linkage"],"1",null,"none",[]],[4,"profile",["record","TypedDigestV1"],"1",null,"none",[]],[5,"runtime",["string","ProviderSlot"],"1","hosted","none",[]]]],"LinkPlanV1":[17,[[1,"schema",["uint",null],"1",1,"none",[]],[2,"selection",["record","LinkPlanSelectionV1"],"1",null,"none",[]],[3,"tokens",["list",["record","LinkTokenV1"]],"*",[],"ordered",[]],[4,"tools",["list",["record","InputSlotRefV1"]],"*",[],"sorted",["slot"]],[5,"non-link-policy",["list",["record","InputSlotRefV1"]],"*",[],"sorted",["slot"]],[6,"output-policy",["record","OutputABIInstallPolicyV1"],"1",null,"none",[]]]],"LinkPolicyV1":[null,[[1,"product-platform",["record","TypedDigestV1"],"1",null,"none",[]],[2,"product-kind",["enum","ProductKind"],"1",null,"none",[]],[3,"linkage",["enum","Linkage"],"1",null,"none",[]],[4,"profile-constraint",["list",["string",null]],"*",[],"sorted",["value"]],[5,"runtime",["string","ProviderSlot"],"1","hosted","none",[]],[6,"tokens",["list",["record","LinkTokenTemplateV1"]],"*",[],"ordered",[]],[7,"output-policy",["record","OutputABIInstallPolicyV1"],"1",null,"none",[]]]],"LinkTokenTemplateV1":[null,[[1,"kind",["enum","LinkTokenKind"],"1",null,"none",[]],[2,"artifact",["record","ArtifactRefV1"],"0/1",{},"none",[]],[3,"provider-slot",["string","ProviderSlot"],"0/1","","none",[]],[4,"value",["string",null],"0/1","","none",[]],[5,"enabled",["bool",null],"1",false,"none",[]],[6,"validated-path",["string","PathTargetRuntime"],"0/1","","none",[]],[7,"runtime-path",["string","PathTargetRuntime"],"0/1","","none",[]],[8,"items",["list",["record","LinkTokenTemplateV1"]],"*",[],"ordered",[]]]],"LinkTokenV1":[null,[[1,"kind",["enum","FinalLinkTokenKind"],"1",null,"none",[]],[2,"artifact",["record","InputSlotRefV1"],"0/1",{},"none",[]],[3,"provider-slot",["string","ProviderSlot"],"0/1","","none",[]],[4,"value",["string",null],"0/1","","none",[]],[5,"enabled",["bool",null],"1",false,"none",[]],[6,"validated-path",["string","PathTargetRuntime"],"0/1","","none",[]],[7,"runtime-path",["string","PathTargetRuntime"],"0/1","","none",[]],[8,"items",["list",["record","LinkTokenV1"]],"*",[],"ordered",[]]]],"LockV1":[3,[[1,"schema",["uint",null],"1",1,"none",[]],[2,"root-manifest",["record","TypedDigestV1"],"1",null,"none",[]],[3,"toolchain",["record","ToolchainLockV1"],"1",null,"none",[]],[4,"modules",["list",["record","ModuleLockV1"]],"*",[],"sorted",["module"]],[5,"native-map",["record","LockedObjectV1"],"0/1",{},"none",[]]]],"LockedObjectV1":[null,[[1,"origin",["string","Url"],"1",null,"none",[]],[2,"digest",["record","TypedDigestV1"],"1",null,"none",[]],[3,"signature",["bytes",null],"0/1","","none",[]]]],"ManifestV1":[2,[[1,"schema",["uint",null],"1",1,"none",[]],[2,"module",["string","ModuleIdentity"],"1",null,"none",[]],[3,"language",["string","ProtocolId"],"1",null,"none",[]],[4,"toolchain",["record","ToolchainRefV1"],"1",null,"none",[]],[5,"requires",["list",["record","RequireV1"]],"*",[],"sorted",["module"]],[6,"products",["list",["record","ProductV1"]],"*",[],"sorted",["name"]],[7,"packages",["list",["record","PackageConfigV1"]],"*",[],"sorted",["path"]],[8,"actions",["list",["record","GenerateDeclV1"]],"*",[],"sorted",["name"]],[9,"natives",["list",["record","NativeProviderV1"]],"*",[],"sorted",["name"]]]],"ModuleLockSignaturePayloadV1":[null,[[1,"schema",["uint",null],"1",1,"none",[]],[2,"module",["string","ModuleIdentity"],"1",null,"none",[]],[3,"version",["string","SemVer"],"1",null,"none",[]],[4,"tree",["bytes","SourceTreeDigest"],"1",null,"none",[]],[5,"manifest",["record","TypedDigestV1"],"1",null,"none",[]]]],"ModuleLockV1":[null,[[1,"module",["string","ModuleIdentity"],"1",null,"none",[]],[2,"version",["string","SemVer"],"1",null,"none",[]],[3,"origin",["string","Url"],"1",null,"none",[]],[4,"archive",["record","TypedDigestV1"],"1",null,"none",[]],[5,"tree",["bytes","SourceTreeDigest"],"1",null,"none",[]],[6,"manifest",["record","TypedDigestV1"],"1",null,"none",[]],[7,"signature",["bytes",null],"0/1","","none",[]],[8,"provenance",["string",null],"0/1","","none",[]]]],"NativeABIContractV1":[16,[[1,"schema",["uint",null],"1",1,"none",[]],[2,"slot",["string","ProviderSlot"],"1",null,"none",[]],[3,"platform",["record","NativeABIPlatformV1"],"1",null,"none",[]],[4,"symbols",["list",["record","NativeSymbolContractV1"]],"*",[],"sorted",["name","version","kind","role"]],[5,"types",["list",["record","NativeTypeContractV1"]],"*",[],"sorted",["identity"]],[6,"runtime-requires",["list",["record","NativeRuntimeRequirementV1"]],"*",[],"sorted",["slot","phase","runtime-identity"]],[7,"features",["record","NativeFeatureContractV1"],"1",null,"none",[]],[8,"minimum-platform",["record","PlatformVersionV1"],"0/1",{},"none",[]],[9,"code",["record","NativeCodeContractV1"],"1",null,"none",[]]]],"NativeABIPlatformV1":[null,[[1,"object-format",["string","CapabilityId"],"1",null,"none",[]],[2,"object-class",["string","CapabilityId"],"1",null,"none",[]],[3,"endian",["enum","Endian"],"1",null,"none",[]],[4,"machine-abi",["string","CapabilityId"],"1",null,"none",[]],[5,"c-abi",["string","CapabilityId"],"1",null,"none",[]],[6,"data-model",["string","CapabilityId"],"1",null,"none",[]],[7,"data-layout",["bytes","DigestBytes"],"1",null,"none",[]],[8,"calling-conventions",["bytes","DigestBytes"],"1",null,"none",[]],[9,"float-abi",["string","CapabilityId"],"1",null,"none",[]],[10,"variadic-abi",["string","CapabilityId"],"1",null,"none",[]],[11,"symbol-abi",["string","CapabilityId"],"1",null,"none",[]],[12,"object-abi",["string","ProtocolId"],"1",null,"none",[]],[13,"runtime-abi",["string","OptionalProtocolId"],"1","","none",[]]]],"NativeCodeContractV1":[null,[[1,"pic",["enum","PicPolicy"],"1","any","none",[]],[2,"tls-models",["list",["string",null]],"*",[],"sorted",["value"]],[3,"unwind-abi",["string",null],"1","none","none",[]],[4,"personality-symbols",["list",["string",null]],"*",[],"sorted",["value"]],[5,"relocations",["list",["record","RelocationRequirementV1"]],"*",[],"sorted",["capability"]]]],"NativeDataLayoutProjectionV1":[null,[[1,"pointers",["record","PointerLayoutV1"],"1",null,"none",[]],[2,"data-layout",["record","DataLayoutV1"],"1",null,"none",[]]]],"NativeFeatureContractV1":[null,[[1,"cpu-baseline",["string",null],"1","","none",[]],[2,"required",["list",["string",null]],"*",[],"sorted",["value"]],[3,"forbidden",["list",["string",null]],"*",[],"sorted",["value"]],[4,"atomics",["list",["string",null]],"*",[],"sorted",["value"]]]],"NativeHeaderContractProjectionV1":[null,[[1,"type-identity",["string","Identity"],"1",null,"none",[]],[2,"native-type-digest",["bytes","DigestBytes"],"1",null,"none",[]],[3,"include-trees",["list",["record","HeaderTreeProjectionV1"]],"*",[],"ordered",[]],[4,"language",["string","CapabilityId"],"1",null,"none",[]],[5,"preprocessing",["enum","PreprocessingMode"],"1","none","none",[]],[6,"effective-defines",["map",["string",null]],"map",{},"raw-utf8",["key"]]]],"NativeMachineFactsV1":[null,[[1,"features",["record","NativeFeatureContractV1"],"1",null,"none",[]],[2,"code",["record","NativeCodeContractV1"],"1",null,"none",[]]]],"NativeMapV1":[6,[[1,"schema",["uint",null],"1",1,"none",[]],[2,"product-platform",["record","TypedDigestV1"],"1",null,"none",[]],[3,"providers",["list",["record","ProviderOverrideV1"]],"*",[],"sorted",["slot"]],[4,"signer-provenance",["record","SignerProvenanceV1"],"1",null,"none",[]]]],"NativeProviderV1":[null,[[1,"name",["string","Identifier"],"1",null,"none",[]],[2,"provides",["string","ProviderSlot"],"1",null,"none",[]],[3,"when",["record","TargetConstraintV1"],"1",{"arch":"","c-abi":"","code-model":"","cpu-baseline":"","data-model":"","descriptor":{},"environment":"","float-abi":"","forbidden-features":[],"hosted":"","minimum-sdk":{},"object-format":"","os":"","pic":"","relocation":"","required-features":[],"vendor":""},"none",[]],[4,"include-trees",["list",["record","IncludeTreeRefV1"]],"*",[],"ordered",[]],[5,"sources",["list",["record","NativeSourceV1"]],"*",[],"ordered",[]],[6,"defines",["map",["string",null]],"map",{},"raw-utf8",["key"]],[7,"objects",["list",["record","PrebuiltObjectV1"]],"*",[],"ordered",[]],[8,"archives",["list",["record","ArchiveV1"]],"*",[],"ordered",[]],[9,"shared",["list",["record","SharedImportLibraryV1"]],"*",[],"ordered",[]],[10,"requires",["list",["string","ProviderSlot"]],"*",[],"sorted",["value"]],[11,"link",["list",["record","LinkTokenTemplateV1"]],"*",[],"ordered",[]],[12,"abi",["record","ArtifactRefV1"],"1",null,"none",[]]]],"NativeRuntimeRequirementV1":[null,[[1,"slot",["string","ProviderSlot"],"1",null,"none",[]],[2,"contract",["record","TypedDigestV1"],"1",null,"none",[]],[3,"phase",["enum","RuntimePhase"],"1",null,"none",[]],[4,"runtime-identity",["string","RuntimeIdentity"],"0/1","","none",[]]]],"NativeSidecarV1":[15,[[1,"schema",["uint",null],"1",1,"none",[]],[2,"artifact",["record","TypedDigestV1"],"1",null,"none",[]],[3,"platform",["record","EvidencedNativeABIPlatformV1"],"1",null,"none",[]],[4,"sections",["list",["record","EvidencedSectionFactV1"]],"*",[],"sorted",["value.name"]],[5,"symbols",["list",["record","EvidencedSymbolFactV1"]],"*",[],"sorted",["value.name","value.version","value.kind","value.role"]],[6,"relocations",["list",["record","EvidencedRelocationFactV1"]],"*",[],"sorted",["value.section","value.offset","value.relocation","value.symbol"]],[7,"attributes",["record","EvidencedAttributeMapV1"],"1",null,"none",[]],[8,"machine",["record","EvidencedNativeMachineFactsV1"],"1",null,"none",[]],[9,"contract",["record","TypedDigestV1"],"1",null,"none",[]],[10,"runtime-requires",["list",["record","NativeRuntimeRequirementV1"]],"*",[],"sorted",["slot","phase","runtime-identity"]],[11,"provenance",["record","ProvenanceV1"],"1",null,"none",[]]]],"NativeSourceV1":[null,[[1,"name",["string","Identifier"],"1",null,"none",[]],[2,"source",["record","ArtifactRefV1"],"1",null,"none",[]],[3,"language",["string","CapabilityId"],"1",null,"none",[]],[4,"preprocessing",["enum","PreprocessingMode"],"1","none","none",[]],[5,"include-indices",["list",["uint",null]],"*",[],"ordered",[]],[6,"defines",["map",["string",null]],"map",{},"raw-utf8",["key"]]]],"NativeSymbolContractV1":[null,[[1,"name",["string",null],"1",null,"none",[]],[2,"version",["string",null],"1","","none",[]],[3,"kind",["enum","SymbolKind"],"1",null,"none",[]],[4,"role",["enum","SymbolRole"],"1",null,"none",[]],[5,"binding",["enum","Binding"],"1",null,"none",[]],[6,"visibility",["enum","Visibility"],"1",null,"none",[]],[7,"calling-convention",["string",null],"1","","none",[]],[8,"type-contract",["bytes","DigestBytes"],"1",null,"none",[]],[9,"size",["uint",null],"0/1",0,"none",[]]]],"NativeTypeContractProjectionV1":[null,[[1,"platform",["record","NativeABIPlatformV1"],"1",null,"none",[]],[2,"kind",["enum","TypeContractKind"],"1",null,"none",[]],[3,"exposure",["enum","Exposure"],"1",null,"none",[]],[4,"root",["uint",null],"1",1,"none",[]],[5,"type-closure",["list",["record","TypeGraphNodeV1"]],"*",[],"ordered",[]],[6,"size",["uint",null],"0/1",0,"none",[]],[7,"alignment",["uint",null],"0/1",0,"none",[]]]],"NativeTypeContractV1":[null,[[1,"identity",["string","Identity"],"1",null,"none",[]],[2,"kind",["enum","TypeContractKind"],"1",null,"none",[]],[3,"exposure",["enum","Exposure"],"1",null,"none",[]],[4,"layout-signature",["bytes","DigestBytes"],"1",null,"none",[]],[5,"size",["uint",null],"0/1",0,"none",[]],[6,"alignment",["uint",null],"0/1",0,"none",[]],[7,"header-contract",["bytes","DigestBytes"],"0/1","","none",[]]]],"ObjectFormatRulesV1":[null,[[1,"executable",["map",["string",null]],"map",{},"raw-utf8",["key"]],[2,"shared",["map",["string",null]],"map",{},"raw-utf8",["key"]],[3,"page",["map",["uint",null]],"map",{},"raw-utf8",["key"]]]],"ObservationStatusV1":[null,[[1,"exit-status",["uint",null],"1",0,"none",[]],[2,"signal",["uint",null],"1",0,"none",[]]]],"ObservationV1":[13,[[1,"schema",["uint",null],"1",1,"none",[]],[2,"invocation",["string","Identity"],"1",null,"none",[]],[3,"action-key",["bytes","ActionKey"],"0/1","","none",[]],[4,"status",["record","ObservationStatusV1"],"1",null,"none",[]],[5,"stdout",["record","TypedDigestV1"],"1",null,"none",[]],[6,"stderr",["record","TypedDigestV1"],"1",null,"none",[]],[7,"timing-resources",["record","TimingResourcesV1"],"1",null,"none",[]],[8,"runner-metadata",["map",["string",null]],"map",{},"raw-utf8",["key"]]]],"OriginTypeContractProjectionV1":[null,[[1,"language-type-protocol",["record","LanguageTypeProtocolV1"],"1",null,"none",[]],[2,"abi",["record","ExportABIV1"],"1",null,"none",[]],[3,"package",["string","PackageIdentity"],"1",null,"none",[]],[4,"type",["string","Identifier"],"1",null,"none",[]],[5,"root",["uint",null],"1",1,"none",[]],[6,"type-closure",["list",["record","TypeGraphNodeV1"]],"*",[],"ordered",[]]]],"OriginTypeContractRefV1":[null,[[1,"package",["string","PackageIdentity"],"1",null,"none",[]],[2,"type",["string","Identifier"],"1",null,"none",[]],[3,"contract",["bytes","DigestBytes"],"1",null,"none",[]]]],"OutputABIInstallPolicyV1":[null,[[1,"output-abi",["string","CapabilityId"],"1",null,"none",[]],[2,"install-policy",["string","CapabilityId"],"1",null,"none",[]]]],"OutputDeclV1":[null,[[1,"kind",["enum","OutputKind"],"1",null,"none",[]],[2,"path",["string","PathArtifact"],"1",null,"none",[]],[3,"executable",["bool",null],"1",false,"none",[]]]],"PackageABISetV1":[null,[[1,"platform",["record","TypedDigestV1"],"1",null,"none",[]],[2,"object-abi",["string","ProtocolId"],"1",null,"none",[]],[3,"runtime-abi",["string","ProtocolId"],"1",null,"none",[]]]],"PackageConfigV1":[null,[[1,"path",["string","PathPackage"],"1",null,"none",[]],[2,"generated",["list",["string","GeneratedActionRef"]],"*",[],"sorted",["value"]],[3,"native",["list",["string","ProviderSlot"]],"*",[],"sorted",["value"]],[4,"test-data",["list",["record","InputDeclV1"]],"*",[],"sorted",["reference.name"]],[5,"test-env",["map",["string",null]],"map",{},"raw-utf8",["key"]]]],"PackageLinkV1":[19,[[1,"schema",["uint",null],"1",1,"none",[]],[2,"package",["string","PackageIdentity"],"1",null,"none",[]],[3,"abi",["record","PackageABISetV1"],"1",null,"none",[]],[4,"package-object",["record","TypedDigestV1"],"1",null,"none",[]],[5,"foreign-symbols",["list",["record","NativeSymbolContractV1"]],"*",[],"sorted",["name","version","kind","role"]],[6,"provider-contracts",["list",["record","ProviderContractV1"]],"*",[],"sorted",["slot"]],[7,"init",["record","InitDependencyFactV1"],"1",null,"none",[]],[8,"install-link-requirements",["list",["record","NativeRuntimeRequirementV1"]],"*",[],"sorted",["slot","phase","runtime-identity"]]]],"PackageNameV1":[null,[[1,"identity",["string","PackageIdentity"],"1",null,"none",[]],[2,"name",["string","Identifier"],"1",null,"none",[]]]],"PaddingRangeV1":[null,[[1,"offset",["uint",null],"1",null,"none",[]],[2,"size",["uint",null],"1",null,"none",[]]]],"PlatformDescriptorV1":[7,[[1,"schema",["uint",null],"1",1,"none",[]],[2,"name",["string",null],"1",null,"none",[]],[3,"identity",["record","PlatformIdentityV1"],"1",null,"none",[]],[4,"pointers",["record","PointerLayoutV1"],"1",null,"none",[]],[5,"data-layout",["record","DataLayoutV1"],"1",null,"none",[]],[6,"c-abi",["record","CABIDataModelV1"],"1",null,"none",[]],[7,"float-variadic-name",["record","FloatVariadicNameV1"],"1",null,"none",[]],[8,"cpu",["record","CPUCapabilitiesV1"],"1",null,"none",[]],[9,"minimum-platform",["record","PlatformVersionV1"],"0/1",{},"none",[]],[10,"tls-unwind",["record","TLSUnwindCapabilitiesV1"],"1",null,"none",[]],[11,"relocation-code",["record","RelocationCodeCapabilitiesV1"],"1",null,"none",[]],[12,"object-rules",["record","ObjectFormatRulesV1"],"1",null,"none",[]],[13,"hosted-policy",["record","HostedPolicyV1"],"1",null,"none",[]],[14,"abi-protocols",["record","ABIProtocolSetV1"],"1",null,"none",[]]]],"PlatformIdentityV1":[null,[[1,"arch",["string","ArchitectureId"],"1",null,"none",[]],[2,"vendor",["string","VendorId"],"1",null,"none",[]],[3,"os",["string","OperatingSystemId"],"1",null,"none",[]],[4,"environment",["string","EnvironmentId"],"1",null,"none",[]],[5,"object-format",["string","ObjectFormatId"],"1",null,"none",[]]]],"PlatformRolesV1":[null,[[1,"execution-platform",["record","TypedDigestV1"],"1",null,"none",[]],[2,"product-platform",["record","TypedDigestV1"],"1",null,"none",[]],[3,"compiler-output-platform",["record","TypedDigestV1"],"0/1",{},"none",[]],[4,"execution-expanded",["record","PlatformDescriptorV1"],"1",null,"none",[]],[5,"product-expanded",["record","PlatformDescriptorV1"],"1",null,"none",[]],[6,"compiler-output-expanded",["record","PlatformDescriptorV1"],"0/1",{},"none",[]]]],"PlatformVersionV1":[null,[[1,"family",["string","CapabilityId"],"1",null,"none",[]],[2,"major",["uint",null],"1",0,"none",[]],[3,"minor",["uint",null],"1",0,"none",[]],[4,"patch",["uint",null],"1",0,"none",[]],[5,"revision",["uint",null],"1",0,"none",[]]]],"PointerLayoutV1":[null,[[1,"endian",["enum","Endian"],"1",null,"none",[]],[2,"address-spaces",["list",["string",null]],"*",[],"sorted",["value"]],[3,"pointer-widths",["map",["uint",null]],"map",{},"raw-utf8",["key"]]]],"PortableCSettingsV1":[null,[[1,"backend",["string","PortableCBackend"],"1","portable-c99","none",[]],[2,"optimization",["enum","Optimization"],"1","0","none",[]],[3,"output-path",["string","PathArtifact"],"1",null,"none",[]],[4,"support",["list",["record","ArtifactRefV1"]],"*",[],"ordered",[]]]],"PrebuiltObjectV1":[null,[[1,"name",["string","Identifier"],"1",null,"none",[]],[2,"object",["record","ArtifactRefV1"],"1",null,"none",[]],[3,"sidecar",["record","ArtifactRefV1"],"1",null,"none",[]],[4,"contract",["record","ArtifactRefV1"],"1",null,"none",[]]]],"ProductKeyV1":[null,[[1,"identity",["string","Identity"],"1",null,"none",[]],[2,"action-key",["bytes","ActionKey"],"1",null,"none",[]]]],"ProductV1":[null,[[1,"name",["string","Identifier"],"1",null,"none",[]],[2,"kind",["enum","ProductKind"],"1",null,"none",[]],[3,"root",["string",null],"0/1","","none",[]],[4,"linkage",["enum","Linkage"],"1",null,"none",[]],[5,"runtime",["string","ProviderSlot"],"1","hosted","none",[]],[6,"entry",["string",null],"0/1","","none",[]],[7,"native",["list",["string","ProviderSlot"]],"*",[],"sorted",["value"]],[8,"linker-script",["record","ArtifactRefV1"],"0/1",{},"none",[]],[9,"providers",["list",["record","ProviderSelectionV1"]],"*",[],"sorted",["slot"]],[10,"members",["list",["string",null]],"*",[],"ordered",[]],[11,"action",["string",null],"0/1","","none",[]],[12,"install-name",["string","RuntimeIdentity"],"0/1","","none",[]]]],"ProfileV1":[9,[[1,"name",["string","Identifier"],"1",null,"none",[]],[2,"optimization",["enum","Optimization"],"1",null,"none",[]],[3,"debug",["string","DebugMode"],"1",null,"none",[]],[4,"assertions",["bool",null],"1",null,"none",[]],[5,"overflow",["enum","OverflowMode"],"1",null,"none",[]],[6,"panic",["enum","PanicMode"],"1",null,"none",[]],[7,"sanitizers",["list",["string",null]],"*",[],"sorted",["value"]],[8,"lto",["enum","LtoMode"],"1",null,"none",[]],[9,"relocation",["string","RelocationMode"],"1",null,"none",[]],[10,"code-model",["string","CapabilityId"],"1",null,"none",[]],[11,"tls-default",["string","CapabilityId"],"1",null,"none",[]],[12,"strip",["enum","StripMode"],"1",null,"none",[]],[13,"reproducibility",["enum","Reproducibility"],"1",null,"none",[]]]],"ProtocolBundleV1":[null,[[1,"language",["string","ProtocolId"],"1",null,"none",[]],[2,"compiler",["string","ProtocolId"],"1",null,"none",[]],[3,"export",["string","ProtocolId"],"1",null,"none",[]],[4,"object",["string","ProtocolId"],"1",null,"none",[]],[5,"runtime",["string","ProtocolId"],"1",null,"none",[]],[6,"manifest",["uint",null],"1",1,"none",[]],[7,"lock",["uint",null],"1",1,"none",[]]]],"ProvenanceV1":[null,[[1,"producer-tool",["record","TypedDigestV1"],"1",null,"none",[]],[2,"source-build-record",["record","TypedDigestV1"],"1",null,"none",[]],[3,"attestation",["bytes",null],"0/1","","none",[]],[4,"signer-policy",["string",null],"0/1","","none",[]]]],"ProviderContractV1":[null,[[1,"slot",["string","ProviderSlot"],"1",null,"none",[]],[2,"contract",["record","TypedDigestV1"],"1",null,"none",[]]]],"ProviderOverrideV1":[null,[[1,"slot",["string","ProviderSlot"],"1",null,"none",[]],[2,"provider",["string","ProviderId"],"1",null,"none",[]],[3,"product-platform",["record","TargetConstraintV1"],"1",{"arch":"","c-abi":"","code-model":"","cpu-baseline":"","data-model":"","descriptor":{},"environment":"","float-abi":"","forbidden-features":[],"hosted":"","minimum-sdk":{},"object-format":"","os":"","pic":"","relocation":"","required-features":[],"vendor":""},"none",[]],[4,"contract",["record","TypedDigestV1"],"1",null,"none",[]],[5,"artifact-tree",["record","TypedDigestV1"],"1",null,"none",[]],[6,"provenance",["string",null],"0/1","","none",[]]]],"ProviderSelectionV1":[null,[[1,"slot",["string","ProviderSlot"],"1",null,"none",[]],[2,"use",["string","ProviderId"],"1",null,"none",[]]]],"PublicABIProjectionV1":[null,[[1,"abi",["record","ExportABIV1"],"1",null,"none",[]],[2,"package",["record","PackageNameV1"],"1",null,"none",[]],[3,"origin-types",["list",["record","OriginTypeContractRefV1"]],"*",[],"sorted",["package","type"]],[4,"declarations",["list",["record","DeclarationABIRefV1"]],"*",[],"sorted",["kind","name","overload"]],[5,"initialization",["record","PublicInitABIFactsV1"],"1",null,"none",[]]]],"PublicInitABIFactsV1":[null,[[1,"init-symbols",["list",["string",null]],"*",[],"sorted",["value"]],[2,"foreign-providers",["list",["record","ProviderContractV1"]],"*",[],"sorted",["slot"]],[3,"abi-facts",["map",["bytes",null]],"map",{},"raw-utf8",["key"]]]],"PublicTypeDeclarationV1":[null,[[1,"kind",["string","CapabilityId"],"1",null,"none",[]],[2,"name",["string","Identifier"],"1",null,"none",[]],[3,"overload",["string",null],"1","","none",[]],[4,"type-node",["uint",null],"1",null,"none",[]],[5,"constant-bits",["bytes",null],"0/1","","none",[]]]],"PublicTypeNodeV1":[null,[[1,"id",["uint",null],"1",null,"none",[]],[2,"kind",["enum","TypeNodeKind"],"1",null,"none",[]],[3,"identity",["string","TypeIdentityOrEmpty"],"1","","none",[]],[4,"children",["list",["uint",null]],"*",[],"ordered",[]],[5,"semantic",["record","TypeSemanticV1"],"1",null,"none",[]]]],"PublicTypeOriginRefV1":[null,[[1,"package",["string","PackageIdentity"],"1",null,"none",[]],[2,"type",["string","Identifier"],"1",null,"none",[]]]],"PublicTypeProjectionV1":[null,[[1,"language-type-protocol",["record","LanguageTypeProtocolV1"],"1",null,"none",[]],[2,"package",["record","PackageNameV1"],"1",null,"none",[]],[3,"origin-types",["list",["record","PublicTypeOriginRefV1"]],"*",[],"sorted",["package","type"]],[4,"type-graph",["list",["record","PublicTypeNodeV1"]],"*",[],"ordered",[]],[5,"declarations",["list",["record","PublicTypeDeclarationV1"]],"*",[],"sorted",["kind","name","overload"]]]],"RecordedCommandV1":[null,[[1,"tool",["record","TypedDigestV1"],"1",null,"none",[]],[2,"version-output",["bytes",null],"1",null,"none",[]],[3,"argv",["list",["string",null]],"*",[],"ordered",[]],[4,"closure",["list",["record","TypedDigestV1"]],"*",[],"sorted",["domain","record-kind","record-schema","digest"]]]],"RelocationCodeCapabilitiesV1":[null,[[1,"relocations",["list",["string",null]],"*",[],"sorted",["value"]],[2,"default-relocation",["string",null],"1",null,"none",[]],[3,"code-models",["list",["string",null]],"*",[],"sorted",["value"]],[4,"default-code-model",["string",null],"1",null,"none",[]]]],"RelocationFactV1":[null,[[1,"section",["string",null],"1",null,"none",[]],[2,"offset",["uint",null],"1",null,"none",[]],[3,"relocation",["string","CapabilityId"],"1",null,"none",[]],[4,"symbol",["string",null],"1",null,"none",[]],[5,"addend",["record","SignedMagnitudeV1"],"1",null,"none",[]],[6,"target-section",["string",null],"1","","none",[]]]],"RelocationRequirementV1":[null,[[1,"capability",["string","CapabilityId"],"1",null,"none",[]],[2,"requirement",["enum","RelocationRequirement"],"1",null,"none",[]]]],"RequireV1":[null,[[1,"module",["string","ModuleIdentity"],"1",null,"none",[]],[2,"minimum",["string","SemVer"],"1",null,"none",[]],[3,"source-index",["string",null],"0/1","","none",[]]]],"ResolvedArchiveMemberV1":[null,[[1,"name",["string",null],"1",null,"none",[]],[2,"member",["record","TypedDigestV1"],"1",null,"none",[]],[3,"sidecar",["record","InputSlotRefV1"],"1",null,"none",[]]]],"ResolvedArchiveV1":[null,[[1,"name",["string","Identifier"],"1",null,"none",[]],[2,"archive",["record","InputSlotRefV1"],"1",null,"none",[]],[3,"sidecar",["record","InputSlotRefV1"],"1",null,"none",[]],[4,"members",["list",["record","ResolvedArchiveMemberV1"]],"*",[],"ordered",[]],[5,"contract",["record","InputSlotRefV1"],"1",null,"none",[]]]],"ResolvedIncludeTreeRefV1":[null,[[1,"tree",["record","InputSlotRefV1"],"1",null,"none",[]],[2,"class",["enum","IncludeClass"],"1",null,"none",[]],[3,"subdirectory",["string","PathPackage"],"1",".","none",[]]]],"ResolvedInputV1":[null,[[1,"name",["string","Identifier"],"1",null,"none",[]],[2,"edge-kind",["enum","EdgeKind"],"1",null,"none",[]],[3,"logical-name",["string","PathArtifact"],"1",null,"none",[]],[4,"artifact-kind",["enum","ArtifactKind"],"1",null,"none",[]],[5,"mode",["enum","SemanticMode"],"1","data","none",[]],[6,"digest",["record","TypedDigestV1"],"1",null,"none",[]],[7,"origin-package",["string","OptionalPackageIdentity"],"0/1","","none",[]]]],"ResolvedNativeLinkV1":[null,[[1,"providers",["list",["record","ResolvedNativeProviderV1"]],"*",[],"sorted",["provides","name"]],[2,"link-plan",["record","LinkPlanV1"],"0/1",{},"none",[]],[3,"required-provider-slots",["list",["string","ProviderSlot"]],"*",[],"sorted",["value"]]]],"ResolvedNativeProviderV1":[null,[[1,"name",["string","Identifier"],"1",null,"none",[]],[2,"provides",["string","ProviderSlot"],"1",null,"none",[]],[3,"when",["record","TargetConstraintV1"],"1",{"arch":"","c-abi":"","code-model":"","cpu-baseline":"","data-model":"","descriptor":{},"environment":"","float-abi":"","forbidden-features":[],"hosted":"","minimum-sdk":{},"object-format":"","os":"","pic":"","relocation":"","required-features":[],"vendor":""},"none",[]],[4,"include-trees",["list",["record","ResolvedIncludeTreeRefV1"]],"*",[],"ordered",[]],[5,"sources",["list",["record","ResolvedNativeSourceV1"]],"*",[],"ordered",[]],[6,"defines",["map",["string",null]],"map",{},"raw-utf8",["key"]],[7,"objects",["list",["record","ResolvedPrebuiltObjectV1"]],"*",[],"ordered",[]],[8,"archives",["list",["record","ResolvedArchiveV1"]],"*",[],"ordered",[]],[9,"shared",["list",["record","ResolvedSharedImportLibraryV1"]],"*",[],"ordered",[]],[10,"requires",["list",["string","ProviderSlot"]],"*",[],"sorted",["value"]],[11,"link",["list",["record","LinkTokenV1"]],"*",[],"ordered",[]],[12,"abi",["record","InputSlotRefV1"],"1",null,"none",[]]]],"ResolvedNativeSourceV1":[null,[[1,"name",["string","Identifier"],"1",null,"none",[]],[2,"source",["record","InputSlotRefV1"],"1",null,"none",[]],[3,"language",["string","CapabilityId"],"1",null,"none",[]],[4,"preprocessing",["enum","PreprocessingMode"],"1","none","none",[]],[5,"include-indices",["list",["uint",null]],"*",[],"ordered",[]],[6,"defines",["map",["string",null]],"map",{},"raw-utf8",["key"]]]],"ResolvedPrebuiltObjectV1":[null,[[1,"name",["string","Identifier"],"1",null,"none",[]],[2,"object",["record","InputSlotRefV1"],"1",null,"none",[]],[3,"sidecar",["record","InputSlotRefV1"],"1",null,"none",[]],[4,"contract",["record","InputSlotRefV1"],"1",null,"none",[]]]],"ResolvedSharedImportLibraryV1":[null,[[1,"name",["string","Identifier"],"1",null,"none",[]],[2,"kind",["enum","SharedLibraryKind"],"1",null,"none",[]],[3,"link-artifact",["record","InputSlotRefV1"],"1",null,"none",[]],[4,"link-sidecar",["record","InputSlotRefV1"],"1",null,"none",[]],[5,"runtime-identity",["string","RuntimeIdentity"],"1",null,"none",[]],[6,"runtime-artifact",["record","InputSlotRefV1"],"1",null,"none",[]],[7,"runtime-sidecar",["record","InputSlotRefV1"],"1",null,"none",[]],[8,"contract",["record","InputSlotRefV1"],"1",null,"none",[]],[9,"runtime-requires",["list",["record","NativeRuntimeRequirementV1"]],"*",[],"sorted",["slot","phase","runtime-identity"]]]],"ResourcePolicyV1":[null,[[1,"cpu-count",["uint",null],"1",0,"none",[]],[2,"memory-bytes",["uint",null],"1",0,"none",[]],[3,"output-bytes",["uint",null],"1",0,"none",[]],[4,"process-count",["uint",null],"1",0,"none",[]]]],"ResultOutputV1":[null,[[1,"name",["string","PathArtifact"],"1",null,"none",[]],[2,"artifact-kind",["enum","ArtifactKind"],"1",null,"none",[]],[3,"mode",["enum","SemanticMode"],"1",null,"none",[]],[4,"digest",["record","TypedDigestV1"],"1",null,"none",[]]]],"RuntimeClosureEntryV1":[null,[[1,"runtime-identity",["string","RuntimeIdentity"],"1",null,"none",[]],[2,"artifact",["record","TypedDigestV1"],"1",null,"none",[]],[3,"destination",["string","PathInstall"],"1",null,"none",[]]]],"RuntimeProviderSetV1":[null,[[1,"providers",["list",["record","NativeProviderV1"]],"*",[],"sorted",["provides","name"]]]],"RuntimeResolutionPolicyV1":[null,[[1,"policy",["string","CapabilityId"],"1",null,"none",[]],[2,"runtime-search",["list",["string","PathTargetRuntime"]],"*",[],"ordered",[]]]],"SandboxPolicyV1":[null,[[1,"policy",["string","CapabilityId"],"1",null,"none",[]],[2,"version",["uint",null],"1",1,"none",[]],[3,"resources",["record","ResourcePolicyV1"],"1",null,"none",[]],[4,"reproducibility",["enum","Reproducibility"],"1",null,"none",[]]]],"SectionFactV1":[null,[[1,"name",["string",null],"1",null,"none",[]],[2,"format-type",["string","CapabilityId"],"1",null,"none",[]],[3,"flags",["list",["string",null]],"*",[],"sorted",["value"]],[4,"size",["uint",null],"1",null,"none",[]],[5,"alignment",["uint",null],"1",null,"none",[]],[6,"content",["record","TypedDigestV1"],"0/1",{},"none",[]]]],"SelectedClosureRefV1":[null,[[1,"toolchain-id",["string","ModuleIdentity"],"1",null,"none",[]],[2,"closure",["record","TypedDigestV1"],"1",null,"none",[]],[3,"compiler-backend",["record","TypedDigestV1"],"1",null,"none",[]]]],"SelectedSourceV1":[null,[[1,"path",["string","PathSource"],"1",null,"none",[]],[2,"input-slot",["record","InputSlotRefV1"],"1",null,"none",[]],[3,"selection-reason",["string",null],"1",null,"none",[]]]],"SelectedToolClosureV1":[22,[[1,"schema",["uint",null],"1",1,"none",[]],[2,"toolchain-id",["string","ModuleIdentity"],"1",null,"none",[]],[3,"protocols",["record","ProtocolBundleV1"],"1",null,"none",[]],[4,"tools",["list",["record","ToolV1"]],"*",[],"sorted",["name"]],[5,"resources",["list",["record","TypedDigestV1"]],"*",[],"sorted",["domain","record-kind","record-schema","digest"]],[6,"platform-profile-policy",["record","SelectedToolPolicyV1"],"1",null,"none",[]],[7,"runtime-providers",["record","RuntimeProviderSetV1"],"1",{"providers":[]},"none",[]]]],"SelectedToolPolicyV1":[null,[[1,"platform",["record","PlatformDescriptorV1"],"1",null,"none",[]],[2,"profile",["record","ProfileV1"],"1",null,"none",[]],[3,"link-policy",["record","LinkPolicyV1"],"0/1",{},"none",[]]]],"SharedImportLibraryV1":[null,[[1,"name",["string","Identifier"],"1",null,"none",[]],[2,"kind",["enum","SharedLibraryKind"],"1",null,"none",[]],[3,"link-artifact",["record","ArtifactRefV1"],"1",null,"none",[]],[4,"link-sidecar",["record","ArtifactRefV1"],"1",null,"none",[]],[5,"runtime-identity",["string","RuntimeIdentity"],"1",null,"none",[]],[6,"runtime-artifact",["record","ArtifactRefV1"],"1",null,"none",[]],[7,"runtime-sidecar",["record","ArtifactRefV1"],"1",null,"none",[]],[8,"contract",["record","ArtifactRefV1"],"1",null,"none",[]],[9,"runtime-requires",["list",["record","NativeRuntimeRequirementV1"]],"*",[],"sorted",["slot","phase","runtime-identity"]]]],"SignedMagnitudeV1":[null,[[1,"negative",["bool",null],"1",false,"none",[]],[2,"magnitude",["uint",null],"1",0,"none",[]]]],"SignerProvenanceV1":[null,[[1,"signer",["string",null],"1",null,"none",[]],[2,"signature",["bytes",null],"1",null,"none",[]],[3,"provenance",["string",null],"0/1","","none",[]]]],"SourceSelectionV1":[null,[[1,"members",["list",["record","SelectedSourceV1"]],"*",[],"sorted",["path"]],[2,"target-tags",["list",["string",null]],"*",[],"sorted",["value"]]]],"SourceTreeEntryProjectionV1":[null,[[1,"path",["string","PathSource"],"1",null,"none",[]],[2,"type",["enum","SourceEntryType"],"1",null,"none",[]],[3,"executable",["bool",null],"1",false,"none",[]],[4,"file-sha256",["bytes",null],"0/1","","none",[]]]],"SourceTreeProjectionV1":[null,[[1,"entries",["list",["record","SourceTreeEntryProjectionV1"]],"*",[],"sorted",["path"]]]],"SymbolFactV1":[null,[[1,"name",["string",null],"1",null,"none",[]],[2,"version",["string",null],"1","","none",[]],[3,"kind",["enum","SymbolKind"],"1",null,"none",[]],[4,"role",["enum","SymbolRole"],"1",null,"none",[]],[5,"binding",["enum","Binding"],"1",null,"none",[]],[6,"visibility",["enum","Visibility"],"1",null,"none",[]],[7,"calling-convention",["string",null],"1","","none",[]],[8,"type-contract",["bytes","DigestBytes"],"1",null,"none",[]],[9,"size",["uint",null],"0/1",0,"none",[]],[10,"section",["string",null],"1","","none",[]],[11,"value",["uint",null],"1",0,"none",[]]]],"TLSUnwindCapabilitiesV1":[null,[[1,"tls-models",["list",["string",null]],"*",[],"sorted",["value"]],[2,"default-tls",["string",null],"1",null,"none",[]],[3,"unwind-models",["list",["string",null]],"*",[],"sorted",["value"]],[4,"default-unwind",["string",null],"1",null,"none",[]]]],"TagNicheLayoutV1":[null,[[1,"tag-offset",["uint",null],"1",null,"none",[]],[2,"tag-size",["uint",null],"1",null,"none",[]],[3,"variants",["list",["record","TypeVariantEncodingV1"]],"*",[],"sorted",["variant"]]]],"TargetConstraintV1":[null,[[1,"descriptor",["record","TypedDigestV1"],"0/1",{},"none",[]],[2,"arch",["string","ArchitectureId"],"0/1","","none",[]],[3,"vendor",["string","VendorId"],"0/1","","none",[]],[4,"os",["string","OperatingSystemId"],"0/1","","none",[]],[5,"environment",["string","EnvironmentId"],"0/1","","none",[]],[6,"object-format",["string","ObjectFormatId"],"0/1","","none",[]],[7,"hosted",["string","OptionalBooleanText"],"0/1","","none",[]],[8,"c-abi",["string",null],"0/1","","none",[]],[9,"data-model",["string",null],"0/1","","none",[]],[10,"float-abi",["string",null],"0/1","","none",[]],[11,"cpu-baseline",["string",null],"0/1","","none",[]],[12,"required-features",["list",["string",null]],"*",[],"sorted",["value"]],[13,"forbidden-features",["list",["string",null]],"*",[],"sorted",["value"]],[14,"minimum-sdk",["record","PlatformVersionV1"],"0/1",{},"none",[]],[15,"relocation",["string","OptionalRelocationMode"],"0/1","","none",[]],[16,"code-model",["string",null],"0/1","","none",[]],[17,"pic",["string","OptionalPicPolicyText"],"0/1","","none",[]]]],"TargetToolchainProvenanceV1":[null,[[1,"target",["record","TypedDigestV1"],"1",null,"none",[]],[2,"toolchain",["record","TypedDigestV1"],"1",null,"none",[]],[3,"protocols",["record","ProtocolBundleV1"],"1",null,"none",[]]]],"TemplateInputV1":[null,[[1,"name",["string","Identifier"],"1",null,"none",[]],[2,"edge-kind",["enum","EdgeKind"],"1",null,"none",[]],[3,"reference",["record","ArtifactRefV1"],"1",null,"none",[]],[4,"artifact-kind",["enum","ArtifactKind"],"1",null,"none",[]],[5,"mode",["enum","SemanticMode"],"1","data","none",[]],[6,"origin-package",["string","OptionalPackageIdentity"],"0/1","","none",[]]]],"TemplateNativeLinkV1":[null,[[1,"providers",["list",["record","NativeProviderV1"]],"*",[],"sorted",["provides","name"]],[2,"link-policy",["record","LinkPolicyV1"],"0/1",{},"none",[]],[3,"required-provider-slots",["list",["string","ProviderSlot"]],"*",[],"sorted",["value"]]]],"TimingResourcesV1":[null,[[1,"elapsed-nanoseconds",["uint",null],"1",0,"none",[]],[2,"user-nanoseconds",["uint",null],"1",0,"none",[]],[3,"system-nanoseconds",["uint",null],"1",0,"none",[]],[4,"peak-memory-bytes",["uint",null],"1",0,"none",[]]]],"ToolAdapterV1":[null,[[1,"adapter-id",["string","CapabilityId"],"1",null,"none",[]],[2,"raw-options",["list",["bytes",null]],"*",[],"ordered",[]],[3,"injected-environment",["map",["string",null]],"map",{},"raw-utf8",["key"]]]],"ToolV1":[null,[[1,"name",["string","Identifier"],"1",null,"none",[]],[2,"path",["string","PathBundle"],"1",null,"none",[]],[3,"executable",["record","TypedDigestV1"],"1",null,"none",[]],[4,"dynamic-dependencies",["list",["record","ArtifactRefV1"]],"*",[],"ordered",[]],[5,"resources",["list",["record","TypedDigestV1"]],"*",[],"sorted",["domain","record-kind","record-schema","digest"]],[6,"adapter",["record","ToolAdapterV1"],"1",null,"none",[]]]],"ToolchainLockV1":[null,[[1,"id",["string","ModuleIdentity"],"1",null,"none",[]],[2,"version",["string","SemVer"],"1",null,"none",[]],[3,"descriptor",["record","TypedDigestV1"],"1",null,"none",[]],[4,"bundle",["record","TypedDigestV1"],"1",null,"none",[]],[5,"origin",["string","Url"],"1",null,"none",[]]]],"ToolchainRefV1":[null,[[1,"id",["string","ModuleIdentity"],"1",null,"none",[]],[2,"minimum",["string","SemVer"],"1",null,"none",[]]]],"ToolchainV1":[8,[[1,"schema",["uint",null],"1",1,"none",[]],[2,"id",["string","ModuleIdentity"],"1",null,"none",[]],[3,"version",["string","SemVer"],"1",null,"none",[]],[4,"protocols",["record","ProtocolBundleV1"],"1",null,"none",[]],[5,"tools",["list",["record","ToolV1"]],"*",[],"sorted",["name"]],[6,"platforms",["list",["record","PlatformDescriptorV1"]],"*",[],"sorted",["name"]],[7,"profiles",["list",["record","ProfileV1"]],"*",[],"sorted",["name"]],[8,"link-policies",["list",["record","LinkPolicyV1"]],"*",[],"sorted",["product-platform.domain","product-platform.record-kind","product-platform.record-schema","product-platform.digest","product-kind","linkage","profile-constraint","runtime"]],[9,"runtime-providers",["record","RuntimeProviderSetV1"],"1",{"providers":[]},"none",[]],[10,"bundle",["record","BundleProvenanceV1"],"1",null,"none",[]]]],"TreeEntryV1":[null,[[1,"name",["string","PathTreeSegment"],"1",null,"none",[]],[2,"kind",["enum","TreeEntryKind"],"1",null,"none",[]],[3,"executable",["bool",null],"1",false,"none",[]],[4,"child",["record","TypedDigestV1"],"1",null,"none",[]]]],"TreeV1":[1,[[1,"schema",["uint",null],"1",1,"none",[]],[2,"entries",["list",["record","TreeEntryV1"]],"*",[],"sorted",["name"]]]],"TypeFieldLayoutV1":[null,[[1,"child-id",["uint",null],"1",null,"none",[]],[2,"offset",["uint",null],"1",null,"none",[]],[3,"size",["uint",null],"1",null,"none",[]],[4,"alignment",["uint",null],"1",null,"none",[]],[5,"role",["enum","TypeFieldRole"],"1",null,"none",[]]]],"TypeFieldSemanticV1":[null,[[1,"public-name",["string","Identifier"],"0/1","","none",[]],[2,"visibility",["enum","TypeVisibility"],"1","private","none",[]],[3,"role",["enum","TypeFieldRole"],"1","field","none",[]],[4,"child-id",["uint",null],"1",null,"none",[]]]],"TypeGraphNodeV1":[null,[[1,"id",["uint",null],"1",null,"none",[]],[2,"kind",["enum","TypeNodeKind"],"1",null,"none",[]],[3,"identity",["string","TypeIdentityOrEmpty"],"1","","none",[]],[4,"children",["list",["uint",null]],"*",[],"ordered",[]],[5,"semantic",["record","TypeSemanticV1"],"1",null,"none",[]],[6,"layout",["record","TypeLayoutV1"],"1",null,"none",[]]]],"TypeLayoutV1":[null,[[1,"size",["uint",null],"0/1",0,"none",[]],[2,"alignment",["uint",null],"0/1",0,"none",[]],[3,"fields",["list",["record","TypeFieldLayoutV1"]],"*",[],"ordered",[]],[4,"calling-convention",["string",null],"0/1","","none",[]],[5,"return-passing",["string",null],"0/1","","none",[]],[6,"parameter-passing",["list",["string",null]],"*",[],"ordered",[]],[7,"tag-niche",["record","TagNicheLayoutV1"],"0/1",{},"none",[]],[8,"padding",["list",["record","PaddingRangeV1"]],"*",[],"sorted",["offset"]],[9,"c-data-model",["string",null],"0/1","","none",[]],[10,"aggregate-algorithm",["string",null],"0/1","","none",[]]]],"TypeParameterSemanticV1":[null,[[1,"child-id",["uint",null],"1",null,"none",[]],[2,"variadic",["bool",null],"1",false,"none",[]]]],"TypeSemanticV1":[null,[[1,"array-length",["uint",null],"0/1",0,"none",[]],[2,"fields",["list",["record","TypeFieldSemanticV1"]],"*",[],"ordered",[]],[3,"parameters",["list",["record","TypeParameterSemanticV1"]],"*",[],"ordered",[]],[4,"enum-members",["list",["record","EnumMemberV1"]],"*",[],"sorted",["name"]],[5,"c-variadic",["bool",null],"1",false,"none",[]],[6,"packed",["bool",null],"1",false,"none",[]],[7,"nullable",["bool",null],"1",false,"none",[]],[8,"error-variants",["list",["uint",null]],"*",[],"sorted",["value"]],[9,"repr",["enum","TypeRepr"],"1","ww","none",[]],[10,"opaque-promises",["list",["string","CapabilityId"]],"*",[],"sorted",["value"]]]],"TypeVariantEncodingV1":[null,[[1,"variant",["uint",null],"1",null,"none",[]],[2,"negative",["bool",null],"1",false,"none",[]],[3,"magnitude",["uint",null],"1",0,"none",[]]]],"TypedDigestV1":[null,[[1,"domain",["enum","DigestDomain"],"1",null,"none",[]],[2,"algorithm",["enum","DigestAlgorithm"],"1","sha256","none",[]],[3,"record-kind",["uint",null],"1",0,"none",[]],[4,"record-schema",["uint",null],"1",0,"none",[]],[5,"digest",["bytes",null],"1",null,"none",[]]]],"UseV1":[null,[[1,"module",["string","ModuleIdentity"],"1",null,"none",[]],[2,"path",["string","WorkspaceLocation"],"1",null,"none",[]],[3,"expected",["bytes","SourceTreeDigest"],"0/1","","none",[]]]],"VendorEntryV1":[null,[[1,"module",["string","ModuleIdentity"],"1",null,"none",[]],[2,"version",["string","SemVer"],"1",null,"none",[]],[3,"tree",["bytes","SourceTreeDigest"],"1",null,"none",[]],[4,"path",["string","PathVendor"],"1",null,"none",[]]]],"VendorV1":[5,[[1,"schema",["uint",null],"1",1,"none",[]],[2,"lock",["record","TypedDigestV1"],"1",null,"none",[]],[3,"entries",["list",["record","VendorEntryV1"]],"*",[],"sorted",["module"]]]],"WorkV1":[4,[[1,"schema",["uint",null],"1",1,"none",[]],[2,"uses",["list",["record","UseV1"]],"*",[],"sorted",["module"]],[3,"providers",["list",["record","ProviderOverrideV1"]],"*",[],"sorted",["slot"]]]]},"scalars":{"ActionKey":["bytes",32,null,null,null,null],"ArchitectureId":["string",null,null,null,null,null],"BootstrapCStandard":["string",null,null,["C99"],null,null],"BootstrapCharBit":["uint",null,null,[8],null,null],"BootstrapIntegerContract":["string",null,null,["exact-u8-u32-u64-twos-complement"],null,null],"BuildPlatform":["string",null,null,["build"],null,null],"CapabilityId":["string",null,null,null,null,null],"DebugMode":["string",null,null,["none","line","full"],null,null],"DigestBytes":["bytes",32,null,null,null,null],"EnvironmentId":["string",null,null,null,null,null],"GeneratedActionRef":["string",null,null,null,null,null],"Identifier":["string",null,null,null,null,null],"Identity":["string",null,null,null,null,null],"IdentityOrEmpty":["string",null,null,null,null,null],"ModuleIdentity":["string",null,null,null,null,null],"ObjectFormatId":["string",null,null,null,null,null],"OperatingSystemId":["string",null,null,null,null,null],"OptionalBooleanText":["string",null,null,["","false","true"],null,null],"OptionalPackageIdentity":["string",null,null,null,null,null],"OptionalPicPolicyText":["string",null,null,["","forbidden","required"],null,null],"OptionalProtocolId":["string",null,null,null,null,null],"OptionalRelocationMode":["string",null,null,["","pic","pie","static"],null,null],"PackageIdentity":["string",null,null,null,null,null],"PathArtifact":["string",null,null,null,"artifact-relative",null],"PathBundle":["string",null,null,null,"bundle-relative",null],"PathInstall":["string",null,null,null,"install-destination",null],"PathPackage":["string",null,null,null,"package-relative",null],"PathSandbox":["string",null,null,null,"sandbox-execution",null],"PathSource":["string",null,null,null,"source-relative",null],"PathTargetRuntime":["string",null,null,null,"target-runtime",null],"PathTreeSegment":["string",null,null,null,"tree-segment",null],"PathVendor":["string",null,null,null,"vendor-relative",null],"PortableCBackend":["string",null,null,["portable-c99"],null,null],"ProtocolId":["string",null,null,null,null,true],"ProviderId":["string",null,null,null,null,null],"ProviderSlot":["string",null,null,null,null,true],"RelocationMode":["string",null,null,["pic","pie","static"],null,null],"RuntimeIdentity":["string",null,null,null,null,null],"SemVer":["string",null,null,null,null,null],"SourceTreeDigest":["bytes",32,null,null,null,null],"TypeIdentityOrEmpty":["string",null,null,null,null,null],"Url":["string",null,null,null,null,null],"VendorId":["string",null,null,null,null,null],"WorkspaceLocation":["string",null,null,null,"workspace-location",null]},"schema_digest":"ed6189cac04df61d50225ff5847e951811718a7b39a2939c2cab9aab782be20a","schema_files":{"digests.json":"de722e871e3bb8c5801d94d214b3cbe03d111b3a53957ca95a876f53e11e58cc","records.json":"4b4d18f60de652831e16d4c34b6c291020991ba7e5493a25f9f28b11d14b3cba","wire.json":"fd27eaf17bb8767f685bad4b4f577eb7521771f9ea58eeb4824a78a622664f4f"},"unions":{"LinkTokenTemplateV1":["kind",{"archive":[["kind","artifact"],["kind","artifact"],["artifact"],["provider-slot","value","enabled","validated-path","runtime-path","items"]],"as-needed":[["kind","enabled","items"],["kind","enabled","items"],["items"],["artifact","provider-slot","value","validated-path","runtime-path"]],"def-file":[["kind","artifact"],["kind","artifact"],["artifact"],["provider-slot","value","enabled","validated-path","runtime-path","items"]],"dynamic-loader":[["kind","artifact","runtime-path"],["kind","artifact","runtime-path"],["artifact","runtime-path"],["provider-slot","value","enabled","validated-path","items"]],"entry":[["kind","value"],["kind","value"],["value"],["artifact","provider-slot","enabled","validated-path","runtime-path","items"]],"export-map":[["kind","artifact"],["kind","artifact"],["artifact"],["provider-slot","value","enabled","validated-path","runtime-path","items"]],"group":[["kind","items"],["kind","items"],["items"],["artifact","provider-slot","value","enabled","validated-path","runtime-path"]],"install-name":[["kind","value"],["kind","value"],["value"],["artifact","provider-slot","enabled","validated-path","runtime-path","items"]],"linker-script":[["kind","artifact"],["kind","artifact"],["artifact"],["provider-slot","value","enabled","validated-path","runtime-path","items"]],"object":[["kind","artifact"],["kind","artifact"],["artifact"],["provider-slot","value","enabled","validated-path","runtime-path","items"]],"provider":[["kind","provider-slot"],["kind","provider-slot"],["provider-slot"],["artifact","value","enabled","validated-path","runtime-path","items"]],"retain":[["kind","value"],["kind","value"],["value"],["artifact","provider-slot","enabled","validated-path","runtime-path","items"]],"runtime-search":[["kind","value","validated-path"],["kind","value","validated-path"],["value","validated-path"],["artifact","provider-slot","enabled","runtime-path","items"]],"script-slot":[["kind"],["kind","artifact"],[],["provider-slot","value","enabled","validated-path","runtime-path","items"]],"shared":[["kind","artifact"],["kind","artifact"],["artifact"],["provider-slot","value","enabled","validated-path","runtime-path","items"]],"splice":[["kind","value"],["kind","value"],["value"],["artifact","provider-slot","enabled","validated-path","runtime-path","items"]],"version-script":[["kind","artifact"],["kind","artifact"],["artifact"],["provider-slot","value","enabled","validated-path","runtime-path","items"]],"whole":[["kind","items"],["kind","items"],["items"],["artifact","provider-slot","value","enabled","validated-path","runtime-path"]]}],"LinkTokenV1":["kind",{"archive":[["kind","artifact"],["kind","artifact"],["artifact"],["provider-slot","value","enabled","validated-path","runtime-path","items"]],"as-needed":[["kind","enabled","items"],["kind","enabled","items"],["items"],["artifact","provider-slot","value","validated-path","runtime-path"]],"def-file":[["kind","artifact"],["kind","artifact"],["artifact"],["provider-slot","value","enabled","validated-path","runtime-path","items"]],"dynamic-loader":[["kind","artifact","runtime-path"],["kind","artifact","runtime-path"],["artifact","runtime-path"],["provider-slot","value","enabled","validated-path","items"]],"entry":[["kind","value"],["kind","value"],["value"],["artifact","provider-slot","enabled","validated-path","runtime-path","items"]],"export-map":[["kind","artifact"],["kind","artifact"],["artifact"],["provider-slot","value","enabled","validated-path","runtime-path","items"]],"group":[["kind","items"],["kind","items"],["items"],["artifact","provider-slot","value","enabled","validated-path","runtime-path"]],"install-name":[["kind","value"],["kind","value"],["value"],["artifact","provider-slot","enabled","validated-path","runtime-path","items"]],"linker-script":[["kind","artifact"],["kind","artifact"],["artifact"],["provider-slot","value","enabled","validated-path","runtime-path","items"]],"object":[["kind","artifact"],["kind","artifact"],["artifact"],["provider-slot","value","enabled","validated-path","runtime-path","items"]],"retain":[["kind","value"],["kind","value"],["value"],["artifact","provider-slot","enabled","validated-path","runtime-path","items"]],"runtime-search":[["kind","value","validated-path"],["kind","value","validated-path"],["value","validated-path"],["artifact","provider-slot","enabled","runtime-path","items"]],"shared":[["kind","artifact"],["kind","artifact"],["artifact"],["provider-slot","value","enabled","validated-path","runtime-path","items"]],"version-script":[["kind","artifact"],["kind","artifact"],["artifact"],["provider-slot","value","enabled","validated-path","runtime-path","items"]],"whole":[["kind","items"],["kind","items"],["items"],["artifact","provider-slot","value","enabled","validated-path","runtime-path"]]}],"TypedDigestV1":["domain",{"blob":[["domain","algorithm","record-kind","record-schema","digest"],["domain","algorithm","record-kind","record-schema","digest"],["digest"],[]],"record":[["domain","algorithm","record-kind","record-schema","digest"],["domain","algorithm","record-kind","record-schema","digest"],["record-kind","record-schema","digest"],[]]}]},"version":1,"wire":{"limits":[16777215,64,2147483647,"18446744073709551615","18446744073709551615"],"magic":"57574152","schema":1,"types":[[1,"bytes"],[2,"string"],[3,"uint"],[4,"bool"],[5,"list"],[6,"map"],[7,"record"]],"unicode":["16.0.0","NFC",true,true]},"wrappers":{".wwe":["5757455800000001","ExportV1"],".wwinstall":["","InstallManifestV1"],".wwlm":["","PackageLinkV1"],"bootstrap.plan":["","BootstrapPlanV1"]}} diff --git a/protocol/schema/digests.json b/protocol/schema/digests.json new file mode 100644 index 00000000..df42b7bd --- /dev/null +++ b/protocol/schema/digests.json @@ -0,0 +1,253 @@ +{ + "format": "wwar-v1-digest-schema", + "version": 1, + "domains": [ + { + "name": "action-key", + "algorithm": "sha256", + "separator_utf8_hex": "57572d414354494f4e2d4b455900", + "input": { + "record": "ActionRecordV1", + "encoding": "WWAR" + }, + "formula": [ + "separator", + "u64be(encoded-length)", + "encoded-bytes" + ], + "result": { + "kind": "bytes", + "scalar": "ActionKey" + } + }, + { + "name": "blob", + "algorithm": "sha256", + "separator_utf8_hex": "57572d424c4f4200", + "input": { + "kind": "bytes" + }, + "formula": [ + "separator", + "u64be(input-length)", + "input-bytes" + ], + "result": { + "record": "TypedDigestV1", + "domain": "blob", + "record-kind": 0, + "record-schema": 0 + } + }, + { + "name": "calling-conventions", + "algorithm": "sha256", + "separator_utf8_hex": "57572d43414c4c494e472d434f4e56454e54494f4e532d563100", + "input": { + "record": "CallingConventionTableProjectionV1", + "encoding": "WWAR" + }, + "formula": [ + "separator", + "u64be(encoded-length)", + "encoded-bytes" + ], + "result": { + "kind": "bytes", + "length": 32 + } + }, + { + "name": "export-declaration-abi", + "algorithm": "sha256", + "separator_utf8_hex": "57572d4558504f52542d4445434c2d4142492d563100", + "input": { + "record": "ExportDeclarationABIProjectionV1", + "encoding": "WWAR" + }, + "formula": [ + "separator", + "u64be(encoded-length)", + "encoded-bytes" + ], + "result": { + "kind": "bytes", + "length": 32 + } + }, + { + "name": "native-data-layout", + "algorithm": "sha256", + "separator_utf8_hex": "57572d4e41544956452d444154412d4c41594f55542d563100", + "input": { + "record": "NativeDataLayoutProjectionV1", + "encoding": "WWAR" + }, + "formula": [ + "separator", + "u64be(encoded-length)", + "encoded-bytes" + ], + "result": { + "kind": "bytes", + "length": 32 + } + }, + { + "name": "native-header-contract", + "algorithm": "sha256", + "separator_utf8_hex": "57572d4e41544956452d4845414445522d434f4e54524143542d563100", + "input": { + "record": "NativeHeaderContractProjectionV1", + "encoding": "WWAR" + }, + "formula": [ + "separator", + "u64be(encoded-length)", + "encoded-bytes" + ], + "result": { + "kind": "bytes", + "length": 32 + } + }, + { + "name": "native-type-contract", + "algorithm": "sha256", + "separator_utf8_hex": "57572d4e41544956452d545950452d434f4e54524143542d563100", + "input": { + "record": "NativeTypeContractProjectionV1", + "encoding": "WWAR" + }, + "formula": [ + "separator", + "u64be(encoded-length)", + "encoded-bytes" + ], + "result": { + "kind": "bytes", + "length": 32 + } + }, + { + "name": "origin-type-contract", + "algorithm": "sha256", + "separator_utf8_hex": "57572d4f524947494e2d545950452d434f4e54524143542d563100", + "input": { + "record": "OriginTypeContractProjectionV1", + "encoding": "WWAR" + }, + "formula": [ + "separator", + "u64be(encoded-length)", + "encoded-bytes" + ], + "result": { + "kind": "bytes", + "length": 32 + } + }, + { + "name": "public-abi", + "algorithm": "sha256", + "separator_utf8_hex": "57572d5055424c49432d4142492d563100", + "input": { + "record": "PublicABIProjectionV1", + "encoding": "WWAR" + }, + "formula": [ + "separator", + "u64be(encoded-length)", + "encoded-bytes" + ], + "result": { + "kind": "bytes", + "length": 32 + } + }, + { + "name": "public-type", + "algorithm": "sha256", + "separator_utf8_hex": "57572d5055424c49432d545950452d563100", + "input": { + "record": "PublicTypeProjectionV1", + "encoding": "WWAR" + }, + "formula": [ + "separator", + "u64be(encoded-length)", + "encoded-bytes" + ], + "result": { + "kind": "bytes", + "length": 32 + } + }, + { + "name": "record", + "algorithm": "sha256", + "separator_utf8_hex": "57572d5245434f524400", + "input": { + "record": "top-level record", + "encoding": "WWAR" + }, + "formula": [ + "separator", + "u32be(record-kind)", + "u32be(record-schema)", + "u64be(encoded-length)", + "encoded-bytes" + ], + "result": { + "record": "TypedDigestV1", + "domain": "record", + "record-kind": "1..22", + "record-schema": 1 + } + }, + { + "name": "source-tree", + "algorithm": "sha256", + "separator_utf8_hex": "77772d736f757263652d747265652d763100", + "input": { + "record": "SourceTreeProjectionV1", + "encoding": "special-source-tree-v1" + }, + "entry_encoding": { + "path": [ + "u64be-byte-length", + "raw-nfc-utf8" + ], + "type": { + "dir": 1, + "file": 2 + }, + "executable": { + "false": 0, + "true": 1, + "directory": 0 + }, + "content": { + "dir": [ + "u64be", + 0 + ], + "file": [ + "u64be", + 32, + "raw-sha256" + ] + }, + "order": "raw-utf8-path-bytes" + }, + "formula": [ + "separator", + "concatenate entry path,type,executable,content frames" + ], + "result": { + "kind": "bytes", + "scalar": "SourceTreeDigest" + } + } + ] +} diff --git a/protocol/schema/records.json b/protocol/schema/records.json new file mode 100644 index 00000000..48534b15 --- /dev/null +++ b/protocol/schema/records.json @@ -0,0 +1,1958 @@ +{ + "format": "wwar-v1-record-schema", + "version": 1, + "scalar_types": [ + {"name":"ActionKey","base":"bytes","length":32}, + {"name":"ArchitectureId","base":"string"}, + {"name":"BootstrapCStandard","base":"string","values":["C99"]}, + {"name":"BootstrapCharBit","base":"uint","values":[8]}, + {"name":"BootstrapIntegerContract","base":"string","values":["exact-u8-u32-u64-twos-complement"]}, + {"name":"BuildPlatform","base":"string","values":["build"]}, + {"name":"CapabilityId","base":"string"}, + {"name":"DebugMode","base":"string","values":["none","line","full"]}, + {"name":"DigestBytes","base":"bytes","length":32}, + {"name":"EnvironmentId","base":"string"}, + {"name":"GeneratedActionRef","base":"string"}, + {"name":"Identifier","base":"string"}, + {"name":"Identity","base":"string"}, + {"name":"IdentityOrEmpty","base":"string"}, + {"name":"ModuleIdentity","base":"string"}, + {"name":"ObjectFormatId","base":"string"}, + {"name":"OperatingSystemId","base":"string"}, + {"name":"OptionalBooleanText","base":"string","values":["","false","true"]}, + {"name":"OptionalPackageIdentity","base":"string"}, + {"name":"OptionalPicPolicyText","base":"string","values":["","forbidden","required"]}, + {"name":"OptionalProtocolId","base":"string"}, + {"name":"OptionalRelocationMode","base":"string","values":["","pic","pie","static"]}, + {"name":"PackageIdentity","base":"string"}, + {"name":"PathArtifact","base":"string","path_class":"artifact-relative"}, + {"name":"PathBundle","base":"string","path_class":"bundle-relative"}, + {"name":"PathInstall","base":"string","path_class":"install-destination"}, + {"name":"PathPackage","base":"string","path_class":"package-relative"}, + {"name":"PathSandbox","base":"string","path_class":"sandbox-execution"}, + {"name":"PathSource","base":"string","path_class":"source-relative"}, + {"name":"PathTargetRuntime","base":"string","path_class":"target-runtime"}, + {"name":"PathTreeSegment","base":"string","path_class":"tree-segment"}, + {"name":"PathVendor","base":"string","path_class":"vendor-relative"}, + {"name":"PortableCBackend","base":"string","values":["portable-c99"]}, + {"name":"ProtocolId","base":"string","nonempty":true}, + {"name":"ProviderId","base":"string"}, + {"name":"ProviderSlot","base":"string","nonempty":true}, + {"name":"RelocationMode","base":"string","values":["pic","pie","static"]}, + {"name":"RuntimeIdentity","base":"string"}, + {"name":"SemVer","base":"string"}, + {"name":"SourceTreeDigest","base":"bytes","length":32}, + {"name":"TypeIdentityOrEmpty","base":"string"}, + {"name":"Url","base":"string"}, + {"name":"VendorId","base":"string"}, + {"name":"WorkspaceLocation","base":"string","path_class":"workspace-location"} + ], + "path_classes": [ + {"name":"artifact-relative","shape":"path","absolute":false,"allow_complete_dot":false,"allow_dotdot_segments":false,"ascii":false}, + {"name":"bundle-relative","shape":"path","absolute":false,"allow_complete_dot":false,"allow_dotdot_segments":false,"ascii":false}, + {"name":"install-destination","shape":"path","absolute":false,"allow_complete_dot":false,"allow_dotdot_segments":false,"ascii":false}, + {"name":"package-relative","shape":"path","absolute":false,"allow_complete_dot":true,"allow_dotdot_segments":false,"ascii":false}, + {"name":"sandbox-execution","shape":"path","absolute":true,"allow_complete_dot":false,"allow_dotdot_segments":false,"ascii":true,"roots":["/data","/in","/out","/tool","/work"]}, + {"name":"source-relative","shape":"path","absolute":false,"allow_complete_dot":false,"allow_dotdot_segments":false,"ascii":false}, + {"name":"target-runtime","shape":"path","absolute":true,"allow_complete_dot":false,"allow_dotdot_segments":false,"ascii":false}, + {"name":"tree-segment","shape":"single-segment","absolute":false,"allow_complete_dot":false,"allow_dotdot_segments":false,"ascii":false}, + {"name":"vendor-relative","shape":"path","absolute":false,"allow_complete_dot":false,"allow_dotdot_segments":false,"ascii":false}, + {"name":"workspace-location","shape":"path","absolute":"either","allow_complete_dot":true,"allow_dotdot_segments":true,"ascii":false} + ], + "enums": [ + {"name":"ActionKind","values":[{"name":"ww.package","value":1},{"name":"ww.init","value":2},{"name":"native.compile","value":3},{"name":"archive","value":4},{"name":"link","value":5},{"name":"generate","value":6},{"name":"doc","value":7},{"name":"bootstrap.compare","value":8}]}, + {"name":"ArtifactKind","values":[{"name":"file","value":1},{"name":"tree","value":2},{"name":"object","value":3},{"name":"archive","value":4},{"name":"shared","value":5},{"name":"import-library","value":6},{"name":"script","value":7},{"name":"crt","value":8},{"name":"loader","value":9},{"name":"native-sidecar","value":10},{"name":"native-abi","value":11},{"name":"export","value":12},{"name":"package-link","value":13},{"name":"action-record","value":14},{"name":"action-result","value":15}]}, + {"name":"ArtifactNamespace","values":[{"name":"source","value":1},{"name":"generated","value":2},{"name":"package","value":3},{"name":"toolchain","value":4},{"name":"sysroot","value":5},{"name":"provider-output","value":6},{"name":"cas","value":7},{"name":"graph","value":8}]}, + {"name":"Binding","values":[{"name":"strong","value":1},{"name":"weak","value":2}]}, + {"name":"BootstrapHostClosureRole","values":[{"name":"preprocessor-compiler","value":1},{"name":"headers","value":2},{"name":"libc","value":3},{"name":"assembler","value":4},{"name":"linker","value":5},{"name":"loader-resources","value":6}]}, + {"name":"BootstrapRawRecordKind","values":[{"name":"action-record","value":11},{"name":"action-result","value":12}]}, + {"name":"DigestAlgorithm","values":[{"name":"sha256","value":1}]}, + {"name":"DigestDomain","values":[{"name":"blob","value":1},{"name":"record","value":2}]}, + {"name":"EdgeKind","values":[{"name":"package-import","value":1},{"name":"generated-input","value":2},{"name":"tool","value":3},{"name":"native-provider","value":4},{"name":"runtime","value":5},{"name":"ordered-link","value":6},{"name":"source-input","value":7},{"name":"bootstrap-record","value":8}]}, + {"name":"Endian","values":[{"name":"little","value":1},{"name":"big","value":2}]}, + {"name":"EvidenceSource","values":[{"name":"inspected","value":1},{"name":"declared","value":2}]}, + {"name":"Exposure","values":[{"name":"opaque","value":1},{"name":"layout","value":2}]}, + {"name":"FinalLinkTokenKind","values":[{"name":"object","value":1},{"name":"archive","value":2},{"name":"shared","value":3},{"name":"group","value":5},{"name":"whole","value":6},{"name":"as-needed","value":7},{"name":"linker-script","value":8},{"name":"version-script","value":9},{"name":"export-map","value":10},{"name":"def-file","value":11},{"name":"runtime-search","value":12},{"name":"install-name","value":13},{"name":"dynamic-loader","value":14},{"name":"entry","value":15},{"name":"retain","value":16}]}, + {"name":"IncludeClass","values":[{"name":"quote","value":1},{"name":"user","value":2},{"name":"system","value":3},{"name":"framework","value":4}]}, + {"name":"InputDeclKind","values":[{"name":"file","value":1},{"name":"tree","value":2},{"name":"artifact","value":3},{"name":"tool","value":4}]}, + {"name":"LinkTokenKind","values":[{"name":"object","value":1},{"name":"archive","value":2},{"name":"shared","value":3},{"name":"provider","value":4},{"name":"group","value":5},{"name":"whole","value":6},{"name":"as-needed","value":7},{"name":"linker-script","value":8},{"name":"version-script","value":9},{"name":"export-map","value":10},{"name":"def-file","value":11},{"name":"runtime-search","value":12},{"name":"install-name","value":13},{"name":"dynamic-loader","value":14},{"name":"entry","value":15},{"name":"retain","value":16},{"name":"splice","value":17},{"name":"script-slot","value":18}]}, + {"name":"Linkage","values":[{"name":"dynamic","value":1},{"name":"pie","value":2},{"name":"static","value":3},{"name":"static-pie","value":4},{"name":"shared","value":5},{"name":"none","value":6}]}, + {"name":"LtoMode","values":[{"name":"none","value":1},{"name":"thin","value":2},{"name":"full","value":3}]}, + {"name":"Optimization","values":[{"name":"0","value":1},{"name":"1","value":2},{"name":"2","value":3},{"name":"3","value":4},{"name":"size","value":5}]}, + {"name":"OutputKind","values":[{"name":"file","value":1},{"name":"tree","value":2}]}, + {"name":"OverflowMode","values":[{"name":"trap","value":1},{"name":"wrap","value":2}]}, + {"name":"PanicMode","values":[{"name":"abort","value":1},{"name":"runtime","value":2}]}, + {"name":"PicPolicy","values":[{"name":"any","value":1},{"name":"required","value":2},{"name":"forbidden","value":3}]}, + {"name":"PreprocessingMode","values":[{"name":"none","value":1},{"name":"c-preprocessor","value":2}]}, + {"name":"ProductKind","values":[{"name":"exe","value":1},{"name":"static","value":2},{"name":"shared","value":3},{"name":"object","value":4},{"name":"generated","value":5}]}, + {"name":"RelocationRequirement","values":[{"name":"required","value":1},{"name":"forbidden","value":2}]}, + {"name":"Reproducibility","values":[{"name":"required","value":1},{"name":"impure","value":2}]}, + {"name":"RuntimePhase","values":[{"name":"link","value":1},{"name":"load","value":2},{"name":"both","value":3}]}, + {"name":"SemanticMode","values":[{"name":"data","value":1},{"name":"executable","value":2}]}, + {"name":"SharedLibraryKind","values":[{"name":"elf-shared","value":1},{"name":"macho-dylib","value":2},{"name":"pe-import","value":3}]}, + {"name":"SourceEntryType","values":[{"name":"dir","value":1},{"name":"file","value":2}]}, + {"name":"StripMode","values":[{"name":"none","value":1},{"name":"debug","value":2},{"name":"all","value":3}]}, + {"name":"SymbolKind","values":[{"name":"function","value":1},{"name":"data","value":2},{"name":"tls","value":3},{"name":"ifunc","value":4}]}, + {"name":"SymbolRole","values":[{"name":"define","value":1},{"name":"require","value":2}]}, + {"name":"TreeEntryKind","values":[{"name":"file","value":1},{"name":"tree","value":2}]}, + {"name":"TypeContractKind","values":[{"name":"opaque","value":1},{"name":"scalar","value":2},{"name":"enum","value":3},{"name":"struct","value":4},{"name":"union","value":5},{"name":"function","value":6}]}, + {"name":"TypeFieldRole","values":[{"name":"field","value":1},{"name":"base","value":2},{"name":"opaque","value":3}]}, + {"name":"TypeNodeKind","values":[{"name":"void","value":1},{"name":"bool","value":2},{"name":"rune","value":3},{"name":"i8","value":4},{"name":"i16","value":5},{"name":"i32","value":6},{"name":"i64","value":7},{"name":"u8","value":8},{"name":"u16","value":9},{"name":"u32","value":10},{"name":"u64","value":11},{"name":"uint","value":12},{"name":"int","value":13},{"name":"uintptr","value":14},{"name":"size","value":15},{"name":"f32","value":16},{"name":"f64","value":17},{"name":"str","value":18},{"name":"ptr","value":19},{"name":"slice","value":20},{"name":"array","value":21},{"name":"struct","value":22},{"name":"function","value":23},{"name":"channel","value":24},{"name":"named","value":25},{"name":"tuple","value":26},{"name":"tagged","value":27},{"name":"error","value":28},{"name":"never","value":29},{"name":"enum","value":30},{"name":"opaque","value":31}]}, + {"name":"TypeRepr","values":[{"name":"ww","value":1},{"name":"c","value":2},{"name":"opaque","value":3}]}, + {"name":"TypeVisibility","values":[{"name":"exported","value":1},{"name":"private","value":2}]}, + {"name":"Visibility","values":[{"name":"default","value":1},{"name":"protected","value":2},{"name":"hidden","value":3}]} + ], + "record_kinds": [ + {"kind":1,"name":"TreeV1","schema":1}, + {"kind":2,"name":"ManifestV1","schema":1}, + {"kind":3,"name":"LockV1","schema":1}, + {"kind":4,"name":"WorkV1","schema":1}, + {"kind":5,"name":"VendorV1","schema":1}, + {"kind":6,"name":"NativeMapV1","schema":1}, + {"kind":7,"name":"PlatformDescriptorV1","schema":1}, + {"kind":8,"name":"ToolchainV1","schema":1}, + {"kind":9,"name":"ProfileV1","schema":1}, + {"kind":10,"name":"ActionTemplateV1","schema":1}, + {"kind":11,"name":"ActionRecordV1","schema":1}, + {"kind":12,"name":"ActionResultV1","schema":1}, + {"kind":13,"name":"ObservationV1","schema":1}, + {"kind":14,"name":"GraphSnapshotV1","schema":1}, + {"kind":15,"name":"NativeSidecarV1","schema":1}, + {"kind":16,"name":"NativeABIContractV1","schema":1}, + {"kind":17,"name":"LinkPlanV1","schema":1}, + {"kind":18,"name":"ExportV1","schema":1}, + {"kind":19,"name":"PackageLinkV1","schema":1}, + {"kind":20,"name":"InstallManifestV1","schema":1}, + {"kind":21,"name":"BootstrapPlanV1","schema":1}, + {"kind":22,"name":"SelectedToolClosureV1","schema":1} + ], + "records": [ + { + "name": "ABIProtocolSetV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"object","type":{"kind":"string","scalar":"ProtocolId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"runtime","type":{"kind":"string","scalar":"ProtocolId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "ActionIdentityV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"logical-identity","type":{"kind":"string","scalar":"Identity"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"cwd","type":{"kind":"string","scalar":"PathSandbox"},"cardinality":"1","encoded_default":"/work","order":"none","order_by":[]} + ] + }, + { + "name": "ActionKindVersionV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"kind","type":{"kind":"enum","name":"ActionKind"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"version","type":{"kind":"uint"},"cardinality":"1","encoded_default":1,"order":"none","order_by":[]} + ] + }, + { + "name": "ActionOutputV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"name","type":{"kind":"string","scalar":"PathArtifact"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"path","type":{"kind":"string","scalar":"PathArtifact"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"artifact-kind","type":{"kind":"enum","name":"ArtifactKind"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":4,"name":"mode","type":{"kind":"enum","name":"SemanticMode"},"cardinality":"1","encoded_default":"data","order":"none","order_by":[]}, + {"tag":5,"name":"canonicalization","type":{"kind":"string","scalar":"CapabilityId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "ActionRecordV1", + "top_level_kind": 11, + "fields": [ + {"tag":1,"name":"schema","type":{"kind":"uint"},"cardinality":"1","encoded_default":1,"order":"none","order_by":[]}, + {"tag":2,"name":"kind-version","type":{"kind":"record","name":"ActionKindVersionV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"protocols","type":{"kind":"record","name":"ProtocolBundleV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":4,"name":"platform-roles","type":{"kind":"record","name":"PlatformRolesV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":5,"name":"selected-tool-closure","type":{"kind":"record","name":"SelectedClosureRefV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":6,"name":"profile","type":{"kind":"record","name":"ProfileV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":7,"name":"identity","type":{"kind":"record","name":"ActionIdentityV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":8,"name":"argv","type":{"kind":"list","item":{"kind":"string"}},"cardinality":"*","encoded_default":[],"order":"ordered","order_by":[]}, + {"tag":9,"name":"environment","type":{"kind":"map","value":{"kind":"string"}},"cardinality":"map","encoded_default":{},"order":"raw-utf8","order_by":["key"]}, + {"tag":10,"name":"inputs","type":{"kind":"list","item":{"kind":"record","name":"ResolvedInputV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["name"]}, + {"tag":11,"name":"source-selection","type":{"kind":"record","name":"SourceSelectionV1"},"cardinality":"1","encoded_default":{"members":[],"target-tags":[]},"order":"none","order_by":[]}, + {"tag":12,"name":"native-link","type":{"kind":"record","name":"ResolvedNativeLinkV1"},"cardinality":"1","encoded_default":{"providers":[],"link-plan":{},"required-provider-slots":[]},"order":"none","order_by":[]}, + {"tag":13,"name":"outputs","type":{"kind":"list","item":{"kind":"record","name":"ActionOutputV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["name"]}, + {"tag":14,"name":"sandbox","type":{"kind":"record","name":"SandboxPolicyV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "ActionResultV1", + "top_level_kind": 12, + "fields": [ + {"tag":1,"name":"schema","type":{"kind":"uint"},"cardinality":"1","encoded_default":1,"order":"none","order_by":[]}, + {"tag":2,"name":"action-key","type":{"kind":"bytes","scalar":"ActionKey"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"action-record","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":4,"name":"outputs","type":{"kind":"list","item":{"kind":"record","name":"ResultOutputV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["name"]} + ] + }, + { + "name": "ActionTemplateV1", + "top_level_kind": 10, + "fields": [ + {"tag":1,"name":"schema","type":{"kind":"uint"},"cardinality":"1","encoded_default":1,"order":"none","order_by":[]}, + {"tag":2,"name":"kind-version","type":{"kind":"record","name":"ActionKindVersionV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"protocols","type":{"kind":"record","name":"ProtocolBundleV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":4,"name":"platform-roles","type":{"kind":"record","name":"PlatformRolesV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":5,"name":"selected-tool-closure","type":{"kind":"record","name":"SelectedClosureRefV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":6,"name":"profile","type":{"kind":"record","name":"ProfileV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":7,"name":"identity","type":{"kind":"record","name":"ActionIdentityV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":8,"name":"argv","type":{"kind":"list","item":{"kind":"string"}},"cardinality":"*","encoded_default":[],"order":"ordered","order_by":[]}, + {"tag":9,"name":"environment","type":{"kind":"map","value":{"kind":"string"}},"cardinality":"map","encoded_default":{},"order":"raw-utf8","order_by":["key"]}, + {"tag":10,"name":"inputs","type":{"kind":"list","item":{"kind":"record","name":"TemplateInputV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["name"]}, + {"tag":11,"name":"source-selection","type":{"kind":"record","name":"SourceSelectionV1"},"cardinality":"1","encoded_default":{"members":[],"target-tags":[]},"order":"none","order_by":[]}, + {"tag":12,"name":"native-link","type":{"kind":"record","name":"TemplateNativeLinkV1"},"cardinality":"1","encoded_default":{"providers":[],"link-policy":{},"required-provider-slots":[]},"order":"none","order_by":[]}, + {"tag":13,"name":"outputs","type":{"kind":"list","item":{"kind":"record","name":"ActionOutputV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["name"]}, + {"tag":14,"name":"sandbox","type":{"kind":"record","name":"SandboxPolicyV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "ArchiveMemberV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"name","type":{"kind":"string"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"member","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"sidecar","type":{"kind":"record","name":"ArtifactRefV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "ArchiveV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"name","type":{"kind":"string","scalar":"Identifier"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"archive","type":{"kind":"record","name":"ArtifactRefV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"sidecar","type":{"kind":"record","name":"ArtifactRefV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":4,"name":"members","type":{"kind":"list","item":{"kind":"record","name":"ArchiveMemberV1"}},"cardinality":"*","encoded_default":[],"order":"ordered","order_by":[]}, + {"tag":5,"name":"contract","type":{"kind":"record","name":"ArtifactRefV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "ArtifactLocatorV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"namespace","type":{"kind":"enum","name":"ArtifactNamespace"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"owner","type":{"kind":"string","scalar":"IdentityOrEmpty"},"cardinality":"1","encoded_default":"","order":"none","order_by":[]}, + {"tag":3,"name":"name","type":{"kind":"string","scalar":"PathArtifact"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":4,"name":"artifact-kind","type":{"kind":"enum","name":"ArtifactKind"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "ArtifactRefV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"namespace","type":{"kind":"enum","name":"ArtifactNamespace"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"owner","type":{"kind":"string","scalar":"IdentityOrEmpty"},"cardinality":"1","encoded_default":"","order":"none","order_by":[]}, + {"tag":3,"name":"name","type":{"kind":"string","scalar":"PathArtifact"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":4,"name":"artifact-kind","type":{"kind":"enum","name":"ArtifactKind"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":5,"name":"expected","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"0/1","encoded_default":{},"order":"none","order_by":[]}, + {"tag":6,"name":"mode","type":{"kind":"enum","name":"SemanticMode"},"cardinality":"1","encoded_default":"data","order":"none","order_by":[]} + ] + }, + { + "name": "BootstrapHostClosureEntryV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"role","type":{"kind":"enum","name":"BootstrapHostClosureRole"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"digest","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "BootstrapHostClosureV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"command","type":{"kind":"record","name":"RecordedCommandV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"entries","type":{"kind":"list","item":{"kind":"record","name":"BootstrapHostClosureEntryV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["role"]} + ] + }, + { + "name": "BootstrapHostContractV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"c-standard","type":{"kind":"string","scalar":"BootstrapCStandard"},"cardinality":"1","encoded_default":"C99","order":"none","order_by":[]}, + {"tag":2,"name":"char-bit","type":{"kind":"uint","scalar":"BootstrapCharBit"},"cardinality":"1","encoded_default":8,"order":"none","order_by":[]}, + {"tag":3,"name":"integer-contract","type":{"kind":"string","scalar":"BootstrapIntegerContract"},"cardinality":"1","encoded_default":"exact-u8-u32-u64-twos-complement","order":"none","order_by":[]}, + {"tag":4,"name":"address-bits-min","type":{"kind":"uint"},"cardinality":"1","encoded_default":32,"order":"none","order_by":[]}, + {"tag":5,"name":"required-headers","type":{"kind":"list","item":{"kind":"string"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["value"]}, + {"tag":6,"name":"implementation-modes","type":{"kind":"list","item":{"kind":"string"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["value"]}, + {"tag":7,"name":"source-size-max","type":{"kind":"uint"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":8,"name":"object-size-max","type":{"kind":"uint"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "BootstrapOutputRoleV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"role","type":{"kind":"string","scalar":"Identifier"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"artifact-kind","type":{"kind":"enum","name":"ArtifactKind"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "BootstrapPlanV1", + "top_level_kind": 21, + "fields": [ + {"tag":1,"name":"schema","type":{"kind":"uint"},"cardinality":"1","encoded_default":1,"order":"none","order_by":[]}, + {"tag":2,"name":"bootstrap-host","type":{"kind":"record","name":"BootstrapHostContractV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"sources","type":{"kind":"list","item":{"kind":"record","name":"ArtifactRefV1"}},"cardinality":"*","encoded_default":[],"order":"ordered","order_by":[]}, + {"tag":4,"name":"portable-c-settings","type":{"kind":"record","name":"PortableCSettingsV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":5,"name":"host-c-closure","type":{"kind":"record","name":"BootstrapHostClosureV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":6,"name":"stage1-outputs","type":{"kind":"list","item":{"kind":"record","name":"ActionOutputV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["name"]}, + {"tag":7,"name":"production-toolchain","type":{"kind":"record","name":"SelectedClosureRefV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":8,"name":"fixed-point-roots","type":{"kind":"list","item":{"kind":"record","name":"ArtifactRefV1"}},"cardinality":"*","encoded_default":[],"order":"ordered","order_by":[]}, + {"tag":9,"name":"semantic-roles","type":{"kind":"list","item":{"kind":"record","name":"BootstrapOutputRoleV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["role"]}, + {"tag":10,"name":"raw-record-roles","type":{"kind":"list","item":{"kind":"record","name":"BootstrapRawRecordRoleV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["role"]} + ] + }, + { + "name": "BootstrapRawRecordRoleV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"role","type":{"kind":"string","scalar":"Identifier"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"record-kind","type":{"kind":"enum","name":"BootstrapRawRecordKind"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "BundleProvenanceV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"tree","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"signature","type":{"kind":"bytes"},"cardinality":"0/1","encoded_default":"","order":"none","order_by":[]}, + {"tag":3,"name":"provenance","type":{"kind":"string"},"cardinality":"0/1","encoded_default":"","order":"none","order_by":[]} + ] + }, + { + "name": "CABIDataModelV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"c-abi","type":{"kind":"string","scalar":"CapabilityId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"data-model","type":{"kind":"string","scalar":"CapabilityId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"calling-conventions","type":{"kind":"map","value":{"kind":"string"}},"cardinality":"map","encoded_default":{},"order":"raw-utf8","order_by":["key"]} + ] + }, + { + "name": "CPUCapabilitiesV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"baseline","type":{"kind":"string","scalar":"CapabilityId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"required","type":{"kind":"list","item":{"kind":"string"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["value"]}, + {"tag":3,"name":"forbidden","type":{"kind":"list","item":{"kind":"string"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["value"]}, + {"tag":4,"name":"atomics","type":{"kind":"list","item":{"kind":"string"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["value"]} + ] + }, + { + "name": "CallingConventionTableProjectionV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"c-abi","type":{"kind":"string","scalar":"CapabilityId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"data-model","type":{"kind":"string","scalar":"CapabilityId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"conventions","type":{"kind":"map","value":{"kind":"string"}},"cardinality":"map","encoded_default":{},"order":"raw-utf8","order_by":["key"]} + ] + }, + { + "name": "DataLayoutV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"integer-widths","type":{"kind":"map","value":{"kind":"uint"}},"cardinality":"map","encoded_default":{},"order":"raw-utf8","order_by":["key"]}, + {"tag":2,"name":"alignments","type":{"kind":"map","value":{"kind":"uint"}},"cardinality":"map","encoded_default":{},"order":"raw-utf8","order_by":["key"]}, + {"tag":3,"name":"aggregate-algorithm","type":{"kind":"string","scalar":"CapabilityId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "DeclarationABIRefV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"kind","type":{"kind":"string","scalar":"CapabilityId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"name","type":{"kind":"string","scalar":"Identifier"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"overload","type":{"kind":"string"},"cardinality":"1","encoded_default":"","order":"none","order_by":[]}, + {"tag":4,"name":"abi-digest","type":{"kind":"bytes","scalar":"DigestBytes"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "EnumMemberV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"name","type":{"kind":"string","scalar":"Identifier"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"negative","type":{"kind":"bool"},"cardinality":"1","encoded_default":false,"order":"none","order_by":[]}, + {"tag":3,"name":"magnitude","type":{"kind":"uint"},"cardinality":"1","encoded_default":0,"order":"none","order_by":[]} + ] + }, + { + "name": "EvidencedAttributeMapV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"evidence","type":{"kind":"enum","name":"EvidenceSource"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"value","type":{"kind":"map","value":{"kind":"string"}},"cardinality":"map","encoded_default":{},"order":"raw-utf8","order_by":["key"]} + ] + }, + { + "name": "EvidencedNativeABIPlatformV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"evidence","type":{"kind":"enum","name":"EvidenceSource"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"value","type":{"kind":"record","name":"NativeABIPlatformV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "EvidencedNativeMachineFactsV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"evidence","type":{"kind":"enum","name":"EvidenceSource"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"value","type":{"kind":"record","name":"NativeMachineFactsV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "EvidencedRelocationFactV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"evidence","type":{"kind":"enum","name":"EvidenceSource"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"value","type":{"kind":"record","name":"RelocationFactV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "EvidencedSectionFactV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"evidence","type":{"kind":"enum","name":"EvidenceSource"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"value","type":{"kind":"record","name":"SectionFactV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "EvidencedSymbolFactV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"evidence","type":{"kind":"enum","name":"EvidenceSource"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"value","type":{"kind":"record","name":"SymbolFactV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "ExportABIV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"product-platform","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"c-abi","type":{"kind":"string","scalar":"CapabilityId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"object-abi","type":{"kind":"string","scalar":"ProtocolId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":4,"name":"runtime-abi","type":{"kind":"string","scalar":"ProtocolId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "ExportDeclarationABIProjectionV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"abi","type":{"kind":"record","name":"ExportABIV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"package","type":{"kind":"record","name":"PackageNameV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"kind","type":{"kind":"string","scalar":"CapabilityId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":4,"name":"name","type":{"kind":"string","scalar":"Identifier"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":5,"name":"overload","type":{"kind":"string"},"cardinality":"1","encoded_default":"","order":"none","order_by":[]}, + {"tag":6,"name":"root","type":{"kind":"uint"},"cardinality":"1","encoded_default":1,"order":"none","order_by":[]}, + {"tag":7,"name":"type-closure","type":{"kind":"list","item":{"kind":"record","name":"TypeGraphNodeV1"}},"cardinality":"*","encoded_default":[],"order":"ordered","order_by":[]}, + {"tag":8,"name":"foreign","type":{"kind":"record","name":"NativeSymbolContractV1"},"cardinality":"0/1","encoded_default":{},"order":"none","order_by":[]} + ] + }, + { + "name": "ExportDeclarationV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"kind","type":{"kind":"string","scalar":"CapabilityId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"name","type":{"kind":"string","scalar":"Identifier"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"overload","type":{"kind":"string"},"cardinality":"1","encoded_default":"","order":"none","order_by":[]}, + {"tag":4,"name":"type-node","type":{"kind":"uint"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":5,"name":"constant-bits","type":{"kind":"bytes"},"cardinality":"0/1","encoded_default":"","order":"none","order_by":[]}, + {"tag":6,"name":"foreign","type":{"kind":"record","name":"NativeSymbolContractV1"},"cardinality":"0/1","encoded_default":{},"order":"none","order_by":[]}, + {"tag":7,"name":"abi-digest","type":{"kind":"bytes","scalar":"DigestBytes"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "ExportOriginTypeV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"package","type":{"kind":"string","scalar":"PackageIdentity"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"type","type":{"kind":"string","scalar":"Identifier"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"contract","type":{"kind":"bytes","scalar":"DigestBytes"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "ExportV1", + "top_level_kind": 18, + "fields": [ + {"tag":1,"name":"schema","type":{"kind":"uint"},"cardinality":"1","encoded_default":1,"order":"none","order_by":[]}, + {"tag":2,"name":"reader-capabilities","type":{"kind":"list","item":{"kind":"string"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["value"]}, + {"tag":3,"name":"language-type-protocol","type":{"kind":"record","name":"LanguageTypeProtocolV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":4,"name":"abi","type":{"kind":"record","name":"ExportABIV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":5,"name":"package","type":{"kind":"record","name":"PackageNameV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":6,"name":"origin-types","type":{"kind":"list","item":{"kind":"record","name":"ExportOriginTypeV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["package","type"]}, + {"tag":7,"name":"type-graph","type":{"kind":"list","item":{"kind":"record","name":"TypeGraphNodeV1"}},"cardinality":"*","encoded_default":[],"order":"ordered","order_by":[]}, + {"tag":8,"name":"declarations","type":{"kind":"list","item":{"kind":"record","name":"ExportDeclarationV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["kind","name","overload"]}, + {"tag":9,"name":"public-init-abi","type":{"kind":"record","name":"PublicInitABIFactsV1"},"cardinality":"1","encoded_default":{"init-symbols":[],"foreign-providers":[],"abi-facts":{}},"order":"none","order_by":[]}, + {"tag":10,"name":"public-type-digest","type":{"kind":"bytes","scalar":"DigestBytes"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":11,"name":"public-abi-digest","type":{"kind":"bytes","scalar":"DigestBytes"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "FloatVariadicNameV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"float-abi","type":{"kind":"string","scalar":"CapabilityId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"variadic-abi","type":{"kind":"string","scalar":"CapabilityId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"name-decoration","type":{"kind":"string","scalar":"CapabilityId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "GenerateDeclV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"name","type":{"kind":"string","scalar":"Identifier"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"tool","type":{"kind":"record","name":"ArtifactRefV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"platform","type":{"kind":"string","scalar":"BuildPlatform"},"cardinality":"1","encoded_default":"build","order":"none","order_by":[]}, + {"tag":4,"name":"when","type":{"kind":"record","name":"TargetConstraintV1"},"cardinality":"0/1","encoded_default":{},"order":"none","order_by":[]}, + {"tag":5,"name":"inputs","type":{"kind":"map","value":{"kind":"record","name":"InputDeclV1"}},"cardinality":"map","encoded_default":{},"order":"raw-utf8","order_by":["key"]}, + {"tag":6,"name":"outputs","type":{"kind":"map","value":{"kind":"record","name":"OutputDeclV1"}},"cardinality":"map","encoded_default":{},"order":"raw-utf8","order_by":["key"]}, + {"tag":7,"name":"argv","type":{"kind":"list","item":{"kind":"string"}},"cardinality":"*","encoded_default":[],"order":"ordered","order_by":[]}, + {"tag":8,"name":"environment","type":{"kind":"map","value":{"kind":"string"}},"cardinality":"map","encoded_default":{},"order":"raw-utf8","order_by":["key"]}, + {"tag":9,"name":"resources","type":{"kind":"record","name":"ResourcePolicyV1"},"cardinality":"1","encoded_default":{"cpu-count":0,"memory-bytes":0,"output-bytes":0,"process-count":0},"order":"none","order_by":[]}, + {"tag":10,"name":"reproducibility","type":{"kind":"enum","name":"Reproducibility"},"cardinality":"1","encoded_default":"required","order":"none","order_by":[]} + ] + }, + { + "name": "GraphEdgeV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"consumer","type":{"kind":"string","scalar":"Identity"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"consumer-slot","type":{"kind":"string","scalar":"Identifier"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"producer","type":{"kind":"string","scalar":"Identity"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":4,"name":"producer-output","type":{"kind":"string","scalar":"PathArtifact"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":5,"name":"edge-kind","type":{"kind":"enum","name":"EdgeKind"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "GraphNodeV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"node","type":{"kind":"string","scalar":"Identity"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"action-template","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"action-key","type":{"kind":"bytes","scalar":"ActionKey"},"cardinality":"0/1","encoded_default":"","order":"none","order_by":[]}, + {"tag":4,"name":"action-record","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"0/1","encoded_default":{},"order":"none","order_by":[]}, + {"tag":5,"name":"action-result","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"0/1","encoded_default":{},"order":"none","order_by":[]} + ] + }, + { + "name": "GraphSnapshotV1", + "top_level_kind": 14, + "fields": [ + {"tag":1,"name":"schema","type":{"kind":"uint"},"cardinality":"1","encoded_default":1,"order":"none","order_by":[]}, + {"tag":2,"name":"root","type":{"kind":"string","scalar":"Identity"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"nodes","type":{"kind":"list","item":{"kind":"record","name":"GraphNodeV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["node"]}, + {"tag":4,"name":"edges","type":{"kind":"list","item":{"kind":"record","name":"GraphEdgeV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["consumer","consumer-slot","producer","producer-output","edge-kind"]} + ] + }, + { + "name": "HeaderTreeProjectionV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"tree","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"class","type":{"kind":"enum","name":"IncludeClass"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"subdirectory","type":{"kind":"string","scalar":"PathPackage"},"cardinality":"1","encoded_default":".","order":"none","order_by":[]} + ] + }, + { + "name": "HostedPolicyV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"hosted","type":{"kind":"bool"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"capabilities","type":{"kind":"list","item":{"kind":"string"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["value"]} + ] + }, + { + "name": "IncludeTreeRefV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"tree","type":{"kind":"record","name":"ArtifactRefV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"class","type":{"kind":"enum","name":"IncludeClass"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"subdirectory","type":{"kind":"string","scalar":"PathPackage"},"cardinality":"1","encoded_default":".","order":"none","order_by":[]} + ] + }, + { + "name": "InitDependencyFactV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"init-symbol","type":{"kind":"string"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"dependencies","type":{"kind":"list","item":{"kind":"string"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["value"]}, + {"tag":3,"name":"retain","type":{"kind":"bool"},"cardinality":"1","encoded_default":true,"order":"none","order_by":[]} + ] + }, + { + "name": "InputDeclV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"kind","type":{"kind":"enum","name":"InputDeclKind"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"reference","type":{"kind":"record","name":"ArtifactLocatorV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"expected","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"0/1","encoded_default":{},"order":"none","order_by":[]}, + {"tag":4,"name":"mode","type":{"kind":"enum","name":"SemanticMode"},"cardinality":"1","encoded_default":"data","order":"none","order_by":[]} + ] + }, + { + "name": "InputSlotRefV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"slot","type":{"kind":"string","scalar":"Identifier"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"artifact-kind","type":{"kind":"enum","name":"ArtifactKind"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "InstallEntryV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"artifact","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"mode","type":{"kind":"enum","name":"SemanticMode"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"destination","type":{"kind":"string","scalar":"PathInstall"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "InstallManifestV1", + "top_level_kind": 20, + "fields": [ + {"tag":1,"name":"schema","type":{"kind":"uint"},"cardinality":"1","encoded_default":1,"order":"none","order_by":[]}, + {"tag":2,"name":"product","type":{"kind":"record","name":"ProductKeyV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"entries","type":{"kind":"list","item":{"kind":"record","name":"InstallEntryV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["destination"]}, + {"tag":4,"name":"runtime-policy","type":{"kind":"record","name":"RuntimeResolutionPolicyV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":5,"name":"runtime-closure","type":{"kind":"list","item":{"kind":"record","name":"RuntimeClosureEntryV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["runtime-identity"]}, + {"tag":6,"name":"provenance","type":{"kind":"record","name":"TargetToolchainProvenanceV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "LanguageTypeProtocolV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"language","type":{"kind":"string","scalar":"ProtocolId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"type-system","type":{"kind":"string","scalar":"ProtocolId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "LinkPlanSelectionV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"product-platform","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"product-kind","type":{"kind":"enum","name":"ProductKind"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"linkage","type":{"kind":"enum","name":"Linkage"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":4,"name":"profile","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":5,"name":"runtime","type":{"kind":"string","scalar":"ProviderSlot"},"cardinality":"1","encoded_default":"hosted","order":"none","order_by":[]} + ] + }, + { + "name": "LinkPlanV1", + "top_level_kind": 17, + "fields": [ + {"tag":1,"name":"schema","type":{"kind":"uint"},"cardinality":"1","encoded_default":1,"order":"none","order_by":[]}, + {"tag":2,"name":"selection","type":{"kind":"record","name":"LinkPlanSelectionV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"tokens","type":{"kind":"list","item":{"kind":"record","name":"LinkTokenV1"}},"cardinality":"*","encoded_default":[],"order":"ordered","order_by":[]}, + {"tag":4,"name":"tools","type":{"kind":"list","item":{"kind":"record","name":"InputSlotRefV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["slot"]}, + {"tag":5,"name":"non-link-policy","type":{"kind":"list","item":{"kind":"record","name":"InputSlotRefV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["slot"]}, + {"tag":6,"name":"output-policy","type":{"kind":"record","name":"OutputABIInstallPolicyV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "LinkPolicyV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"product-platform","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"product-kind","type":{"kind":"enum","name":"ProductKind"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"linkage","type":{"kind":"enum","name":"Linkage"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":4,"name":"profile-constraint","type":{"kind":"list","item":{"kind":"string"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["value"]}, + {"tag":5,"name":"runtime","type":{"kind":"string","scalar":"ProviderSlot"},"cardinality":"1","encoded_default":"hosted","order":"none","order_by":[]}, + {"tag":6,"name":"tokens","type":{"kind":"list","item":{"kind":"record","name":"LinkTokenTemplateV1"}},"cardinality":"*","encoded_default":[],"order":"ordered","order_by":[]}, + {"tag":7,"name":"output-policy","type":{"kind":"record","name":"OutputABIInstallPolicyV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "LinkTokenTemplateV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"kind","type":{"kind":"enum","name":"LinkTokenKind"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"artifact","type":{"kind":"record","name":"ArtifactRefV1"},"cardinality":"0/1","encoded_default":{},"order":"none","order_by":[]}, + {"tag":3,"name":"provider-slot","type":{"kind":"string","scalar":"ProviderSlot"},"cardinality":"0/1","encoded_default":"","order":"none","order_by":[]}, + {"tag":4,"name":"value","type":{"kind":"string"},"cardinality":"0/1","encoded_default":"","order":"none","order_by":[]}, + {"tag":5,"name":"enabled","type":{"kind":"bool"},"cardinality":"1","encoded_default":false,"order":"none","order_by":[]}, + {"tag":6,"name":"validated-path","type":{"kind":"string","scalar":"PathTargetRuntime"},"cardinality":"0/1","encoded_default":"","order":"none","order_by":[]}, + {"tag":7,"name":"runtime-path","type":{"kind":"string","scalar":"PathTargetRuntime"},"cardinality":"0/1","encoded_default":"","order":"none","order_by":[]}, + {"tag":8,"name":"items","type":{"kind":"list","item":{"kind":"record","name":"LinkTokenTemplateV1"}},"cardinality":"*","encoded_default":[],"order":"ordered","order_by":[]} + ] + }, + { + "name": "LinkTokenV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"kind","type":{"kind":"enum","name":"FinalLinkTokenKind"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"artifact","type":{"kind":"record","name":"InputSlotRefV1"},"cardinality":"0/1","encoded_default":{},"order":"none","order_by":[]}, + {"tag":3,"name":"provider-slot","type":{"kind":"string","scalar":"ProviderSlot"},"cardinality":"0/1","encoded_default":"","order":"none","order_by":[]}, + {"tag":4,"name":"value","type":{"kind":"string"},"cardinality":"0/1","encoded_default":"","order":"none","order_by":[]}, + {"tag":5,"name":"enabled","type":{"kind":"bool"},"cardinality":"1","encoded_default":false,"order":"none","order_by":[]}, + {"tag":6,"name":"validated-path","type":{"kind":"string","scalar":"PathTargetRuntime"},"cardinality":"0/1","encoded_default":"","order":"none","order_by":[]}, + {"tag":7,"name":"runtime-path","type":{"kind":"string","scalar":"PathTargetRuntime"},"cardinality":"0/1","encoded_default":"","order":"none","order_by":[]}, + {"tag":8,"name":"items","type":{"kind":"list","item":{"kind":"record","name":"LinkTokenV1"}},"cardinality":"*","encoded_default":[],"order":"ordered","order_by":[]} + ] + }, + { + "name": "LockV1", + "top_level_kind": 3, + "fields": [ + {"tag":1,"name":"schema","type":{"kind":"uint"},"cardinality":"1","encoded_default":1,"order":"none","order_by":[]}, + {"tag":2,"name":"root-manifest","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"toolchain","type":{"kind":"record","name":"ToolchainLockV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":4,"name":"modules","type":{"kind":"list","item":{"kind":"record","name":"ModuleLockV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["module"]}, + {"tag":5,"name":"native-map","type":{"kind":"record","name":"LockedObjectV1"},"cardinality":"0/1","encoded_default":{},"order":"none","order_by":[]} + ] + }, + { + "name": "LockedObjectV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"origin","type":{"kind":"string","scalar":"Url"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"digest","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"signature","type":{"kind":"bytes"},"cardinality":"0/1","encoded_default":"","order":"none","order_by":[]} + ] + }, + { + "name": "ManifestV1", + "top_level_kind": 2, + "fields": [ + {"tag":1,"name":"schema","type":{"kind":"uint"},"cardinality":"1","encoded_default":1,"order":"none","order_by":[]}, + {"tag":2,"name":"module","type":{"kind":"string","scalar":"ModuleIdentity"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"language","type":{"kind":"string","scalar":"ProtocolId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":4,"name":"toolchain","type":{"kind":"record","name":"ToolchainRefV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":5,"name":"requires","type":{"kind":"list","item":{"kind":"record","name":"RequireV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["module"]}, + {"tag":6,"name":"products","type":{"kind":"list","item":{"kind":"record","name":"ProductV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["name"]}, + {"tag":7,"name":"packages","type":{"kind":"list","item":{"kind":"record","name":"PackageConfigV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["path"]}, + {"tag":8,"name":"actions","type":{"kind":"list","item":{"kind":"record","name":"GenerateDeclV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["name"]}, + {"tag":9,"name":"natives","type":{"kind":"list","item":{"kind":"record","name":"NativeProviderV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["name"]} + ] + }, + { + "name": "ModuleLockSignaturePayloadV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"schema","type":{"kind":"uint"},"cardinality":"1","encoded_default":1,"order":"none","order_by":[]}, + {"tag":2,"name":"module","type":{"kind":"string","scalar":"ModuleIdentity"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"version","type":{"kind":"string","scalar":"SemVer"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":4,"name":"tree","type":{"kind":"bytes","scalar":"SourceTreeDigest"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":5,"name":"manifest","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "ModuleLockV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"module","type":{"kind":"string","scalar":"ModuleIdentity"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"version","type":{"kind":"string","scalar":"SemVer"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"origin","type":{"kind":"string","scalar":"Url"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":4,"name":"archive","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":5,"name":"tree","type":{"kind":"bytes","scalar":"SourceTreeDigest"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":6,"name":"manifest","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":7,"name":"signature","type":{"kind":"bytes"},"cardinality":"0/1","encoded_default":"","order":"none","order_by":[]}, + {"tag":8,"name":"provenance","type":{"kind":"string"},"cardinality":"0/1","encoded_default":"","order":"none","order_by":[]} + ] + }, + { + "name": "NativeABIContractV1", + "top_level_kind": 16, + "fields": [ + {"tag":1,"name":"schema","type":{"kind":"uint"},"cardinality":"1","encoded_default":1,"order":"none","order_by":[]}, + {"tag":2,"name":"slot","type":{"kind":"string","scalar":"ProviderSlot"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"platform","type":{"kind":"record","name":"NativeABIPlatformV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":4,"name":"symbols","type":{"kind":"list","item":{"kind":"record","name":"NativeSymbolContractV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["name","version","kind","role"]}, + {"tag":5,"name":"types","type":{"kind":"list","item":{"kind":"record","name":"NativeTypeContractV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["identity"]}, + {"tag":6,"name":"runtime-requires","type":{"kind":"list","item":{"kind":"record","name":"NativeRuntimeRequirementV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["slot","phase","runtime-identity"]}, + {"tag":7,"name":"features","type":{"kind":"record","name":"NativeFeatureContractV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":8,"name":"minimum-platform","type":{"kind":"record","name":"PlatformVersionV1"},"cardinality":"0/1","encoded_default":{},"order":"none","order_by":[]}, + {"tag":9,"name":"code","type":{"kind":"record","name":"NativeCodeContractV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "NativeABIPlatformV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"object-format","type":{"kind":"string","scalar":"CapabilityId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"object-class","type":{"kind":"string","scalar":"CapabilityId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"endian","type":{"kind":"enum","name":"Endian"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":4,"name":"machine-abi","type":{"kind":"string","scalar":"CapabilityId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":5,"name":"c-abi","type":{"kind":"string","scalar":"CapabilityId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":6,"name":"data-model","type":{"kind":"string","scalar":"CapabilityId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":7,"name":"data-layout","type":{"kind":"bytes","scalar":"DigestBytes"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":8,"name":"calling-conventions","type":{"kind":"bytes","scalar":"DigestBytes"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":9,"name":"float-abi","type":{"kind":"string","scalar":"CapabilityId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":10,"name":"variadic-abi","type":{"kind":"string","scalar":"CapabilityId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":11,"name":"symbol-abi","type":{"kind":"string","scalar":"CapabilityId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":12,"name":"object-abi","type":{"kind":"string","scalar":"ProtocolId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":13,"name":"runtime-abi","type":{"kind":"string","scalar":"OptionalProtocolId"},"cardinality":"1","encoded_default":"","order":"none","order_by":[]} + ] + }, + { + "name": "NativeCodeContractV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"pic","type":{"kind":"enum","name":"PicPolicy"},"cardinality":"1","encoded_default":"any","order":"none","order_by":[]}, + {"tag":2,"name":"tls-models","type":{"kind":"list","item":{"kind":"string"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["value"]}, + {"tag":3,"name":"unwind-abi","type":{"kind":"string"},"cardinality":"1","encoded_default":"none","order":"none","order_by":[]}, + {"tag":4,"name":"personality-symbols","type":{"kind":"list","item":{"kind":"string"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["value"]}, + {"tag":5,"name":"relocations","type":{"kind":"list","item":{"kind":"record","name":"RelocationRequirementV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["capability"]} + ] + }, + { + "name": "NativeDataLayoutProjectionV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"pointers","type":{"kind":"record","name":"PointerLayoutV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"data-layout","type":{"kind":"record","name":"DataLayoutV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "NativeFeatureContractV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"cpu-baseline","type":{"kind":"string"},"cardinality":"1","encoded_default":"","order":"none","order_by":[]}, + {"tag":2,"name":"required","type":{"kind":"list","item":{"kind":"string"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["value"]}, + {"tag":3,"name":"forbidden","type":{"kind":"list","item":{"kind":"string"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["value"]}, + {"tag":4,"name":"atomics","type":{"kind":"list","item":{"kind":"string"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["value"]} + ] + }, + { + "name": "NativeHeaderContractProjectionV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"type-identity","type":{"kind":"string","scalar":"Identity"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"native-type-digest","type":{"kind":"bytes","scalar":"DigestBytes"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"include-trees","type":{"kind":"list","item":{"kind":"record","name":"HeaderTreeProjectionV1"}},"cardinality":"*","encoded_default":[],"order":"ordered","order_by":[]}, + {"tag":4,"name":"language","type":{"kind":"string","scalar":"CapabilityId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":5,"name":"preprocessing","type":{"kind":"enum","name":"PreprocessingMode"},"cardinality":"1","encoded_default":"none","order":"none","order_by":[]}, + {"tag":6,"name":"effective-defines","type":{"kind":"map","value":{"kind":"string"}},"cardinality":"map","encoded_default":{},"order":"raw-utf8","order_by":["key"]} + ] + }, + { + "name": "NativeMachineFactsV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"features","type":{"kind":"record","name":"NativeFeatureContractV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"code","type":{"kind":"record","name":"NativeCodeContractV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "NativeMapV1", + "top_level_kind": 6, + "fields": [ + {"tag":1,"name":"schema","type":{"kind":"uint"},"cardinality":"1","encoded_default":1,"order":"none","order_by":[]}, + {"tag":2,"name":"product-platform","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"providers","type":{"kind":"list","item":{"kind":"record","name":"ProviderOverrideV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["slot"]}, + {"tag":4,"name":"signer-provenance","type":{"kind":"record","name":"SignerProvenanceV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "NativeProviderV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"name","type":{"kind":"string","scalar":"Identifier"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"provides","type":{"kind":"string","scalar":"ProviderSlot"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"when","type":{"kind":"record","name":"TargetConstraintV1"},"cardinality":"1","encoded_default":{"descriptor":{},"arch":"","vendor":"","os":"","environment":"","object-format":"","hosted":"","c-abi":"","data-model":"","float-abi":"","cpu-baseline":"","required-features":[],"forbidden-features":[],"minimum-sdk":{},"relocation":"","code-model":"","pic":""},"order":"none","order_by":[]}, + {"tag":4,"name":"include-trees","type":{"kind":"list","item":{"kind":"record","name":"IncludeTreeRefV1"}},"cardinality":"*","encoded_default":[],"order":"ordered","order_by":[]}, + {"tag":5,"name":"sources","type":{"kind":"list","item":{"kind":"record","name":"NativeSourceV1"}},"cardinality":"*","encoded_default":[],"order":"ordered","order_by":[]}, + {"tag":6,"name":"defines","type":{"kind":"map","value":{"kind":"string"}},"cardinality":"map","encoded_default":{},"order":"raw-utf8","order_by":["key"]}, + {"tag":7,"name":"objects","type":{"kind":"list","item":{"kind":"record","name":"PrebuiltObjectV1"}},"cardinality":"*","encoded_default":[],"order":"ordered","order_by":[]}, + {"tag":8,"name":"archives","type":{"kind":"list","item":{"kind":"record","name":"ArchiveV1"}},"cardinality":"*","encoded_default":[],"order":"ordered","order_by":[]}, + {"tag":9,"name":"shared","type":{"kind":"list","item":{"kind":"record","name":"SharedImportLibraryV1"}},"cardinality":"*","encoded_default":[],"order":"ordered","order_by":[]}, + {"tag":10,"name":"requires","type":{"kind":"list","item":{"kind":"string","scalar":"ProviderSlot"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["value"]}, + {"tag":11,"name":"link","type":{"kind":"list","item":{"kind":"record","name":"LinkTokenTemplateV1"}},"cardinality":"*","encoded_default":[],"order":"ordered","order_by":[]}, + {"tag":12,"name":"abi","type":{"kind":"record","name":"ArtifactRefV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "NativeRuntimeRequirementV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"slot","type":{"kind":"string","scalar":"ProviderSlot"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"contract","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"phase","type":{"kind":"enum","name":"RuntimePhase"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":4,"name":"runtime-identity","type":{"kind":"string","scalar":"RuntimeIdentity"},"cardinality":"0/1","encoded_default":"","order":"none","order_by":[]} + ] + }, + { + "name": "NativeSidecarV1", + "top_level_kind": 15, + "fields": [ + {"tag":1,"name":"schema","type":{"kind":"uint"},"cardinality":"1","encoded_default":1,"order":"none","order_by":[]}, + {"tag":2,"name":"artifact","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"platform","type":{"kind":"record","name":"EvidencedNativeABIPlatformV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":4,"name":"sections","type":{"kind":"list","item":{"kind":"record","name":"EvidencedSectionFactV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["value.name"]}, + {"tag":5,"name":"symbols","type":{"kind":"list","item":{"kind":"record","name":"EvidencedSymbolFactV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["value.name","value.version","value.kind","value.role"]}, + {"tag":6,"name":"relocations","type":{"kind":"list","item":{"kind":"record","name":"EvidencedRelocationFactV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["value.section","value.offset","value.relocation","value.symbol"]}, + {"tag":7,"name":"attributes","type":{"kind":"record","name":"EvidencedAttributeMapV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":8,"name":"machine","type":{"kind":"record","name":"EvidencedNativeMachineFactsV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":9,"name":"contract","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":10,"name":"runtime-requires","type":{"kind":"list","item":{"kind":"record","name":"NativeRuntimeRequirementV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["slot","phase","runtime-identity"]}, + {"tag":11,"name":"provenance","type":{"kind":"record","name":"ProvenanceV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "NativeSourceV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"name","type":{"kind":"string","scalar":"Identifier"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"source","type":{"kind":"record","name":"ArtifactRefV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"language","type":{"kind":"string","scalar":"CapabilityId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":4,"name":"preprocessing","type":{"kind":"enum","name":"PreprocessingMode"},"cardinality":"1","encoded_default":"none","order":"none","order_by":[]}, + {"tag":5,"name":"include-indices","type":{"kind":"list","item":{"kind":"uint"}},"cardinality":"*","encoded_default":[],"order":"ordered","order_by":[]}, + {"tag":6,"name":"defines","type":{"kind":"map","value":{"kind":"string"}},"cardinality":"map","encoded_default":{},"order":"raw-utf8","order_by":["key"]} + ] + }, + { + "name": "NativeSymbolContractV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"name","type":{"kind":"string"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"version","type":{"kind":"string"},"cardinality":"1","encoded_default":"","order":"none","order_by":[]}, + {"tag":3,"name":"kind","type":{"kind":"enum","name":"SymbolKind"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":4,"name":"role","type":{"kind":"enum","name":"SymbolRole"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":5,"name":"binding","type":{"kind":"enum","name":"Binding"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":6,"name":"visibility","type":{"kind":"enum","name":"Visibility"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":7,"name":"calling-convention","type":{"kind":"string"},"cardinality":"1","encoded_default":"","order":"none","order_by":[]}, + {"tag":8,"name":"type-contract","type":{"kind":"bytes","scalar":"DigestBytes"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":9,"name":"size","type":{"kind":"uint"},"cardinality":"0/1","encoded_default":0,"order":"none","order_by":[]} + ] + }, + { + "name": "NativeTypeContractProjectionV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"platform","type":{"kind":"record","name":"NativeABIPlatformV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"kind","type":{"kind":"enum","name":"TypeContractKind"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"exposure","type":{"kind":"enum","name":"Exposure"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":4,"name":"root","type":{"kind":"uint"},"cardinality":"1","encoded_default":1,"order":"none","order_by":[]}, + {"tag":5,"name":"type-closure","type":{"kind":"list","item":{"kind":"record","name":"TypeGraphNodeV1"}},"cardinality":"*","encoded_default":[],"order":"ordered","order_by":[]}, + {"tag":6,"name":"size","type":{"kind":"uint"},"cardinality":"0/1","encoded_default":0,"order":"none","order_by":[]}, + {"tag":7,"name":"alignment","type":{"kind":"uint"},"cardinality":"0/1","encoded_default":0,"order":"none","order_by":[]} + ] + }, + { + "name": "NativeTypeContractV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"identity","type":{"kind":"string","scalar":"Identity"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"kind","type":{"kind":"enum","name":"TypeContractKind"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"exposure","type":{"kind":"enum","name":"Exposure"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":4,"name":"layout-signature","type":{"kind":"bytes","scalar":"DigestBytes"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":5,"name":"size","type":{"kind":"uint"},"cardinality":"0/1","encoded_default":0,"order":"none","order_by":[]}, + {"tag":6,"name":"alignment","type":{"kind":"uint"},"cardinality":"0/1","encoded_default":0,"order":"none","order_by":[]}, + {"tag":7,"name":"header-contract","type":{"kind":"bytes","scalar":"DigestBytes"},"cardinality":"0/1","encoded_default":"","order":"none","order_by":[]} + ] + }, + { + "name": "ObjectFormatRulesV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"executable","type":{"kind":"map","value":{"kind":"string"}},"cardinality":"map","encoded_default":{},"order":"raw-utf8","order_by":["key"]}, + {"tag":2,"name":"shared","type":{"kind":"map","value":{"kind":"string"}},"cardinality":"map","encoded_default":{},"order":"raw-utf8","order_by":["key"]}, + {"tag":3,"name":"page","type":{"kind":"map","value":{"kind":"uint"}},"cardinality":"map","encoded_default":{},"order":"raw-utf8","order_by":["key"]} + ] + }, + { + "name": "ObservationStatusV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"exit-status","type":{"kind":"uint"},"cardinality":"1","encoded_default":0,"order":"none","order_by":[]}, + {"tag":2,"name":"signal","type":{"kind":"uint"},"cardinality":"1","encoded_default":0,"order":"none","order_by":[]} + ] + }, + { + "name": "ObservationV1", + "top_level_kind": 13, + "fields": [ + {"tag":1,"name":"schema","type":{"kind":"uint"},"cardinality":"1","encoded_default":1,"order":"none","order_by":[]}, + {"tag":2,"name":"invocation","type":{"kind":"string","scalar":"Identity"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"action-key","type":{"kind":"bytes","scalar":"ActionKey"},"cardinality":"0/1","encoded_default":"","order":"none","order_by":[]}, + {"tag":4,"name":"status","type":{"kind":"record","name":"ObservationStatusV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":5,"name":"stdout","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":6,"name":"stderr","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":7,"name":"timing-resources","type":{"kind":"record","name":"TimingResourcesV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":8,"name":"runner-metadata","type":{"kind":"map","value":{"kind":"string"}},"cardinality":"map","encoded_default":{},"order":"raw-utf8","order_by":["key"]} + ] + }, + { + "name": "OriginTypeContractProjectionV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"language-type-protocol","type":{"kind":"record","name":"LanguageTypeProtocolV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"abi","type":{"kind":"record","name":"ExportABIV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"package","type":{"kind":"string","scalar":"PackageIdentity"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":4,"name":"type","type":{"kind":"string","scalar":"Identifier"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":5,"name":"root","type":{"kind":"uint"},"cardinality":"1","encoded_default":1,"order":"none","order_by":[]}, + {"tag":6,"name":"type-closure","type":{"kind":"list","item":{"kind":"record","name":"TypeGraphNodeV1"}},"cardinality":"*","encoded_default":[],"order":"ordered","order_by":[]} + ] + }, + { + "name": "OriginTypeContractRefV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"package","type":{"kind":"string","scalar":"PackageIdentity"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"type","type":{"kind":"string","scalar":"Identifier"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"contract","type":{"kind":"bytes","scalar":"DigestBytes"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "OutputABIInstallPolicyV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"output-abi","type":{"kind":"string","scalar":"CapabilityId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"install-policy","type":{"kind":"string","scalar":"CapabilityId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "OutputDeclV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"kind","type":{"kind":"enum","name":"OutputKind"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"path","type":{"kind":"string","scalar":"PathArtifact"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"executable","type":{"kind":"bool"},"cardinality":"1","encoded_default":false,"order":"none","order_by":[]} + ] + }, + { + "name": "PackageABISetV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"platform","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"object-abi","type":{"kind":"string","scalar":"ProtocolId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"runtime-abi","type":{"kind":"string","scalar":"ProtocolId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "PackageConfigV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"path","type":{"kind":"string","scalar":"PathPackage"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"generated","type":{"kind":"list","item":{"kind":"string","scalar":"GeneratedActionRef"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["value"]}, + {"tag":3,"name":"native","type":{"kind":"list","item":{"kind":"string","scalar":"ProviderSlot"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["value"]}, + {"tag":4,"name":"test-data","type":{"kind":"list","item":{"kind":"record","name":"InputDeclV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["reference.name"]}, + {"tag":5,"name":"test-env","type":{"kind":"map","value":{"kind":"string"}},"cardinality":"map","encoded_default":{},"order":"raw-utf8","order_by":["key"]} + ] + }, + { + "name": "PackageLinkV1", + "top_level_kind": 19, + "fields": [ + {"tag":1,"name":"schema","type":{"kind":"uint"},"cardinality":"1","encoded_default":1,"order":"none","order_by":[]}, + {"tag":2,"name":"package","type":{"kind":"string","scalar":"PackageIdentity"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"abi","type":{"kind":"record","name":"PackageABISetV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":4,"name":"package-object","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":5,"name":"foreign-symbols","type":{"kind":"list","item":{"kind":"record","name":"NativeSymbolContractV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["name","version","kind","role"]}, + {"tag":6,"name":"provider-contracts","type":{"kind":"list","item":{"kind":"record","name":"ProviderContractV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["slot"]}, + {"tag":7,"name":"init","type":{"kind":"record","name":"InitDependencyFactV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":8,"name":"install-link-requirements","type":{"kind":"list","item":{"kind":"record","name":"NativeRuntimeRequirementV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["slot","phase","runtime-identity"]} + ] + }, + { + "name": "PackageNameV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"identity","type":{"kind":"string","scalar":"PackageIdentity"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"name","type":{"kind":"string","scalar":"Identifier"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "PaddingRangeV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"offset","type":{"kind":"uint"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"size","type":{"kind":"uint"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "PlatformDescriptorV1", + "top_level_kind": 7, + "fields": [ + {"tag":1,"name":"schema","type":{"kind":"uint"},"cardinality":"1","encoded_default":1,"order":"none","order_by":[]}, + {"tag":2,"name":"name","type":{"kind":"string"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"identity","type":{"kind":"record","name":"PlatformIdentityV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":4,"name":"pointers","type":{"kind":"record","name":"PointerLayoutV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":5,"name":"data-layout","type":{"kind":"record","name":"DataLayoutV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":6,"name":"c-abi","type":{"kind":"record","name":"CABIDataModelV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":7,"name":"float-variadic-name","type":{"kind":"record","name":"FloatVariadicNameV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":8,"name":"cpu","type":{"kind":"record","name":"CPUCapabilitiesV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":9,"name":"minimum-platform","type":{"kind":"record","name":"PlatformVersionV1"},"cardinality":"0/1","encoded_default":{},"order":"none","order_by":[]}, + {"tag":10,"name":"tls-unwind","type":{"kind":"record","name":"TLSUnwindCapabilitiesV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":11,"name":"relocation-code","type":{"kind":"record","name":"RelocationCodeCapabilitiesV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":12,"name":"object-rules","type":{"kind":"record","name":"ObjectFormatRulesV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":13,"name":"hosted-policy","type":{"kind":"record","name":"HostedPolicyV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":14,"name":"abi-protocols","type":{"kind":"record","name":"ABIProtocolSetV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "PlatformIdentityV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"arch","type":{"kind":"string","scalar":"ArchitectureId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"vendor","type":{"kind":"string","scalar":"VendorId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"os","type":{"kind":"string","scalar":"OperatingSystemId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":4,"name":"environment","type":{"kind":"string","scalar":"EnvironmentId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":5,"name":"object-format","type":{"kind":"string","scalar":"ObjectFormatId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "PlatformRolesV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"execution-platform","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"product-platform","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"compiler-output-platform","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"0/1","encoded_default":{},"order":"none","order_by":[]}, + {"tag":4,"name":"execution-expanded","type":{"kind":"record","name":"PlatformDescriptorV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":5,"name":"product-expanded","type":{"kind":"record","name":"PlatformDescriptorV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":6,"name":"compiler-output-expanded","type":{"kind":"record","name":"PlatformDescriptorV1"},"cardinality":"0/1","encoded_default":{},"order":"none","order_by":[]} + ] + }, + { + "name": "PlatformVersionV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"family","type":{"kind":"string","scalar":"CapabilityId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"major","type":{"kind":"uint"},"cardinality":"1","encoded_default":0,"order":"none","order_by":[]}, + {"tag":3,"name":"minor","type":{"kind":"uint"},"cardinality":"1","encoded_default":0,"order":"none","order_by":[]}, + {"tag":4,"name":"patch","type":{"kind":"uint"},"cardinality":"1","encoded_default":0,"order":"none","order_by":[]}, + {"tag":5,"name":"revision","type":{"kind":"uint"},"cardinality":"1","encoded_default":0,"order":"none","order_by":[]} + ] + }, + { + "name": "PointerLayoutV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"endian","type":{"kind":"enum","name":"Endian"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"address-spaces","type":{"kind":"list","item":{"kind":"string"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["value"]}, + {"tag":3,"name":"pointer-widths","type":{"kind":"map","value":{"kind":"uint"}},"cardinality":"map","encoded_default":{},"order":"raw-utf8","order_by":["key"]} + ] + }, + { + "name": "PortableCSettingsV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"backend","type":{"kind":"string","scalar":"PortableCBackend"},"cardinality":"1","encoded_default":"portable-c99","order":"none","order_by":[]}, + {"tag":2,"name":"optimization","type":{"kind":"enum","name":"Optimization"},"cardinality":"1","encoded_default":"0","order":"none","order_by":[]}, + {"tag":3,"name":"output-path","type":{"kind":"string","scalar":"PathArtifact"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":4,"name":"support","type":{"kind":"list","item":{"kind":"record","name":"ArtifactRefV1"}},"cardinality":"*","encoded_default":[],"order":"ordered","order_by":[]} + ] + }, + { + "name": "PrebuiltObjectV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"name","type":{"kind":"string","scalar":"Identifier"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"object","type":{"kind":"record","name":"ArtifactRefV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"sidecar","type":{"kind":"record","name":"ArtifactRefV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":4,"name":"contract","type":{"kind":"record","name":"ArtifactRefV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "ProductKeyV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"identity","type":{"kind":"string","scalar":"Identity"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"action-key","type":{"kind":"bytes","scalar":"ActionKey"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "ProductV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"name","type":{"kind":"string","scalar":"Identifier"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"kind","type":{"kind":"enum","name":"ProductKind"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"root","type":{"kind":"string"},"cardinality":"0/1","encoded_default":"","order":"none","order_by":[]}, + {"tag":4,"name":"linkage","type":{"kind":"enum","name":"Linkage"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":5,"name":"runtime","type":{"kind":"string","scalar":"ProviderSlot"},"cardinality":"1","encoded_default":"hosted","order":"none","order_by":[]}, + {"tag":6,"name":"entry","type":{"kind":"string"},"cardinality":"0/1","encoded_default":"","order":"none","order_by":[]}, + {"tag":7,"name":"native","type":{"kind":"list","item":{"kind":"string","scalar":"ProviderSlot"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["value"]}, + {"tag":8,"name":"linker-script","type":{"kind":"record","name":"ArtifactRefV1"},"cardinality":"0/1","encoded_default":{},"order":"none","order_by":[]}, + {"tag":9,"name":"providers","type":{"kind":"list","item":{"kind":"record","name":"ProviderSelectionV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["slot"]}, + {"tag":10,"name":"members","type":{"kind":"list","item":{"kind":"string"}},"cardinality":"*","encoded_default":[],"order":"ordered","order_by":[]}, + {"tag":11,"name":"action","type":{"kind":"string"},"cardinality":"0/1","encoded_default":"","order":"none","order_by":[]}, + {"tag":12,"name":"install-name","type":{"kind":"string","scalar":"RuntimeIdentity"},"cardinality":"0/1","encoded_default":"","order":"none","order_by":[]} + ] + }, + { + "name": "ProfileV1", + "top_level_kind": 9, + "fields": [ + {"tag":1,"name":"name","type":{"kind":"string","scalar":"Identifier"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"optimization","type":{"kind":"enum","name":"Optimization"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"debug","type":{"kind":"string","scalar":"DebugMode"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":4,"name":"assertions","type":{"kind":"bool"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":5,"name":"overflow","type":{"kind":"enum","name":"OverflowMode"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":6,"name":"panic","type":{"kind":"enum","name":"PanicMode"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":7,"name":"sanitizers","type":{"kind":"list","item":{"kind":"string"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["value"]}, + {"tag":8,"name":"lto","type":{"kind":"enum","name":"LtoMode"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":9,"name":"relocation","type":{"kind":"string","scalar":"RelocationMode"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":10,"name":"code-model","type":{"kind":"string","scalar":"CapabilityId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":11,"name":"tls-default","type":{"kind":"string","scalar":"CapabilityId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":12,"name":"strip","type":{"kind":"enum","name":"StripMode"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":13,"name":"reproducibility","type":{"kind":"enum","name":"Reproducibility"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "ProtocolBundleV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"language","type":{"kind":"string","scalar":"ProtocolId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"compiler","type":{"kind":"string","scalar":"ProtocolId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"export","type":{"kind":"string","scalar":"ProtocolId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":4,"name":"object","type":{"kind":"string","scalar":"ProtocolId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":5,"name":"runtime","type":{"kind":"string","scalar":"ProtocolId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":6,"name":"manifest","type":{"kind":"uint"},"cardinality":"1","encoded_default":1,"order":"none","order_by":[]}, + {"tag":7,"name":"lock","type":{"kind":"uint"},"cardinality":"1","encoded_default":1,"order":"none","order_by":[]} + ] + }, + { + "name": "ProvenanceV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"producer-tool","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"source-build-record","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"attestation","type":{"kind":"bytes"},"cardinality":"0/1","encoded_default":"","order":"none","order_by":[]}, + {"tag":4,"name":"signer-policy","type":{"kind":"string"},"cardinality":"0/1","encoded_default":"","order":"none","order_by":[]} + ] + }, + { + "name": "ProviderContractV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"slot","type":{"kind":"string","scalar":"ProviderSlot"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"contract","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "ProviderOverrideV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"slot","type":{"kind":"string","scalar":"ProviderSlot"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"provider","type":{"kind":"string","scalar":"ProviderId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"product-platform","type":{"kind":"record","name":"TargetConstraintV1"},"cardinality":"1","encoded_default":{"descriptor":{},"arch":"","vendor":"","os":"","environment":"","object-format":"","hosted":"","c-abi":"","data-model":"","float-abi":"","cpu-baseline":"","required-features":[],"forbidden-features":[],"minimum-sdk":{},"relocation":"","code-model":"","pic":""},"order":"none","order_by":[]}, + {"tag":4,"name":"contract","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":5,"name":"artifact-tree","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":6,"name":"provenance","type":{"kind":"string"},"cardinality":"0/1","encoded_default":"","order":"none","order_by":[]} + ] + }, + { + "name": "ProviderSelectionV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"slot","type":{"kind":"string","scalar":"ProviderSlot"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"use","type":{"kind":"string","scalar":"ProviderId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "PublicABIProjectionV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"abi","type":{"kind":"record","name":"ExportABIV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"package","type":{"kind":"record","name":"PackageNameV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"origin-types","type":{"kind":"list","item":{"kind":"record","name":"OriginTypeContractRefV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["package","type"]}, + {"tag":4,"name":"declarations","type":{"kind":"list","item":{"kind":"record","name":"DeclarationABIRefV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["kind","name","overload"]}, + {"tag":5,"name":"initialization","type":{"kind":"record","name":"PublicInitABIFactsV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "PublicInitABIFactsV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"init-symbols","type":{"kind":"list","item":{"kind":"string"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["value"]}, + {"tag":2,"name":"foreign-providers","type":{"kind":"list","item":{"kind":"record","name":"ProviderContractV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["slot"]}, + {"tag":3,"name":"abi-facts","type":{"kind":"map","value":{"kind":"bytes"}},"cardinality":"map","encoded_default":{},"order":"raw-utf8","order_by":["key"]} + ] + }, + { + "name": "PublicTypeDeclarationV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"kind","type":{"kind":"string","scalar":"CapabilityId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"name","type":{"kind":"string","scalar":"Identifier"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"overload","type":{"kind":"string"},"cardinality":"1","encoded_default":"","order":"none","order_by":[]}, + {"tag":4,"name":"type-node","type":{"kind":"uint"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":5,"name":"constant-bits","type":{"kind":"bytes"},"cardinality":"0/1","encoded_default":"","order":"none","order_by":[]} + ] + }, + { + "name": "PublicTypeNodeV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"id","type":{"kind":"uint"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"kind","type":{"kind":"enum","name":"TypeNodeKind"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"identity","type":{"kind":"string","scalar":"TypeIdentityOrEmpty"},"cardinality":"1","encoded_default":"","order":"none","order_by":[]}, + {"tag":4,"name":"children","type":{"kind":"list","item":{"kind":"uint"}},"cardinality":"*","encoded_default":[],"order":"ordered","order_by":[]}, + {"tag":5,"name":"semantic","type":{"kind":"record","name":"TypeSemanticV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "PublicTypeOriginRefV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"package","type":{"kind":"string","scalar":"PackageIdentity"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"type","type":{"kind":"string","scalar":"Identifier"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "PublicTypeProjectionV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"language-type-protocol","type":{"kind":"record","name":"LanguageTypeProtocolV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"package","type":{"kind":"record","name":"PackageNameV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"origin-types","type":{"kind":"list","item":{"kind":"record","name":"PublicTypeOriginRefV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["package","type"]}, + {"tag":4,"name":"type-graph","type":{"kind":"list","item":{"kind":"record","name":"PublicTypeNodeV1"}},"cardinality":"*","encoded_default":[],"order":"ordered","order_by":[]}, + {"tag":5,"name":"declarations","type":{"kind":"list","item":{"kind":"record","name":"PublicTypeDeclarationV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["kind","name","overload"]} + ] + }, + { + "name": "RecordedCommandV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"tool","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"version-output","type":{"kind":"bytes"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"argv","type":{"kind":"list","item":{"kind":"string"}},"cardinality":"*","encoded_default":[],"order":"ordered","order_by":[]}, + {"tag":4,"name":"closure","type":{"kind":"list","item":{"kind":"record","name":"TypedDigestV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["domain","record-kind","record-schema","digest"]} + ] + }, + { + "name": "RelocationCodeCapabilitiesV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"relocations","type":{"kind":"list","item":{"kind":"string"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["value"]}, + {"tag":2,"name":"default-relocation","type":{"kind":"string"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"code-models","type":{"kind":"list","item":{"kind":"string"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["value"]}, + {"tag":4,"name":"default-code-model","type":{"kind":"string"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "RelocationFactV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"section","type":{"kind":"string"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"offset","type":{"kind":"uint"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"relocation","type":{"kind":"string","scalar":"CapabilityId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":4,"name":"symbol","type":{"kind":"string"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":5,"name":"addend","type":{"kind":"record","name":"SignedMagnitudeV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":6,"name":"target-section","type":{"kind":"string"},"cardinality":"1","encoded_default":"","order":"none","order_by":[]} + ] + }, + { + "name": "RelocationRequirementV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"capability","type":{"kind":"string","scalar":"CapabilityId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"requirement","type":{"kind":"enum","name":"RelocationRequirement"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "RequireV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"module","type":{"kind":"string","scalar":"ModuleIdentity"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"minimum","type":{"kind":"string","scalar":"SemVer"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"source-index","type":{"kind":"string"},"cardinality":"0/1","encoded_default":"","order":"none","order_by":[]} + ] + }, + { + "name": "ResolvedArchiveMemberV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"name","type":{"kind":"string"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"member","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"sidecar","type":{"kind":"record","name":"InputSlotRefV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "ResolvedArchiveV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"name","type":{"kind":"string","scalar":"Identifier"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"archive","type":{"kind":"record","name":"InputSlotRefV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"sidecar","type":{"kind":"record","name":"InputSlotRefV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":4,"name":"members","type":{"kind":"list","item":{"kind":"record","name":"ResolvedArchiveMemberV1"}},"cardinality":"*","encoded_default":[],"order":"ordered","order_by":[]}, + {"tag":5,"name":"contract","type":{"kind":"record","name":"InputSlotRefV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "ResolvedIncludeTreeRefV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"tree","type":{"kind":"record","name":"InputSlotRefV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"class","type":{"kind":"enum","name":"IncludeClass"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"subdirectory","type":{"kind":"string","scalar":"PathPackage"},"cardinality":"1","encoded_default":".","order":"none","order_by":[]} + ] + }, + { + "name": "ResolvedInputV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"name","type":{"kind":"string","scalar":"Identifier"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"edge-kind","type":{"kind":"enum","name":"EdgeKind"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"logical-name","type":{"kind":"string","scalar":"PathArtifact"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":4,"name":"artifact-kind","type":{"kind":"enum","name":"ArtifactKind"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":5,"name":"mode","type":{"kind":"enum","name":"SemanticMode"},"cardinality":"1","encoded_default":"data","order":"none","order_by":[]}, + {"tag":6,"name":"digest","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":7,"name":"origin-package","type":{"kind":"string","scalar":"OptionalPackageIdentity"},"cardinality":"0/1","encoded_default":"","order":"none","order_by":[]} + ] + }, + { + "name": "ResolvedNativeLinkV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"providers","type":{"kind":"list","item":{"kind":"record","name":"ResolvedNativeProviderV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["provides","name"]}, + {"tag":2,"name":"link-plan","type":{"kind":"record","name":"LinkPlanV1"},"cardinality":"0/1","encoded_default":{},"order":"none","order_by":[]}, + {"tag":3,"name":"required-provider-slots","type":{"kind":"list","item":{"kind":"string","scalar":"ProviderSlot"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["value"]} + ] + }, + { + "name": "ResolvedNativeProviderV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"name","type":{"kind":"string","scalar":"Identifier"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"provides","type":{"kind":"string","scalar":"ProviderSlot"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"when","type":{"kind":"record","name":"TargetConstraintV1"},"cardinality":"1","encoded_default":{"descriptor":{},"arch":"","vendor":"","os":"","environment":"","object-format":"","hosted":"","c-abi":"","data-model":"","float-abi":"","cpu-baseline":"","required-features":[],"forbidden-features":[],"minimum-sdk":{},"relocation":"","code-model":"","pic":""},"order":"none","order_by":[]}, + {"tag":4,"name":"include-trees","type":{"kind":"list","item":{"kind":"record","name":"ResolvedIncludeTreeRefV1"}},"cardinality":"*","encoded_default":[],"order":"ordered","order_by":[]}, + {"tag":5,"name":"sources","type":{"kind":"list","item":{"kind":"record","name":"ResolvedNativeSourceV1"}},"cardinality":"*","encoded_default":[],"order":"ordered","order_by":[]}, + {"tag":6,"name":"defines","type":{"kind":"map","value":{"kind":"string"}},"cardinality":"map","encoded_default":{},"order":"raw-utf8","order_by":["key"]}, + {"tag":7,"name":"objects","type":{"kind":"list","item":{"kind":"record","name":"ResolvedPrebuiltObjectV1"}},"cardinality":"*","encoded_default":[],"order":"ordered","order_by":[]}, + {"tag":8,"name":"archives","type":{"kind":"list","item":{"kind":"record","name":"ResolvedArchiveV1"}},"cardinality":"*","encoded_default":[],"order":"ordered","order_by":[]}, + {"tag":9,"name":"shared","type":{"kind":"list","item":{"kind":"record","name":"ResolvedSharedImportLibraryV1"}},"cardinality":"*","encoded_default":[],"order":"ordered","order_by":[]}, + {"tag":10,"name":"requires","type":{"kind":"list","item":{"kind":"string","scalar":"ProviderSlot"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["value"]}, + {"tag":11,"name":"link","type":{"kind":"list","item":{"kind":"record","name":"LinkTokenV1"}},"cardinality":"*","encoded_default":[],"order":"ordered","order_by":[]}, + {"tag":12,"name":"abi","type":{"kind":"record","name":"InputSlotRefV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "ResolvedNativeSourceV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"name","type":{"kind":"string","scalar":"Identifier"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"source","type":{"kind":"record","name":"InputSlotRefV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"language","type":{"kind":"string","scalar":"CapabilityId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":4,"name":"preprocessing","type":{"kind":"enum","name":"PreprocessingMode"},"cardinality":"1","encoded_default":"none","order":"none","order_by":[]}, + {"tag":5,"name":"include-indices","type":{"kind":"list","item":{"kind":"uint"}},"cardinality":"*","encoded_default":[],"order":"ordered","order_by":[]}, + {"tag":6,"name":"defines","type":{"kind":"map","value":{"kind":"string"}},"cardinality":"map","encoded_default":{},"order":"raw-utf8","order_by":["key"]} + ] + }, + { + "name": "ResolvedPrebuiltObjectV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"name","type":{"kind":"string","scalar":"Identifier"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"object","type":{"kind":"record","name":"InputSlotRefV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"sidecar","type":{"kind":"record","name":"InputSlotRefV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":4,"name":"contract","type":{"kind":"record","name":"InputSlotRefV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "ResolvedSharedImportLibraryV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"name","type":{"kind":"string","scalar":"Identifier"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"kind","type":{"kind":"enum","name":"SharedLibraryKind"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"link-artifact","type":{"kind":"record","name":"InputSlotRefV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":4,"name":"link-sidecar","type":{"kind":"record","name":"InputSlotRefV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":5,"name":"runtime-identity","type":{"kind":"string","scalar":"RuntimeIdentity"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":6,"name":"runtime-artifact","type":{"kind":"record","name":"InputSlotRefV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":7,"name":"runtime-sidecar","type":{"kind":"record","name":"InputSlotRefV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":8,"name":"contract","type":{"kind":"record","name":"InputSlotRefV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":9,"name":"runtime-requires","type":{"kind":"list","item":{"kind":"record","name":"NativeRuntimeRequirementV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["slot","phase","runtime-identity"]} + ] + }, + { + "name": "ResourcePolicyV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"cpu-count","type":{"kind":"uint"},"cardinality":"1","encoded_default":0,"order":"none","order_by":[]}, + {"tag":2,"name":"memory-bytes","type":{"kind":"uint"},"cardinality":"1","encoded_default":0,"order":"none","order_by":[]}, + {"tag":3,"name":"output-bytes","type":{"kind":"uint"},"cardinality":"1","encoded_default":0,"order":"none","order_by":[]}, + {"tag":4,"name":"process-count","type":{"kind":"uint"},"cardinality":"1","encoded_default":0,"order":"none","order_by":[]} + ] + }, + { + "name": "ResultOutputV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"name","type":{"kind":"string","scalar":"PathArtifact"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"artifact-kind","type":{"kind":"enum","name":"ArtifactKind"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"mode","type":{"kind":"enum","name":"SemanticMode"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":4,"name":"digest","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "RuntimeClosureEntryV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"runtime-identity","type":{"kind":"string","scalar":"RuntimeIdentity"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"artifact","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"destination","type":{"kind":"string","scalar":"PathInstall"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "RuntimeProviderSetV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"providers","type":{"kind":"list","item":{"kind":"record","name":"NativeProviderV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["provides","name"]} + ] + }, + { + "name": "RuntimeResolutionPolicyV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"policy","type":{"kind":"string","scalar":"CapabilityId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"runtime-search","type":{"kind":"list","item":{"kind":"string","scalar":"PathTargetRuntime"}},"cardinality":"*","encoded_default":[],"order":"ordered","order_by":[]} + ] + }, + { + "name": "SandboxPolicyV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"policy","type":{"kind":"string","scalar":"CapabilityId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"version","type":{"kind":"uint"},"cardinality":"1","encoded_default":1,"order":"none","order_by":[]}, + {"tag":3,"name":"resources","type":{"kind":"record","name":"ResourcePolicyV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":4,"name":"reproducibility","type":{"kind":"enum","name":"Reproducibility"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "SectionFactV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"name","type":{"kind":"string"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"format-type","type":{"kind":"string","scalar":"CapabilityId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"flags","type":{"kind":"list","item":{"kind":"string"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["value"]}, + {"tag":4,"name":"size","type":{"kind":"uint"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":5,"name":"alignment","type":{"kind":"uint"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":6,"name":"content","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"0/1","encoded_default":{},"order":"none","order_by":[]} + ] + }, + { + "name": "SelectedClosureRefV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"toolchain-id","type":{"kind":"string","scalar":"ModuleIdentity"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"closure","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"compiler-backend","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "SelectedSourceV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"path","type":{"kind":"string","scalar":"PathSource"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"input-slot","type":{"kind":"record","name":"InputSlotRefV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"selection-reason","type":{"kind":"string"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "SelectedToolClosureV1", + "top_level_kind": 22, + "fields": [ + {"tag":1,"name":"schema","type":{"kind":"uint"},"cardinality":"1","encoded_default":1,"order":"none","order_by":[]}, + {"tag":2,"name":"toolchain-id","type":{"kind":"string","scalar":"ModuleIdentity"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"protocols","type":{"kind":"record","name":"ProtocolBundleV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":4,"name":"tools","type":{"kind":"list","item":{"kind":"record","name":"ToolV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["name"]}, + {"tag":5,"name":"resources","type":{"kind":"list","item":{"kind":"record","name":"TypedDigestV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["domain","record-kind","record-schema","digest"]}, + {"tag":6,"name":"platform-profile-policy","type":{"kind":"record","name":"SelectedToolPolicyV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":7,"name":"runtime-providers","type":{"kind":"record","name":"RuntimeProviderSetV1"},"cardinality":"1","encoded_default":{"providers":[]},"order":"none","order_by":[]} + ] + }, + { + "name": "SelectedToolPolicyV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"platform","type":{"kind":"record","name":"PlatformDescriptorV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"profile","type":{"kind":"record","name":"ProfileV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"link-policy","type":{"kind":"record","name":"LinkPolicyV1"},"cardinality":"0/1","encoded_default":{},"order":"none","order_by":[]} + ] + }, + { + "name": "SharedImportLibraryV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"name","type":{"kind":"string","scalar":"Identifier"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"kind","type":{"kind":"enum","name":"SharedLibraryKind"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"link-artifact","type":{"kind":"record","name":"ArtifactRefV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":4,"name":"link-sidecar","type":{"kind":"record","name":"ArtifactRefV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":5,"name":"runtime-identity","type":{"kind":"string","scalar":"RuntimeIdentity"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":6,"name":"runtime-artifact","type":{"kind":"record","name":"ArtifactRefV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":7,"name":"runtime-sidecar","type":{"kind":"record","name":"ArtifactRefV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":8,"name":"contract","type":{"kind":"record","name":"ArtifactRefV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":9,"name":"runtime-requires","type":{"kind":"list","item":{"kind":"record","name":"NativeRuntimeRequirementV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["slot","phase","runtime-identity"]} + ] + }, + { + "name": "SignedMagnitudeV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"negative","type":{"kind":"bool"},"cardinality":"1","encoded_default":false,"order":"none","order_by":[]}, + {"tag":2,"name":"magnitude","type":{"kind":"uint"},"cardinality":"1","encoded_default":0,"order":"none","order_by":[]} + ] + }, + { + "name": "SignerProvenanceV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"signer","type":{"kind":"string"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"signature","type":{"kind":"bytes"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"provenance","type":{"kind":"string"},"cardinality":"0/1","encoded_default":"","order":"none","order_by":[]} + ] + }, + { + "name": "SourceSelectionV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"members","type":{"kind":"list","item":{"kind":"record","name":"SelectedSourceV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["path"]}, + {"tag":2,"name":"target-tags","type":{"kind":"list","item":{"kind":"string"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["value"]} + ] + }, + { + "name": "SourceTreeEntryProjectionV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"path","type":{"kind":"string","scalar":"PathSource"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"type","type":{"kind":"enum","name":"SourceEntryType"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"executable","type":{"kind":"bool"},"cardinality":"1","encoded_default":false,"order":"none","order_by":[]}, + {"tag":4,"name":"file-sha256","type":{"kind":"bytes"},"cardinality":"0/1","encoded_default":"","order":"none","order_by":[]} + ] + }, + { + "name": "SourceTreeProjectionV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"entries","type":{"kind":"list","item":{"kind":"record","name":"SourceTreeEntryProjectionV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["path"]} + ] + }, + { + "name": "SymbolFactV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"name","type":{"kind":"string"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"version","type":{"kind":"string"},"cardinality":"1","encoded_default":"","order":"none","order_by":[]}, + {"tag":3,"name":"kind","type":{"kind":"enum","name":"SymbolKind"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":4,"name":"role","type":{"kind":"enum","name":"SymbolRole"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":5,"name":"binding","type":{"kind":"enum","name":"Binding"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":6,"name":"visibility","type":{"kind":"enum","name":"Visibility"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":7,"name":"calling-convention","type":{"kind":"string"},"cardinality":"1","encoded_default":"","order":"none","order_by":[]}, + {"tag":8,"name":"type-contract","type":{"kind":"bytes","scalar":"DigestBytes"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":9,"name":"size","type":{"kind":"uint"},"cardinality":"0/1","encoded_default":0,"order":"none","order_by":[]}, + {"tag":10,"name":"section","type":{"kind":"string"},"cardinality":"1","encoded_default":"","order":"none","order_by":[]}, + {"tag":11,"name":"value","type":{"kind":"uint"},"cardinality":"1","encoded_default":0,"order":"none","order_by":[]} + ] + }, + { + "name": "TLSUnwindCapabilitiesV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"tls-models","type":{"kind":"list","item":{"kind":"string"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["value"]}, + {"tag":2,"name":"default-tls","type":{"kind":"string"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"unwind-models","type":{"kind":"list","item":{"kind":"string"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["value"]}, + {"tag":4,"name":"default-unwind","type":{"kind":"string"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "TagNicheLayoutV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"tag-offset","type":{"kind":"uint"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"tag-size","type":{"kind":"uint"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"variants","type":{"kind":"list","item":{"kind":"record","name":"TypeVariantEncodingV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["variant"]} + ] + }, + { + "name": "TargetConstraintV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"descriptor","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"0/1","encoded_default":{},"order":"none","order_by":[]}, + {"tag":2,"name":"arch","type":{"kind":"string","scalar":"ArchitectureId"},"cardinality":"0/1","encoded_default":"","order":"none","order_by":[]}, + {"tag":3,"name":"vendor","type":{"kind":"string","scalar":"VendorId"},"cardinality":"0/1","encoded_default":"","order":"none","order_by":[]}, + {"tag":4,"name":"os","type":{"kind":"string","scalar":"OperatingSystemId"},"cardinality":"0/1","encoded_default":"","order":"none","order_by":[]}, + {"tag":5,"name":"environment","type":{"kind":"string","scalar":"EnvironmentId"},"cardinality":"0/1","encoded_default":"","order":"none","order_by":[]}, + {"tag":6,"name":"object-format","type":{"kind":"string","scalar":"ObjectFormatId"},"cardinality":"0/1","encoded_default":"","order":"none","order_by":[]}, + {"tag":7,"name":"hosted","type":{"kind":"string","scalar":"OptionalBooleanText"},"cardinality":"0/1","encoded_default":"","order":"none","order_by":[]}, + {"tag":8,"name":"c-abi","type":{"kind":"string"},"cardinality":"0/1","encoded_default":"","order":"none","order_by":[]}, + {"tag":9,"name":"data-model","type":{"kind":"string"},"cardinality":"0/1","encoded_default":"","order":"none","order_by":[]}, + {"tag":10,"name":"float-abi","type":{"kind":"string"},"cardinality":"0/1","encoded_default":"","order":"none","order_by":[]}, + {"tag":11,"name":"cpu-baseline","type":{"kind":"string"},"cardinality":"0/1","encoded_default":"","order":"none","order_by":[]}, + {"tag":12,"name":"required-features","type":{"kind":"list","item":{"kind":"string"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["value"]}, + {"tag":13,"name":"forbidden-features","type":{"kind":"list","item":{"kind":"string"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["value"]}, + {"tag":14,"name":"minimum-sdk","type":{"kind":"record","name":"PlatformVersionV1"},"cardinality":"0/1","encoded_default":{},"order":"none","order_by":[]}, + {"tag":15,"name":"relocation","type":{"kind":"string","scalar":"OptionalRelocationMode"},"cardinality":"0/1","encoded_default":"","order":"none","order_by":[]}, + {"tag":16,"name":"code-model","type":{"kind":"string"},"cardinality":"0/1","encoded_default":"","order":"none","order_by":[]}, + {"tag":17,"name":"pic","type":{"kind":"string","scalar":"OptionalPicPolicyText"},"cardinality":"0/1","encoded_default":"","order":"none","order_by":[]} + ] + }, + { + "name": "TargetToolchainProvenanceV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"target","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"toolchain","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"protocols","type":{"kind":"record","name":"ProtocolBundleV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "TemplateInputV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"name","type":{"kind":"string","scalar":"Identifier"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"edge-kind","type":{"kind":"enum","name":"EdgeKind"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"reference","type":{"kind":"record","name":"ArtifactRefV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":4,"name":"artifact-kind","type":{"kind":"enum","name":"ArtifactKind"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":5,"name":"mode","type":{"kind":"enum","name":"SemanticMode"},"cardinality":"1","encoded_default":"data","order":"none","order_by":[]}, + {"tag":6,"name":"origin-package","type":{"kind":"string","scalar":"OptionalPackageIdentity"},"cardinality":"0/1","encoded_default":"","order":"none","order_by":[]} + ] + }, + { + "name": "TemplateNativeLinkV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"providers","type":{"kind":"list","item":{"kind":"record","name":"NativeProviderV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["provides","name"]}, + {"tag":2,"name":"link-policy","type":{"kind":"record","name":"LinkPolicyV1"},"cardinality":"0/1","encoded_default":{},"order":"none","order_by":[]}, + {"tag":3,"name":"required-provider-slots","type":{"kind":"list","item":{"kind":"string","scalar":"ProviderSlot"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["value"]} + ] + }, + { + "name": "TimingResourcesV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"elapsed-nanoseconds","type":{"kind":"uint"},"cardinality":"1","encoded_default":0,"order":"none","order_by":[]}, + {"tag":2,"name":"user-nanoseconds","type":{"kind":"uint"},"cardinality":"1","encoded_default":0,"order":"none","order_by":[]}, + {"tag":3,"name":"system-nanoseconds","type":{"kind":"uint"},"cardinality":"1","encoded_default":0,"order":"none","order_by":[]}, + {"tag":4,"name":"peak-memory-bytes","type":{"kind":"uint"},"cardinality":"1","encoded_default":0,"order":"none","order_by":[]} + ] + }, + { + "name": "ToolAdapterV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"adapter-id","type":{"kind":"string","scalar":"CapabilityId"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"raw-options","type":{"kind":"list","item":{"kind":"bytes"}},"cardinality":"*","encoded_default":[],"order":"ordered","order_by":[]}, + {"tag":3,"name":"injected-environment","type":{"kind":"map","value":{"kind":"string"}},"cardinality":"map","encoded_default":{},"order":"raw-utf8","order_by":["key"]} + ] + }, + { + "name": "ToolV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"name","type":{"kind":"string","scalar":"Identifier"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"path","type":{"kind":"string","scalar":"PathBundle"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"executable","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":4,"name":"dynamic-dependencies","type":{"kind":"list","item":{"kind":"record","name":"ArtifactRefV1"}},"cardinality":"*","encoded_default":[],"order":"ordered","order_by":[]}, + {"tag":5,"name":"resources","type":{"kind":"list","item":{"kind":"record","name":"TypedDigestV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["domain","record-kind","record-schema","digest"]}, + {"tag":6,"name":"adapter","type":{"kind":"record","name":"ToolAdapterV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "ToolchainLockV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"id","type":{"kind":"string","scalar":"ModuleIdentity"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"version","type":{"kind":"string","scalar":"SemVer"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"descriptor","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":4,"name":"bundle","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":5,"name":"origin","type":{"kind":"string","scalar":"Url"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "ToolchainRefV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"id","type":{"kind":"string","scalar":"ModuleIdentity"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"minimum","type":{"kind":"string","scalar":"SemVer"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "ToolchainV1", + "top_level_kind": 8, + "fields": [ + {"tag":1,"name":"schema","type":{"kind":"uint"},"cardinality":"1","encoded_default":1,"order":"none","order_by":[]}, + {"tag":2,"name":"id","type":{"kind":"string","scalar":"ModuleIdentity"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"version","type":{"kind":"string","scalar":"SemVer"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":4,"name":"protocols","type":{"kind":"record","name":"ProtocolBundleV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":5,"name":"tools","type":{"kind":"list","item":{"kind":"record","name":"ToolV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["name"]}, + {"tag":6,"name":"platforms","type":{"kind":"list","item":{"kind":"record","name":"PlatformDescriptorV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["name"]}, + {"tag":7,"name":"profiles","type":{"kind":"list","item":{"kind":"record","name":"ProfileV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["name"]}, + {"tag":8,"name":"link-policies","type":{"kind":"list","item":{"kind":"record","name":"LinkPolicyV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["product-platform.domain","product-platform.record-kind","product-platform.record-schema","product-platform.digest","product-kind","linkage","profile-constraint","runtime"]}, + {"tag":9,"name":"runtime-providers","type":{"kind":"record","name":"RuntimeProviderSetV1"},"cardinality":"1","encoded_default":{"providers":[]},"order":"none","order_by":[]}, + {"tag":10,"name":"bundle","type":{"kind":"record","name":"BundleProvenanceV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "TreeEntryV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"name","type":{"kind":"string","scalar":"PathTreeSegment"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"kind","type":{"kind":"enum","name":"TreeEntryKind"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"executable","type":{"kind":"bool"},"cardinality":"1","encoded_default":false,"order":"none","order_by":[]}, + {"tag":4,"name":"child","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "TreeV1", + "top_level_kind": 1, + "fields": [ + {"tag":1,"name":"schema","type":{"kind":"uint"},"cardinality":"1","encoded_default":1,"order":"none","order_by":[]}, + {"tag":2,"name":"entries","type":{"kind":"list","item":{"kind":"record","name":"TreeEntryV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["name"]} + ] + }, + { + "name": "TypeFieldLayoutV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"child-id","type":{"kind":"uint"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"offset","type":{"kind":"uint"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"size","type":{"kind":"uint"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":4,"name":"alignment","type":{"kind":"uint"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":5,"name":"role","type":{"kind":"enum","name":"TypeFieldRole"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "TypeFieldSemanticV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"public-name","type":{"kind":"string","scalar":"Identifier"},"cardinality":"0/1","encoded_default":"","order":"none","order_by":[]}, + {"tag":2,"name":"visibility","type":{"kind":"enum","name":"TypeVisibility"},"cardinality":"1","encoded_default":"private","order":"none","order_by":[]}, + {"tag":3,"name":"role","type":{"kind":"enum","name":"TypeFieldRole"},"cardinality":"1","encoded_default":"field","order":"none","order_by":[]}, + {"tag":4,"name":"child-id","type":{"kind":"uint"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "TypeGraphNodeV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"id","type":{"kind":"uint"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"kind","type":{"kind":"enum","name":"TypeNodeKind"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"identity","type":{"kind":"string","scalar":"TypeIdentityOrEmpty"},"cardinality":"1","encoded_default":"","order":"none","order_by":[]}, + {"tag":4,"name":"children","type":{"kind":"list","item":{"kind":"uint"}},"cardinality":"*","encoded_default":[],"order":"ordered","order_by":[]}, + {"tag":5,"name":"semantic","type":{"kind":"record","name":"TypeSemanticV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":6,"name":"layout","type":{"kind":"record","name":"TypeLayoutV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "TypeLayoutV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"size","type":{"kind":"uint"},"cardinality":"0/1","encoded_default":0,"order":"none","order_by":[]}, + {"tag":2,"name":"alignment","type":{"kind":"uint"},"cardinality":"0/1","encoded_default":0,"order":"none","order_by":[]}, + {"tag":3,"name":"fields","type":{"kind":"list","item":{"kind":"record","name":"TypeFieldLayoutV1"}},"cardinality":"*","encoded_default":[],"order":"ordered","order_by":[]}, + {"tag":4,"name":"calling-convention","type":{"kind":"string"},"cardinality":"0/1","encoded_default":"","order":"none","order_by":[]}, + {"tag":5,"name":"return-passing","type":{"kind":"string"},"cardinality":"0/1","encoded_default":"","order":"none","order_by":[]}, + {"tag":6,"name":"parameter-passing","type":{"kind":"list","item":{"kind":"string"}},"cardinality":"*","encoded_default":[],"order":"ordered","order_by":[]}, + {"tag":7,"name":"tag-niche","type":{"kind":"record","name":"TagNicheLayoutV1"},"cardinality":"0/1","encoded_default":{},"order":"none","order_by":[]}, + {"tag":8,"name":"padding","type":{"kind":"list","item":{"kind":"record","name":"PaddingRangeV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["offset"]}, + {"tag":9,"name":"c-data-model","type":{"kind":"string"},"cardinality":"0/1","encoded_default":"","order":"none","order_by":[]}, + {"tag":10,"name":"aggregate-algorithm","type":{"kind":"string"},"cardinality":"0/1","encoded_default":"","order":"none","order_by":[]} + ] + }, + { + "name": "TypeParameterSemanticV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"child-id","type":{"kind":"uint"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"variadic","type":{"kind":"bool"},"cardinality":"1","encoded_default":false,"order":"none","order_by":[]} + ] + }, + { + "name": "TypeSemanticV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"array-length","type":{"kind":"uint"},"cardinality":"0/1","encoded_default":0,"order":"none","order_by":[]}, + {"tag":2,"name":"fields","type":{"kind":"list","item":{"kind":"record","name":"TypeFieldSemanticV1"}},"cardinality":"*","encoded_default":[],"order":"ordered","order_by":[]}, + {"tag":3,"name":"parameters","type":{"kind":"list","item":{"kind":"record","name":"TypeParameterSemanticV1"}},"cardinality":"*","encoded_default":[],"order":"ordered","order_by":[]}, + {"tag":4,"name":"enum-members","type":{"kind":"list","item":{"kind":"record","name":"EnumMemberV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["name"]}, + {"tag":5,"name":"c-variadic","type":{"kind":"bool"},"cardinality":"1","encoded_default":false,"order":"none","order_by":[]}, + {"tag":6,"name":"packed","type":{"kind":"bool"},"cardinality":"1","encoded_default":false,"order":"none","order_by":[]}, + {"tag":7,"name":"nullable","type":{"kind":"bool"},"cardinality":"1","encoded_default":false,"order":"none","order_by":[]}, + {"tag":8,"name":"error-variants","type":{"kind":"list","item":{"kind":"uint"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["value"]}, + {"tag":9,"name":"repr","type":{"kind":"enum","name":"TypeRepr"},"cardinality":"1","encoded_default":"ww","order":"none","order_by":[]}, + {"tag":10,"name":"opaque-promises","type":{"kind":"list","item":{"kind":"string","scalar":"CapabilityId"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["value"]} + ] + }, + { + "name": "TypeVariantEncodingV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"variant","type":{"kind":"uint"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"negative","type":{"kind":"bool"},"cardinality":"1","encoded_default":false,"order":"none","order_by":[]}, + {"tag":3,"name":"magnitude","type":{"kind":"uint"},"cardinality":"1","encoded_default":0,"order":"none","order_by":[]} + ] + }, + { + "name": "TypedDigestV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"domain","type":{"kind":"enum","name":"DigestDomain"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"algorithm","type":{"kind":"enum","name":"DigestAlgorithm"},"cardinality":"1","encoded_default":"sha256","order":"none","order_by":[]}, + {"tag":3,"name":"record-kind","type":{"kind":"uint"},"cardinality":"1","encoded_default":0,"order":"none","order_by":[]}, + {"tag":4,"name":"record-schema","type":{"kind":"uint"},"cardinality":"1","encoded_default":0,"order":"none","order_by":[]}, + {"tag":5,"name":"digest","type":{"kind":"bytes"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "UseV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"module","type":{"kind":"string","scalar":"ModuleIdentity"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"path","type":{"kind":"string","scalar":"WorkspaceLocation"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"expected","type":{"kind":"bytes","scalar":"SourceTreeDigest"},"cardinality":"0/1","encoded_default":"","order":"none","order_by":[]} + ] + }, + { + "name": "VendorEntryV1", + "top_level_kind": null, + "fields": [ + {"tag":1,"name":"module","type":{"kind":"string","scalar":"ModuleIdentity"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":2,"name":"version","type":{"kind":"string","scalar":"SemVer"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"tree","type":{"kind":"bytes","scalar":"SourceTreeDigest"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":4,"name":"path","type":{"kind":"string","scalar":"PathVendor"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]} + ] + }, + { + "name": "VendorV1", + "top_level_kind": 5, + "fields": [ + {"tag":1,"name":"schema","type":{"kind":"uint"},"cardinality":"1","encoded_default":1,"order":"none","order_by":[]}, + {"tag":2,"name":"lock","type":{"kind":"record","name":"TypedDigestV1"},"cardinality":"1","encoded_default":null,"order":"none","order_by":[]}, + {"tag":3,"name":"entries","type":{"kind":"list","item":{"kind":"record","name":"VendorEntryV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["module"]} + ] + }, + { + "name": "WorkV1", + "top_level_kind": 4, + "fields": [ + {"tag":1,"name":"schema","type":{"kind":"uint"},"cardinality":"1","encoded_default":1,"order":"none","order_by":[]}, + {"tag":2,"name":"uses","type":{"kind":"list","item":{"kind":"record","name":"UseV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["module"]}, + {"tag":3,"name":"providers","type":{"kind":"list","item":{"kind":"record","name":"ProviderOverrideV1"}},"cardinality":"*","encoded_default":[],"order":"sorted","order_by":["slot"]} + ] + } + ], + "unions": [ + {"name":"LinkTokenTemplateUnion","record":"LinkTokenTemplateV1","discriminator":"kind","cases":[{"value":"object","required":["kind","artifact"],"allowed":["kind","artifact"],"nonempty":["artifact"],"empty":["provider-slot","value","enabled","validated-path","runtime-path","items"]},{"value":"archive","required":["kind","artifact"],"allowed":["kind","artifact"],"nonempty":["artifact"],"empty":["provider-slot","value","enabled","validated-path","runtime-path","items"]},{"value":"shared","required":["kind","artifact"],"allowed":["kind","artifact"],"nonempty":["artifact"],"empty":["provider-slot","value","enabled","validated-path","runtime-path","items"]},{"value":"provider","required":["kind","provider-slot"],"allowed":["kind","provider-slot"],"nonempty":["provider-slot"],"empty":["artifact","value","enabled","validated-path","runtime-path","items"]},{"value":"group","required":["kind","items"],"allowed":["kind","items"],"nonempty":["items"],"empty":["artifact","provider-slot","value","enabled","validated-path","runtime-path"]},{"value":"whole","required":["kind","items"],"allowed":["kind","items"],"nonempty":["items"],"empty":["artifact","provider-slot","value","enabled","validated-path","runtime-path"]},{"value":"as-needed","required":["kind","enabled","items"],"allowed":["kind","enabled","items"],"nonempty":["items"],"empty":["artifact","provider-slot","value","validated-path","runtime-path"]},{"value":"linker-script","required":["kind","artifact"],"allowed":["kind","artifact"],"nonempty":["artifact"],"empty":["provider-slot","value","enabled","validated-path","runtime-path","items"]},{"value":"version-script","required":["kind","artifact"],"allowed":["kind","artifact"],"nonempty":["artifact"],"empty":["provider-slot","value","enabled","validated-path","runtime-path","items"]},{"value":"export-map","required":["kind","artifact"],"allowed":["kind","artifact"],"nonempty":["artifact"],"empty":["provider-slot","value","enabled","validated-path","runtime-path","items"]},{"value":"def-file","required":["kind","artifact"],"allowed":["kind","artifact"],"nonempty":["artifact"],"empty":["provider-slot","value","enabled","validated-path","runtime-path","items"]},{"value":"runtime-search","required":["kind","value","validated-path"],"allowed":["kind","value","validated-path"],"nonempty":["value","validated-path"],"empty":["artifact","provider-slot","enabled","runtime-path","items"]},{"value":"install-name","required":["kind","value"],"allowed":["kind","value"],"nonempty":["value"],"empty":["artifact","provider-slot","enabled","validated-path","runtime-path","items"]},{"value":"dynamic-loader","required":["kind","artifact","runtime-path"],"allowed":["kind","artifact","runtime-path"],"nonempty":["artifact","runtime-path"],"empty":["provider-slot","value","enabled","validated-path","items"]},{"value":"entry","required":["kind","value"],"allowed":["kind","value"],"nonempty":["value"],"empty":["artifact","provider-slot","enabled","validated-path","runtime-path","items"]},{"value":"retain","required":["kind","value"],"allowed":["kind","value"],"nonempty":["value"],"empty":["artifact","provider-slot","enabled","validated-path","runtime-path","items"]},{"value":"splice","required":["kind","value"],"allowed":["kind","value"],"nonempty":["value"],"empty":["artifact","provider-slot","enabled","validated-path","runtime-path","items"]},{"value":"script-slot","required":["kind"],"allowed":["kind","artifact"],"nonempty":[],"empty":["provider-slot","value","enabled","validated-path","runtime-path","items"]}]}, + {"name":"LinkTokenUnion","record":"LinkTokenV1","discriminator":"kind","cases":[{"value":"object","required":["kind","artifact"],"allowed":["kind","artifact"],"nonempty":["artifact"],"empty":["provider-slot","value","enabled","validated-path","runtime-path","items"]},{"value":"archive","required":["kind","artifact"],"allowed":["kind","artifact"],"nonempty":["artifact"],"empty":["provider-slot","value","enabled","validated-path","runtime-path","items"]},{"value":"shared","required":["kind","artifact"],"allowed":["kind","artifact"],"nonempty":["artifact"],"empty":["provider-slot","value","enabled","validated-path","runtime-path","items"]},{"value":"group","required":["kind","items"],"allowed":["kind","items"],"nonempty":["items"],"empty":["artifact","provider-slot","value","enabled","validated-path","runtime-path"]},{"value":"whole","required":["kind","items"],"allowed":["kind","items"],"nonempty":["items"],"empty":["artifact","provider-slot","value","enabled","validated-path","runtime-path"]},{"value":"as-needed","required":["kind","enabled","items"],"allowed":["kind","enabled","items"],"nonempty":["items"],"empty":["artifact","provider-slot","value","validated-path","runtime-path"]},{"value":"linker-script","required":["kind","artifact"],"allowed":["kind","artifact"],"nonempty":["artifact"],"empty":["provider-slot","value","enabled","validated-path","runtime-path","items"]},{"value":"version-script","required":["kind","artifact"],"allowed":["kind","artifact"],"nonempty":["artifact"],"empty":["provider-slot","value","enabled","validated-path","runtime-path","items"]},{"value":"export-map","required":["kind","artifact"],"allowed":["kind","artifact"],"nonempty":["artifact"],"empty":["provider-slot","value","enabled","validated-path","runtime-path","items"]},{"value":"def-file","required":["kind","artifact"],"allowed":["kind","artifact"],"nonempty":["artifact"],"empty":["provider-slot","value","enabled","validated-path","runtime-path","items"]},{"value":"runtime-search","required":["kind","value","validated-path"],"allowed":["kind","value","validated-path"],"nonempty":["value","validated-path"],"empty":["artifact","provider-slot","enabled","runtime-path","items"]},{"value":"install-name","required":["kind","value"],"allowed":["kind","value"],"nonempty":["value"],"empty":["artifact","provider-slot","enabled","validated-path","runtime-path","items"]},{"value":"dynamic-loader","required":["kind","artifact","runtime-path"],"allowed":["kind","artifact","runtime-path"],"nonempty":["artifact","runtime-path"],"empty":["provider-slot","value","enabled","validated-path","items"]},{"value":"entry","required":["kind","value"],"allowed":["kind","value"],"nonempty":["value"],"empty":["artifact","provider-slot","enabled","validated-path","runtime-path","items"]},{"value":"retain","required":["kind","value"],"allowed":["kind","value"],"nonempty":["value"],"empty":["artifact","provider-slot","enabled","validated-path","runtime-path","items"]}]}, + {"name":"TypedDigestUnion","record":"TypedDigestV1","discriminator":"domain","cases":[{"value":"blob","required":["domain","algorithm","record-kind","record-schema","digest"],"allowed":["domain","algorithm","record-kind","record-schema","digest"],"nonempty":["digest"],"empty":[]},{"value":"record","required":["domain","algorithm","record-kind","record-schema","digest"],"allowed":["domain","algorithm","record-kind","record-schema","digest"],"nonempty":["record-kind","record-schema","digest"],"empty":[]}]} + ], + "artifact_digest_mapping": [ + {"artifact_kind":"action-record","domain":"record","record_kind":11,"record_schema":1}, + {"artifact_kind":"action-result","domain":"record","record_kind":12,"record_schema":1}, + {"artifact_kind":"archive","domain":"blob","record_kind":0,"record_schema":0}, + {"artifact_kind":"crt","domain":"blob","record_kind":0,"record_schema":0}, + {"artifact_kind":"export","domain":"record","record_kind":18,"record_schema":1}, + {"artifact_kind":"file","domain":"blob","record_kind":0,"record_schema":0}, + {"artifact_kind":"import-library","domain":"blob","record_kind":0,"record_schema":0}, + {"artifact_kind":"loader","domain":"blob","record_kind":0,"record_schema":0}, + {"artifact_kind":"native-abi","domain":"record","record_kind":16,"record_schema":1}, + {"artifact_kind":"native-sidecar","domain":"record","record_kind":15,"record_schema":1}, + {"artifact_kind":"object","domain":"blob","record_kind":0,"record_schema":0}, + {"artifact_kind":"package-link","domain":"record","record_kind":19,"record_schema":1}, + {"artifact_kind":"script","domain":"blob","record_kind":0,"record_schema":0}, + {"artifact_kind":"shared","domain":"blob","record_kind":0,"record_schema":0}, + {"artifact_kind":"tree","domain":"record","record_kind":1,"record_schema":1} + ], + "wrappers": [ + {"name":".wwe","magic_hex":"5757455800000001","framing":[{"offset":0,"length":8,"value_hex":"5757455800000001"},{"offset":8,"length":"to EOF","encoding":"one complete WWAR version-1 ExportV1 envelope"}],"trailing_bytes":"reject","body_record":"ExportV1","identity":"record_id(18,1,body); the exact eight-byte magic is verified and reconstructed framing and is not a second identity"}, + {"name":".wwinstall","magic_hex":"","body_record":"InstallManifestV1","identity":"record_id(20,1,body)"}, + {"name":".wwlm","magic_hex":"","body_record":"PackageLinkV1","identity":"record_id(19,1,body)"}, + {"name":"bootstrap.plan","magic_hex":"","body_record":"BootstrapPlanV1","identity":"record_id(21,1,body)"} + ] +} diff --git a/protocol/schema/wire.json b/protocol/schema/wire.json new file mode 100644 index 00000000..d3b0303d --- /dev/null +++ b/protocol/schema/wire.json @@ -0,0 +1,145 @@ +{ + "format": "wwar-v1-wire-schema", + "version": 1, + "magic_hex": "57574152", + "schema_version": 1, + "root": "one complete value; typed identities and wrappers additionally require their declared record", + "value_frame": { + "type": "u8", + "payload_length": "u64be", + "payload": "exactly payload_length bytes" + }, + "container_frames": { + "list": { + "count": "u32be", + "members": "count repetitions of u64be(value_length) followed by exactly one complete value frame" + }, + "map": { + "count": "u32be", + "members": "count repetitions of u64be(key_length), raw UTF-8 key, u64be(value_length), complete value frame" + }, + "record": { + "count": "u32be", + "members": "count repetitions of u32be(field_tag), u64be(value_length), complete value frame" + } + }, + "wire_types": [ + { + "name": "bytes", + "code": 1, + "payload": { + "frame": "raw-bytes", + "canonical": [ + "declared-limit", + "frame-available", + "exact-length" + ] + } + }, + { + "name": "string", + "code": 2, + "payload": { + "frame": "utf8", + "canonical": [ + "declared-limit", + "frame-available", + "valid-utf8", + "no-nul-string", + "nfc-string", + "exact-length" + ] + } + }, + { + "name": "uint", + "code": 3, + "payload": { + "frame": "minimal-uint", + "canonical": [ + "declared-limit", + "frame-available", + "uint-width", + "uint-minimal", + "exact-length" + ] + } + }, + { + "name": "bool", + "code": 4, + "payload": { + "frame": "byte", + "canonical": [ + "declared-limit", + "frame-available", + "bool-00-or-01", + "exact-length" + ] + } + }, + { + "name": "list", + "code": 5, + "payload": { + "frame": "counted-values", + "canonical": [ + "declared-limit", + "frame-available", + "declared-order", + "exact-length" + ] + } + }, + { + "name": "map", + "code": 6, + "payload": { + "frame": "counted-pairs", + "canonical": [ + "declared-limit", + "frame-available", + "raw-utf8-key-order", + "exact-length" + ] + } + }, + { + "name": "record", + "code": 7, + "payload": { + "frame": "counted-fields", + "canonical": [ + "declared-limit", + "frame-available", + "increasing-tag-order", + "exact-length" + ] + } + } + ], + "limits": { + "container_members_max": 16777215, + "nesting_depth_max": 64, + "string_or_bytes_length_max": 2147483647, + "uint_max": "18446744073709551615", + "wwar_payload_length_max": "18446744073709551615" + }, + "unicode": { + "version": "16.0.0", + "form": "NFC", + "nul_forbidden": true, + "scalar_values_only": true, + "utf8": "RFC 3629 shortest form; surrogates and values above U+10FFFF are invalid", + "validation_order": [ + "decode shortest-form UTF-8", + "reject NUL and non-scalar values", + "require exact NFC under Unicode 16.0.0" + ] + }, + "error_precedence": [ + "declared limit before frame availability", + "frame truncation before type-specific or exact-length checks", + "fully framed child length mismatch before child interpretation" + ] +} diff --git a/protocol/schema/wwar-v1.sha256 b/protocol/schema/wwar-v1.sha256 new file mode 100644 index 00000000..9c81f768 --- /dev/null +++ b/protocol/schema/wwar-v1.sha256 @@ -0,0 +1,3 @@ +fd27eaf17bb8767f685bad4b4f577eb7521771f9ea58eeb4824a78a622664f4f wire.json +4b4d18f60de652831e16d4c34b6c291020991ba7e5493a25f9f28b11d14b3cba records.json +de722e871e3bb8c5801d94d214b3cbe03d111b3a53957ca95a876f53e11e58cc digests.json diff --git a/protocol/tool.py b/protocol/tool.py new file mode 100644 index 00000000..4485b0bb --- /dev/null +++ b/protocol/tool.py @@ -0,0 +1,2100 @@ +#!/usr/bin/env python3 +"""Strict WWAR v1 schema, codec, table generator, and digest utility.""" + +from __future__ import annotations + +import argparse +import copy +import hashlib +import json +import pathlib +import struct +import sys +import unicodedata +from dataclasses import dataclass +from typing import Any + + +SCHEMA_FILES = ("wire.json", "records.json", "digests.json") +SCHEMA_MANIFEST = "wwar-v1.sha256" +TABLE_FORMAT = "wwar-v1-tables" +SCHEMA_DOMAIN = b"WW-SCHEMA-V1\0" +FORMULA_BYTES = ("separator", "u64be(input-length)", "input-bytes") +FORMULA_WWAR = ("separator", "u64be(encoded-length)", "encoded-bytes") +FORMULA_RECORD = ( + "separator", + "u32be(record-kind)", + "u32be(record-schema)", + "u64be(encoded-length)", + "encoded-bytes", +) +FORMULA_SOURCE_TREE = ( + "separator", + "concatenate entry path,type,executable,content frames", +) +WIRE_ROOT = "one complete value; typed identities and wrappers additionally require their declared record" +WIRE_VALUE_FRAME = { + "type": "u8", + "payload_length": "u64be", + "payload": "exactly payload_length bytes", +} +WIRE_CONTAINER_FRAMES = { + "list": { + "count": "u32be", + "members": "count repetitions of u64be(value_length) followed by exactly one complete value frame", + }, + "map": { + "count": "u32be", + "members": "count repetitions of u64be(key_length), raw UTF-8 key, u64be(value_length), complete value frame", + }, + "record": { + "count": "u32be", + "members": "count repetitions of u32be(field_tag), u64be(value_length), complete value frame", + }, +} +WIRE_TYPE_ROWS = [ + {"name": "bytes", "code": 1, "payload": {"frame": "raw-bytes", "canonical": ["declared-limit", "frame-available", "exact-length"]}}, + {"name": "string", "code": 2, "payload": {"frame": "utf8", "canonical": ["declared-limit", "frame-available", "valid-utf8", "no-nul-string", "nfc-string", "exact-length"]}}, + {"name": "uint", "code": 3, "payload": {"frame": "minimal-uint", "canonical": ["declared-limit", "frame-available", "uint-width", "uint-minimal", "exact-length"]}}, + {"name": "bool", "code": 4, "payload": {"frame": "byte", "canonical": ["declared-limit", "frame-available", "bool-00-or-01", "exact-length"]}}, + {"name": "list", "code": 5, "payload": {"frame": "counted-values", "canonical": ["declared-limit", "frame-available", "declared-order", "exact-length"]}}, + {"name": "map", "code": 6, "payload": {"frame": "counted-pairs", "canonical": ["declared-limit", "frame-available", "raw-utf8-key-order", "exact-length"]}}, + {"name": "record", "code": 7, "payload": {"frame": "counted-fields", "canonical": ["declared-limit", "frame-available", "increasing-tag-order", "exact-length"]}}, +] +WIRE_LIMITS = { + "container_members_max": (1 << 24) - 1, + "nesting_depth_max": 64, + "string_or_bytes_length_max": (1 << 31) - 1, + "uint_max": str((1 << 64) - 1), + "wwar_payload_length_max": str((1 << 64) - 1), +} +WIRE_UNICODE = { + "version": "16.0.0", + "form": "NFC", + "nul_forbidden": True, + "scalar_values_only": True, + "utf8": "RFC 3629 shortest form; surrogates and values above U+10FFFF are invalid", + "validation_order": [ + "decode shortest-form UTF-8", + "reject NUL and non-scalar values", + "require exact NFC under Unicode 16.0.0", + ], +} +WIRE_ERROR_PRECEDENCE = [ + "declared limit before frame availability", + "frame truncation before type-specific or exact-length checks", + "fully framed child length mismatch before child interpretation", +] +SCHEMA_LITERAL_BYTES_MAX = 16 * 1024 +SCHEMA_LITERAL_NODES_MAX = 4096 +SCHEMA_LITERAL_MEMBERS_MAX = 1024 +SCHEMA_LITERAL_DEPTH_MAX = 64 + + +class SchemaError(ValueError): + pass + + +@dataclass +class ProtocolError(ValueError): + code: str + path: str = "$" + detail: str = "" + + def __str__(self) -> str: + suffix = f": {self.detail}" if self.detail else "" + return f"{self.code} {self.path}{suffix}" + + +def _duplicate_object(pairs: list[tuple[str, Any]]) -> dict[str, Any]: + result: dict[str, Any] = {} + for key, value in pairs: + if key in result: + raise SchemaError(f"duplicate JSON key {key!r}") + result[key] = value + return result + + +def load_json(path: pathlib.Path) -> Any: + try: + raw = path.read_bytes() + except OSError as exc: + raise SchemaError(f"cannot read {path}: {exc}") from exc + try: + text = raw.decode("utf-8") + except UnicodeDecodeError as exc: + raise SchemaError(f"{path}: invalid UTF-8") from exc + if unicodedata.normalize("NFC", text) != text: + raise SchemaError(f"{path}: JSON text is not NFC") + try: + return json.loads(text, object_pairs_hook=_duplicate_object) + except json.JSONDecodeError as exc: + raise SchemaError(f"{path}:{exc.lineno}:{exc.colno}: {exc.msg}") from exc + + +def canonical_json(value: Any) -> bytes: + return ( + json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":")) + + "\n" + ).encode("utf-8") + + +def _keys(value: Any, expected: set[str], where: str) -> None: + if not isinstance(value, dict): + raise SchemaError(f"{where}: expected object") + actual = set(value) + if actual != expected: + raise SchemaError( + f"{where}: keys differ: missing={sorted(expected - actual)} " + f"unknown={sorted(actual - expected)}" + ) + + +def _allowed_keys(value: Any, allowed: set[str], required: set[str], where: str) -> None: + if not isinstance(value, dict): + raise SchemaError(f"{where}: expected object") + actual = set(value) + if not required <= actual or not actual <= allowed: + raise SchemaError( + f"{where}: keys differ: missing={sorted(required - actual)} " + f"unknown={sorted(actual - allowed)}" + ) + + +def _list(value: Any, where: str) -> list[Any]: + if not isinstance(value, list): + raise SchemaError(f"{where}: expected array") + return value + + +def _name(value: Any, where: str) -> str: + if ( + not isinstance(value, str) + or not value + or len(value.encode("utf-8")) > 255 + or unicodedata.normalize("NFC", value) != value + ): + raise SchemaError(f"{where}: expected nonempty NFC string") + return value + + +def _uint(value: Any, where: str, maximum: int = (1 << 64) - 1) -> int: + if isinstance(value, bool) or not isinstance(value, int) or value < 0 or value > maximum: + raise SchemaError(f"{where}: expected unsigned integer <= {maximum}") + return value + + +def _hex(value: Any, where: str, exact_bytes: int | None = None) -> bytes: + if not isinstance(value, str) or len(value) % 2 or value.lower() != value: + raise SchemaError(f"{where}: expected lowercase even-length hexadecimal") + try: + raw = bytes.fromhex(value) + except ValueError as exc: + raise SchemaError(f"{where}: invalid hexadecimal") from exc + if exact_bytes is not None and len(raw) != exact_bytes: + raise SchemaError(f"{where}: expected {exact_bytes} bytes") + return raw + + +def _validate_schema_literal_budget(value: Any, where: str) -> None: + nodes = 0 + + def walk(child: Any, depth: int) -> None: + nonlocal nodes + nodes += 1 + if nodes > SCHEMA_LITERAL_NODES_MAX: + raise SchemaError(f"{where}: schema literal has too many nodes") + if depth > SCHEMA_LITERAL_DEPTH_MAX: + raise SchemaError(f"{where}: schema literal is too deeply nested") + if isinstance(child, str): + if len(child.encode("utf-8")) > SCHEMA_LITERAL_BYTES_MAX: + raise SchemaError(f"{where}: schema literal string is too large") + return + if isinstance(child, list): + if len(child) > SCHEMA_LITERAL_MEMBERS_MAX: + raise SchemaError(f"{where}: schema literal list has too many members") + for item in child: + walk(item, depth + 1) + return + if isinstance(child, dict): + if len(child) > SCHEMA_LITERAL_MEMBERS_MAX: + raise SchemaError(f"{where}: schema literal map has too many members") + for key, item in child.items(): + walk(key, depth + 1) + walk(item, depth + 1) + + walk(value, 0) + try: + encoded = canonical_json(value) + except (TypeError, ValueError) as exc: + raise SchemaError(f"{where}: schema literal is not JSON data") from exc + if len(encoded) > SCHEMA_LITERAL_BYTES_MAX: + raise SchemaError(f"{where}: canonical schema literal is too large") + + +def _compiled_type(value: dict[str, Any]) -> list[Any]: + kind = value["kind"] + if kind in {"bool", "bytes", "string", "uint"}: + return [kind, value.get("scalar")] + if kind in {"enum", "record"}: + return [kind, value["name"]] + if kind == "list": + return [kind, _compiled_type(value["item"])] + if kind == "map": + return [kind, _compiled_type(value["value"])] + raise SchemaError(f"cannot compile unknown type {kind!r}") + + +class SchemaBundle: + def __init__( + self, + wire: dict[str, Any], + records: dict[str, Any], + digests: dict[str, Any], + file_hashes: dict[str, str] | None = None, + schema_digest: str | None = None, + ) -> None: + self.wire = wire + self.records_data = records + self.digests_data = digests + self.file_hashes = file_hashes or {} + self.schema_digest = schema_digest or "" + self.records: dict[str, dict[str, Any]] = {} + self.enums: dict[str, dict[str, Any]] = {} + self.scalars: dict[str, dict[str, Any]] = {} + self.paths: dict[str, dict[str, Any]] = {} + self.unions: dict[str, dict[str, Any]] = {} + self.kinds: dict[int, dict[str, Any]] = {} + self.domains: dict[str, dict[str, Any]] = {} + self.wrappers: dict[str, dict[str, Any]] = {} + self.type_codes: dict[str, int] = {} + self.type_names: dict[int, str] = {} + + @classmethod + def from_dir(cls, schema_dir: pathlib.Path, check_manifest: bool = True) -> "SchemaBundle": + paths = {name: schema_dir / name for name in SCHEMA_FILES} + values = {name: load_json(path) for name, path in paths.items()} + file_hashes = { + name: hashlib.sha256(paths[name].read_bytes()).hexdigest() for name in SCHEMA_FILES + } + digest = schema_bundle_digest(paths) + bundle = cls( + values["wire.json"], + values["records.json"], + values["digests.json"], + file_hashes, + digest, + ) + bundle.validate() + if check_manifest: + check_schema_manifest(schema_dir, file_hashes) + return bundle + + def validate(self) -> None: + self._validate_wire() + self._validate_records() + self._validate_digests() + + def _validate_wire(self) -> None: + _keys( + self.wire, + { + "format", + "version", + "magic_hex", + "schema_version", + "root", + "value_frame", + "container_frames", + "wire_types", + "limits", + "unicode", + "error_precedence", + }, + "$wire", + ) + if self.wire["format"] != "wwar-v1-wire-schema" or self.wire["version"] != 1: + raise SchemaError("$wire: unsupported format/version") + _hex(self.wire["magic_hex"], "$wire.magic_hex", 4) + if self.wire["magic_hex"] != "57574152": + raise SchemaError("$wire.magic_hex: WWAR v1 magic differs") + _uint(self.wire["schema_version"], "$wire.schema_version", 0xFFFF) + if self.wire["schema_version"] != 1: + raise SchemaError("$wire.schema_version: WWAR v1 schema differs") + if self.wire["root"] != WIRE_ROOT: + raise SchemaError("$wire.root: unsupported root framing") + _keys(self.wire["value_frame"], {"type", "payload_length", "payload"}, "$wire.value_frame") + if self.wire["value_frame"] != WIRE_VALUE_FRAME: + raise SchemaError("$wire.value_frame: unsupported framing") + containers = self.wire["container_frames"] + _keys(containers, {"list", "map", "record"}, "$wire.container_frames") + _keys(containers["list"], {"count", "members"}, "$wire.container_frames.list") + _keys(containers["map"], {"count", "members"}, "$wire.container_frames.map") + _keys(containers["record"], {"count", "members"}, "$wire.container_frames.record") + if containers != WIRE_CONTAINER_FRAMES: + raise SchemaError("$wire.container_frames: unsupported framing") + seen_names: set[str] = set() + seen_codes: set[int] = set() + for index, row in enumerate(_list(self.wire["wire_types"], "$wire.wire_types")): + _keys(row, {"name", "code", "payload"}, f"$wire.wire_types[{index}]") + name = _name(row["name"], f"$wire.wire_types[{index}].name") + code = _uint(row["code"], f"$wire.wire_types[{index}].code", 255) + _keys(row["payload"], {"frame", "canonical"}, f"$wire.wire_types[{index}].payload") + if name in seen_names or code in seen_codes: + raise SchemaError("$wire.wire_types: duplicate name or code") + seen_names.add(name) + seen_codes.add(code) + if self.wire["wire_types"] != WIRE_TYPE_ROWS: + raise SchemaError("$wire.wire_types: WWAR v1 type table differs") + self.type_codes = {row["name"]: row["code"] for row in self.wire["wire_types"]} + self.type_names = {code: name for name, code in self.type_codes.items()} + _keys( + self.wire["limits"], + { + "container_members_max", + "nesting_depth_max", + "string_or_bytes_length_max", + "uint_max", + "wwar_payload_length_max", + }, + "$wire.limits", + ) + if self.wire["limits"] != WIRE_LIMITS: + raise SchemaError("$wire.limits: WWAR v1 limits differ") + _keys( + self.wire["unicode"], + {"version", "form", "nul_forbidden", "scalar_values_only", "utf8", "validation_order"}, + "$wire.unicode", + ) + if self.wire["unicode"] != WIRE_UNICODE: + raise SchemaError("$wire.unicode: WWAR v1 Unicode rules differ") + if ( + self.wire["unicode"]["nul_forbidden"] is not True + or self.wire["unicode"]["scalar_values_only"] is not True + ): + raise SchemaError("$wire.unicode: canonical flags must be booleans") + if WIRE_UNICODE["version"] != unicodedata.unidata_version: + raise SchemaError( + f"$wire.unicode.version: need {WIRE_UNICODE['version']}, " + f"runtime has {unicodedata.unidata_version}" + ) + if self.wire["error_precedence"] != WIRE_ERROR_PRECEDENCE: + raise SchemaError("$wire.error_precedence: WWAR v1 precedence differs") + + def _validate_records(self) -> None: + data = self.records_data + _keys( + data, + { + "format", + "version", + "scalar_types", + "path_classes", + "enums", + "record_kinds", + "records", + "unions", + "artifact_digest_mapping", + "wrappers", + }, + "$records", + ) + if data["format"] != "wwar-v1-record-schema" or data["version"] != 1: + raise SchemaError("$records: unsupported format/version") + scalar_names: set[str] = set() + for index, scalar in enumerate(_list(data["scalar_types"], "$records.scalar_types")): + where = f"$records.scalar_types[{index}]" + _allowed_keys( + scalar, + {"name", "base", "length", "maximum", "values", "path_class", "nonempty"}, + {"name", "base"}, + where, + ) + name = _name(scalar["name"], where + ".name") + if name in scalar_names: + raise SchemaError(f"{where}: duplicate scalar {name}") + scalar_names.add(name) + if scalar["base"] not in {"bool", "bytes", "string", "uint"}: + raise SchemaError(f"{where}.base: invalid primitive") + if "length" in scalar: + length = _uint(scalar["length"], where + ".length") + if scalar["base"] != "bytes" or length == 0: + raise SchemaError(f"{where}.length: only nonempty byte lengths are supported") + if "maximum" in scalar: + maximum = _uint(scalar["maximum"], where + ".maximum") + if scalar["base"] != "uint" or maximum == 0: + raise SchemaError(f"{where}.maximum: only positive uint maxima are supported") + if "values" in scalar: + values = _list(scalar["values"], where + ".values") + _validate_schema_literal_budget(values, where + ".values") + if not values or len(values) != len({json.dumps(item, sort_keys=True) for item in values}): + raise SchemaError(f"{where}.values: expected nonempty unique values") + for value_index, value in enumerate(values): + value_where = f"{where}.values[{value_index}]" + if scalar["base"] == "string": + _name(value, value_where) if value else _validate_string(value, value_where) + elif scalar["base"] == "uint": + _uint(value, value_where) + elif scalar["base"] == "bool" and not isinstance(value, bool): + raise SchemaError(f"{value_where}: expected bool") + elif scalar["base"] == "bytes": + _hex(value, value_where) + if "nonempty" in scalar and scalar["nonempty"] is not True: + raise SchemaError(f"{where}.nonempty: expected true") + path_names: set[str] = set() + path_allowed = { + "name", + "shape", + "absolute", + "allow_complete_dot", + "allow_dotdot_segments", + "ascii", + "roots", + } + for index, path in enumerate(_list(data["path_classes"], "$records.path_classes")): + where = f"$records.path_classes[{index}]" + _allowed_keys(path, path_allowed, path_allowed - {"roots"}, where) + name = _name(path["name"], where + ".name") + if name in path_names: + raise SchemaError(f"{where}: duplicate path class {name}") + path_names.add(name) + if path["shape"] not in {"path", "single-segment"}: + raise SchemaError(f"{where}.shape: invalid") + if not ( + isinstance(path["absolute"], bool) or path["absolute"] == "either" + ): + raise SchemaError(f"{where}.absolute: invalid") + for flag in ("allow_complete_dot", "allow_dotdot_segments", "ascii"): + if not isinstance(path[flag], bool): + raise SchemaError(f"{where}.{flag}: expected bool") + if "roots" in path: + roots = _list(path["roots"], where + ".roots") + if ( + path["absolute"] is not True + or not roots + or len(roots) != len(set(roots)) + or not all( + isinstance(root, str) + and root.startswith("/") + and len(root.encode("utf-8")) <= 255 + and unicodedata.normalize("NFC", root) == root + and "//" not in root + and "\x00" not in root + for root in roots + ) + ): + raise SchemaError(f"{where}.roots: invalid virtual roots") + for scalar in data["scalar_types"]: + if "path_class" in scalar and scalar["path_class"] not in path_names: + raise SchemaError(f"$records.scalar_types[{scalar['name']}]: unknown path class") + + enum_names: set[str] = set() + for index, enum in enumerate(_list(data["enums"], "$records.enums")): + where = f"$records.enums[{index}]" + _keys(enum, {"name", "values"}, where) + name = _name(enum["name"], where + ".name") + if name in enum_names: + raise SchemaError(f"{where}: duplicate enum {name}") + enum_names.add(name) + names: set[str] = set() + values: set[int] = set() + previous = -1 + for value_index, value in enumerate(_list(enum["values"], where + ".values")): + value_where = f"{where}.values[{value_index}]" + _keys(value, {"name", "value"}, value_where) + value_name = _name(value["name"], value_where + ".name") + number = _uint(value["value"], value_where + ".value") + if value_name in names or number in values: + raise SchemaError(f"{value_where}: duplicate enum name/value") + if number <= previous: + raise SchemaError(f"{value_where}: enum values must increase") + previous = number + names.add(value_name) + values.add(number) + + record_names: set[str] = set() + for index, record in enumerate(_list(data["records"], "$records.records")): + where = f"$records.records[{index}]" + _keys(record, {"name", "top_level_kind", "fields"}, where) + name = _name(record["name"], where + ".name") + if name in record_names: + raise SchemaError(f"{where}: duplicate record {name}") + record_names.add(name) + if record["top_level_kind"] is not None: + _uint(record["top_level_kind"], where + ".top_level_kind", 0xFFFFFFFF) + previous = 0 + field_names: set[str] = set() + for field_index, field in enumerate(_list(record["fields"], where + ".fields")): + field_where = f"{where}.fields[{field_index}]" + _keys( + field, + {"tag", "name", "type", "cardinality", "encoded_default", "order", "order_by"}, + field_where, + ) + tag = _uint(field["tag"], field_where + ".tag", 0xFFFFFFFF) + field_name = _name(field["name"], field_where + ".name") + if tag <= previous or field_name in field_names: + raise SchemaError(f"{field_where}: tags must increase and names be unique") + previous = tag + field_names.add(field_name) + if field["cardinality"] not in {"0/1", "1", "*", "map"}: + raise SchemaError(f"{field_where}.cardinality: invalid") + if field["order"] not in {"none", "ordered", "sorted", "raw-utf8"}: + raise SchemaError(f"{field_where}.order: invalid") + if not isinstance(field["order_by"], list) or not all( + isinstance(item, str) and item for item in field["order_by"] + ): + raise SchemaError(f"{field_where}.order_by: invalid") + self.records = {row["name"]: row for row in data["records"]} + self.enums = {row["name"]: row for row in data["enums"]} + self.scalars = {row["name"]: row for row in data["scalar_types"]} + self.paths = {row["name"]: row for row in data["path_classes"]} + for record_index, record in enumerate(data["records"]): + for field_index, field in enumerate(record["fields"]): + where = f"$records.records[{record_index}].fields[{field_index}]" + self._validate_type(field["type"], where + ".type") + self._validate_order_spec(field, where) + if field["encoded_default"] is not None: + _validate_schema_literal_budget( + field["encoded_default"], where + ".encoded_default" + ) + self._validate_semantic_value( + field["type"], + field["encoded_default"], + where + ".encoded_default", + allow_empty_record=field["cardinality"] == "0/1", + allow_empty_scalar=field["cardinality"] == "0/1", + ) + + kind_numbers: set[int] = set() + kind_records: set[str] = set() + previous_kind = 0 + for index, row in enumerate(_list(data["record_kinds"], "$records.record_kinds")): + where = f"$records.record_kinds[{index}]" + _keys(row, {"kind", "name", "schema"}, where) + kind = _uint(row["kind"], where + ".kind", 0xFFFFFFFF) + name = _name(row["name"], where + ".name") + schema = _uint(row["schema"], where + ".schema", 0xFFFFFFFF) + if kind <= previous_kind or kind in kind_numbers or name in kind_records: + raise SchemaError(f"{where}: kinds must increase and be unique") + previous_kind = kind + kind_numbers.add(kind) + kind_records.add(name) + if name not in self.records or self.records[name]["top_level_kind"] != kind or schema != 1: + raise SchemaError(f"{where}: kind/record/schema mismatch") + for record in data["records"]: + if record["top_level_kind"] is not None and record["name"] not in kind_records: + raise SchemaError(f"$records.records[{record['name']}]: missing record-kind row") + self.kinds = {row["kind"]: row for row in data["record_kinds"]} + + union_names: set[str] = set() + union_records: set[str] = set() + for index, union in enumerate(_list(data["unions"], "$records.unions")): + where = f"$records.unions[{index}]" + _keys(union, {"name", "record", "discriminator", "cases"}, where) + union_name = _name(union["name"], where + ".name") + record_name = _name(union["record"], where + ".record") + discriminator = _name(union["discriminator"], where + ".discriminator") + if union_name in union_names or record_name in union_records or record_name not in self.records: + raise SchemaError(f"{where}: duplicate or unknown union record") + union_names.add(union_name) + union_records.add(record_name) + fields = {field["name"]: field for field in self.records[record_name]["fields"]} + if discriminator not in fields or fields[discriminator]["type"].get("kind") != "enum": + raise SchemaError(f"{where}: discriminator is not an enum field") + enum = self.enums[fields[discriminator]["type"]["name"]] + enum_members = {row["name"] for row in enum["values"]} + cases: set[str] = set() + for case_index, case in enumerate(_list(union["cases"], where + ".cases")): + case_where = f"{where}.cases[{case_index}]" + _keys(case, {"value", "required", "allowed", "nonempty", "empty"}, case_where) + value = _name(case["value"], case_where + ".value") + if value in cases or value not in enum_members: + raise SchemaError(f"{case_where}: duplicate or unknown discriminator value") + cases.add(value) + groups: dict[str, set[str]] = {} + for group in ("required", "allowed", "nonempty", "empty"): + values = _list(case[group], case_where + "." + group) + if not all(isinstance(item, str) and item in fields for item in values): + raise SchemaError(f"{case_where}.{group}: unknown field") + if len(values) != len(set(values)): + raise SchemaError(f"{case_where}.{group}: duplicate field") + groups[group] = set(values) + if groups["allowed"] & groups["empty"]: + raise SchemaError(f"{case_where}: allowed/empty fields must be disjoint") + if groups["allowed"] | groups["empty"] != set(fields): + raise SchemaError(f"{case_where}: allowed/empty fields do not partition record") + if not groups["required"] <= groups["allowed"]: + raise SchemaError(f"{case_where}: required field not allowed") + if not groups["nonempty"] <= groups["required"]: + raise SchemaError(f"{case_where}: nonempty field must be required") + if discriminator not in groups["required"]: + raise SchemaError(f"{case_where}: discriminator must be required") + for field_name in set(fields) - groups["required"]: + if fields[field_name]["encoded_default"] is None: + raise SchemaError( + f"{case_where}: non-required field {field_name!r} needs a default" + ) + for field_name in groups["empty"]: + default = fields[field_name]["encoded_default"] + if default is None or not _is_empty(default): + raise SchemaError( + f"{case_where}: inactive field {field_name!r} needs an empty default" + ) + if cases != enum_members: + raise SchemaError(f"{where}: union cases do not cover discriminator enum") + self.unions = {row["record"]: row for row in data["unions"]} + + mapped_artifacts: set[str] = set() + for index, row in enumerate( + _list(data["artifact_digest_mapping"], "$records.artifact_digest_mapping") + ): + where = f"$records.artifact_digest_mapping[{index}]" + _keys(row, {"artifact_kind", "domain", "record_kind", "record_schema"}, where) + artifact = _name(row["artifact_kind"], where + ".artifact_kind") + if artifact in mapped_artifacts: + raise SchemaError(f"{where}: duplicate artifact kind") + mapped_artifacts.add(artifact) + if row["domain"] not in {"blob", "record"}: + raise SchemaError(f"{where}.domain: invalid") + kind = _uint(row["record_kind"], where + ".record_kind", 0xFFFFFFFF) + schema = _uint(row["record_schema"], where + ".record_schema", 0xFFFFFFFF) + if row["domain"] == "blob" and (kind, schema) != (0, 0): + raise SchemaError(f"{where}: blob mapping must use kind/schema zero") + if row["domain"] == "record" and (kind not in kind_numbers or schema != 1): + raise SchemaError(f"{where}: unknown record identity") + if mapped_artifacts and not any( + {value["name"] for value in enum["values"]} == mapped_artifacts + for enum in data["enums"] + ): + raise SchemaError("$records.artifact_digest_mapping: no matching closed enum") + + wrapper_names: set[str] = set() + for index, row in enumerate(_list(data["wrappers"], "$records.wrappers")): + where = f"$records.wrappers[{index}]" + _allowed_keys( + row, + {"name", "magic_hex", "framing", "trailing_bytes", "body_record", "identity"}, + {"name", "magic_hex", "body_record", "identity"}, + where, + ) + name = _name(row["name"], where + ".name") + if name in wrapper_names or row["body_record"] not in self.records: + raise SchemaError(f"{where}: duplicate wrapper or unknown body record") + wrapper_names.add(name) + magic = _hex(row["magic_hex"], where + ".magic_hex") + identity = row["identity"] + kind = self.records[row["body_record"]]["top_level_kind"] + if kind is None: + raise SchemaError(f"{where}.body_record: wrapper body needs a record kind") + expected_identity = f"record_id({kind},1,body)" + if "framing" in row: + expected_identity += ( + "; the exact eight-byte magic is verified and reconstructed framing " + "and is not a second identity" + ) + if identity != expected_identity: + raise SchemaError(f"{where}.identity: wrapper identity differs") + if "trailing_bytes" in row and row["trailing_bytes"] != "reject": + raise SchemaError(f"{where}.trailing_bytes: only reject is supported") + if "framing" in row: + frames = _list(row["framing"], where + ".framing") + if not frames: + raise SchemaError(f"{where}.framing: expected at least one frame") + for frame_index, frame in enumerate(frames): + _allowed_keys( + frame, + {"offset", "length", "value_hex", "encoding"}, + {"offset", "length"}, + f"{where}.framing[{frame_index}]", + ) + frame_where = f"{where}.framing[{frame_index}]" + _uint(frame["offset"], frame_where + ".offset") + length = frame["length"] + if length != "to EOF": + _uint(length, frame_where + ".length") + has_value = "value_hex" in frame + has_encoding = "encoding" in frame + if has_value == has_encoding: + raise SchemaError(f"{frame_where}: need exactly one value or encoding") + if has_value: + raw = _hex(frame["value_hex"], frame_where + ".value_hex") + if not isinstance(length, int) or len(raw) != length: + raise SchemaError(f"{frame_where}: literal length mismatch") + else: + encoding = frame["encoding"] + if ( + not isinstance(encoding, str) + or not encoding + or len(encoding.encode("utf-8")) > 512 + or unicodedata.normalize("NFC", encoding) != encoding + ): + raise SchemaError(f"{frame_where}.encoding: invalid") + expected_frames = [ + {"offset": 0, "length": len(magic), "value_hex": magic.hex()}, + { + "offset": len(magic), + "length": "to EOF", + "encoding": f"one complete WWAR version-1 {row['body_record']} envelope", + }, + ] + if frames != expected_frames or row.get("trailing_bytes") != "reject": + raise SchemaError(f"{where}.framing: wrapper framing differs") + elif magic or "trailing_bytes" in row: + raise SchemaError(f"{where}: magic wrappers require explicit framing") + self.wrappers = {row["name"]: row for row in data["wrappers"]} + + def _validate_type(self, value: Any, where: str) -> None: + if not isinstance(value, dict) or "kind" not in value: + raise SchemaError(f"{where}: invalid type") + kind = value["kind"] + if kind in {"bool", "bytes", "string", "uint"}: + _allowed_keys(value, {"kind", "scalar"}, {"kind"}, where) + if "scalar" in value: + scalar = value["scalar"] + if scalar not in self.scalars or self.scalars[scalar]["base"] != kind: + raise SchemaError(f"{where}: scalar base mismatch") + elif kind in {"enum", "record"}: + _keys(value, {"kind", "name"}, where) + catalog = self.enums if kind == "enum" else self.records + if value["name"] not in catalog: + raise SchemaError(f"{where}: unknown {kind} {value['name']!r}") + elif kind == "list": + _keys(value, {"kind", "item"}, where) + self._validate_type(value["item"], where + ".item") + elif kind == "map": + _keys(value, {"kind", "value"}, where) + self._validate_type(value["value"], where + ".value") + else: + raise SchemaError(f"{where}: unknown type kind {kind!r}") + + def _validate_order_spec(self, field: dict[str, Any], where: str) -> None: + order = field["order"] + order_by = field["order_by"] + type_spec = field["type"] + kind = type_spec["kind"] + cardinality = field["cardinality"] + if kind == "list": + if cardinality != "*" or order not in {"ordered", "sorted"}: + raise SchemaError(f"{where}: lists require * and ordered/sorted") + elif kind == "map": + if cardinality != "map" or order != "raw-utf8": + raise SchemaError(f"{where}: maps require map and raw-utf8") + elif cardinality not in {"0/1", "1"} or order != "none": + raise SchemaError(f"{where}: scalar/enum/record fields require 0/1 or 1 and none") + if order == "none": + if order_by: + raise SchemaError(f"{where}.order_by: none fields cannot have keys") + return + if order == "ordered": + if order_by: + raise SchemaError(f"{where}.order_by: ordered fields cannot have keys") + return + if order == "raw-utf8": + if type_spec["kind"] != "map" or order_by != ["key"]: + raise SchemaError(f"{where}: raw-utf8 requires a map and the key descriptor") + return + if order != "sorted" or type_spec["kind"] != "list" or not order_by: + raise SchemaError(f"{where}: sorted order requires a keyed list") + for index, path in enumerate(order_by): + current = type_spec["item"] + if path != "value": + for component in path.split("."): + if current["kind"] != "record" or component == "": + raise SchemaError(f"{where}.order_by[{index}]: invalid field path") + fields = { + child["name"]: child for child in self.records[current["name"]]["fields"] + } + if component not in fields: + raise SchemaError(f"{where}.order_by[{index}]: unknown field path") + current = fields[component]["type"] + + def _validate_semantic_value( + self, + type_spec: dict[str, Any], + value: Any, + where: str, + allow_empty_record: bool = False, + allow_empty_scalar: bool = False, + ) -> None: + kind = type_spec["kind"] + if kind == "bool": + if not isinstance(value, bool): + raise SchemaError(f"{where}: expected bool") + elif kind == "bytes": + raw = _hex(value, where) + self._validate_scalar(type_spec, value, raw, where, allow_empty_scalar) + elif kind == "string": + if not isinstance(value, str) or "\x00" in value or unicodedata.normalize("NFC", value) != value: + raise SchemaError(f"{where}: expected NFC string without NUL") + self._validate_scalar(type_spec, value, value, where, allow_empty_scalar) + elif kind == "uint": + number = _uint(value, where) + self._validate_scalar(type_spec, value, number, where, allow_empty_scalar) + elif kind == "enum": + if not isinstance(value, str) or value not in { + row["name"] for row in self.enums[type_spec["name"]]["values"] + }: + raise SchemaError(f"{where}: unknown enum value") + elif kind == "record": + if not isinstance(value, dict): + raise SchemaError(f"{where}: expected record object") + if not value and allow_empty_record: + return + record = self.records[type_spec["name"]] + fields = {field["name"]: field for field in record["fields"]} + if set(value) != set(fields): + raise SchemaError(f"{where}: record default must name every encoded field") + for name, field in fields.items(): + self._validate_semantic_value( + field["type"], + value[name], + where + "." + name, + allow_empty_record=field["cardinality"] == "0/1", + allow_empty_scalar=field["cardinality"] == "0/1", + ) + elif kind == "list": + for index, child in enumerate(_list(value, where)): + self._validate_semantic_value(type_spec["item"], child, f"{where}[{index}]", True) + elif kind == "map": + if not isinstance(value, dict): + raise SchemaError(f"{where}: expected map object") + for key, child in value.items(): + if not isinstance(key, str) or "\x00" in key or unicodedata.normalize("NFC", key) != key: + raise SchemaError(f"{where}: invalid map key") + self._validate_semantic_value(type_spec["value"], child, where + "." + key, True) + + def _validate_scalar( + self, + type_spec: dict[str, Any], + original: Any, + normalized: Any, + where: str, + allow_empty: bool = False, + ) -> None: + scalar_name = type_spec.get("scalar") + if not scalar_name: + return + scalar = self.scalars[scalar_name] + if allow_empty and _is_empty(original): + return + if "length" in scalar and len(normalized) != scalar["length"]: + raise SchemaError(f"{where}: {scalar_name} must have length {scalar['length']}") + if "maximum" in scalar and normalized > int(scalar["maximum"]): + raise SchemaError(f"{where}: {scalar_name} exceeds maximum") + if "values" in scalar and original not in scalar["values"]: + raise SchemaError(f"{where}: {scalar_name} is not a closed value") + if scalar.get("nonempty") and not original: + raise SchemaError(f"{where}: {scalar_name} must be nonempty") + if "path_class" in scalar: + self._validate_path(original, self.paths[scalar["path_class"]], where) + + def _validate_path(self, value: str, spec: dict[str, Any], where: str) -> None: + if not isinstance(value, str) or "\\" in value or "\x00" in value: + raise SchemaError(f"{where}: invalid logical path") + if spec["ascii"] and not value.isascii(): + raise SchemaError(f"{where}: path must be ASCII") + if value == "." and spec["allow_complete_dot"]: + return + absolute = value.startswith("/") + if spec["absolute"] is True and not absolute: + raise SchemaError(f"{where}: path must be absolute") + if spec["absolute"] is False and absolute: + raise SchemaError(f"{where}: path must be relative") + parts = value[1:].split("/") if absolute else value.split("/") + if spec["shape"] == "single-segment" and len(parts) != 1: + raise SchemaError(f"{where}: expected one path segment") + if any(not part or part == "." for part in parts): + raise SchemaError(f"{where}: empty or dot segment") + if not spec["allow_dotdot_segments"] and ".." in parts: + raise SchemaError(f"{where}: dot-dot segment") + if "roots" in spec and not any(value == root or value.startswith(root + "/") for root in spec["roots"]): + raise SchemaError(f"{where}: path outside virtual roots") + + def _validate_digests(self) -> None: + data = self.digests_data + _keys(data, {"format", "version", "domains"}, "$digests") + if data["format"] != "wwar-v1-digest-schema" or data["version"] != 1: + raise SchemaError("$digests: unsupported format/version") + names: set[str] = set() + separators: set[bytes] = set() + for index, domain in enumerate(_list(data["domains"], "$digests.domains")): + where = f"$digests.domains[{index}]" + _allowed_keys( + domain, + {"name", "algorithm", "separator_utf8_hex", "input", "entry_encoding", "formula", "result"}, + {"name", "algorithm", "separator_utf8_hex", "input", "formula", "result"}, + where, + ) + name = _name(domain["name"], where + ".name") + separator = _hex(domain["separator_utf8_hex"], where + ".separator_utf8_hex") + if name in names or separator in separators: + raise SchemaError(f"{where}: duplicate digest name or separator") + names.add(name) + separators.add(separator) + if domain["algorithm"] != "sha256" or not separator.endswith(b"\x00"): + raise SchemaError(f"{where}: unsupported algorithm or unterminated separator") + if len(separator) > 255: + raise SchemaError(f"{where}.separator_utf8_hex: separator is too long") + if separator.count(b"\x00") != 1: + raise SchemaError(f"{where}.separator_utf8_hex: expected one terminal NUL") + try: + separator_text = separator[:-1].decode("utf-8") + except UnicodeDecodeError as exc: + raise SchemaError(f"{where}.separator_utf8_hex: invalid UTF-8") from exc + if ( + not separator_text + or unicodedata.normalize("NFC", separator_text) != separator_text + ): + raise SchemaError(f"{where}.separator_utf8_hex: expected nonempty NFC UTF-8") + formula = tuple(_list(domain["formula"], where + ".formula")) + source_tree = "entry_encoding" in domain + if formula == FORMULA_BYTES: + _keys(domain["input"], {"kind"}, where + ".input") + if domain["input"]["kind"] != "bytes" or source_tree: + raise SchemaError(f"{where}: invalid bytes formula input") + elif formula == FORMULA_WWAR: + _keys(domain["input"], {"record", "encoding"}, where + ".input") + if domain["input"]["record"] not in self.records or domain["input"]["encoding"] != "WWAR" or source_tree: + raise SchemaError(f"{where}: invalid WWAR formula input") + elif formula == FORMULA_RECORD: + _keys(domain["input"], {"record", "encoding"}, where + ".input") + if domain["input"] != {"record": "top-level record", "encoding": "WWAR"} or source_tree: + raise SchemaError(f"{where}: invalid record formula input") + elif formula == FORMULA_SOURCE_TREE: + _keys(domain["input"], {"record", "encoding"}, where + ".input") + if domain["input"]["record"] not in self.records or domain["input"]["encoding"] != "special-source-tree-v1" or not source_tree: + raise SchemaError(f"{where}: invalid source-tree formula input") + self._validate_source_tree_shape(domain["entry_encoding"], where + ".entry_encoding") + else: + raise SchemaError(f"{where}.formula: unknown finite formula") + self._validate_digest_result(domain, where + ".result") + self.domains = {row["name"]: row for row in data["domains"]} + + def _validate_source_tree_shape(self, value: Any, where: str) -> None: + _keys(value, {"path", "type", "executable", "content", "order"}, where) + if value["path"] != ["u64be-byte-length", "raw-nfc-utf8"]: + raise SchemaError(f"{where}.path: unsupported") + if value["type"] != {"dir": 1, "file": 2}: + raise SchemaError(f"{where}.type: unsupported") + if value["executable"] != {"false": 0, "true": 1, "directory": 0}: + raise SchemaError(f"{where}.executable: unsupported") + if value["content"] != {"dir": ["u64be", 0], "file": ["u64be", 32, "raw-sha256"]}: + raise SchemaError(f"{where}.content: unsupported") + if value["order"] != "raw-utf8-path-bytes": + raise SchemaError(f"{where}.order: unsupported") + + def _validate_digest_result(self, domain: dict[str, Any], where: str) -> None: + value = domain["result"] + if not isinstance(value, dict): + raise SchemaError(f"{where}: expected object") + if "kind" in value: + if value.get("kind") != "bytes": + raise SchemaError(f"{where}.kind: digest results are bytes") + if set(value) == {"kind", "length"}: + if value["length"] != 32: + raise SchemaError(f"{where}.length: SHA-256 is 32 bytes") + return + if set(value) == {"kind", "scalar"}: + scalar = self.scalars.get(value["scalar"]) + if scalar is None or scalar["base"] != "bytes" or scalar.get("length") != 32: + raise SchemaError(f"{where}.scalar: expected a 32-byte scalar") + return + raise SchemaError(f"{where}: invalid byte-result shape") + _keys(value, {"record", "domain", "record-kind", "record-schema"}, where) + if value["record"] not in self.records: + raise SchemaError(f"{where}.record: unknown result record") + if value["domain"] != domain["name"]: + raise SchemaError(f"{where}.domain: result domain differs from digest domain") + union = self.unions.get(value["record"]) + if union is None or value["domain"] not in { + case["value"] for case in union["cases"] + }: + raise SchemaError(f"{where}.record: result is not the matching typed union") + if value["domain"] == "blob": + _uint(value["record-kind"], where + ".record-kind") + _uint(value["record-schema"], where + ".record-schema") + if (value["record-kind"], value["record-schema"]) != (0, 0): + raise SchemaError(f"{where}: blob identity must use kind/schema zero") + elif value["domain"] == "record": + _uint(value["record-schema"], where + ".record-schema") + if value["record-kind"] != "1..22" or value["record-schema"] != 1: + raise SchemaError(f"{where}: record identity range differs") + else: + raise SchemaError(f"{where}.domain: invalid typed digest domain") + + def generated_table(self) -> dict[str, Any]: + """Compile descriptive schemas into compact positional codec lookup tables.""" + return { + "format": TABLE_FORMAT, + "version": 1, + "schema_digest": self.schema_digest, + "schema_files": self.file_hashes, + "wire": { + "magic": self.wire["magic_hex"], + "schema": self.wire["schema_version"], + "types": [ + [row["code"], row["name"]] for row in self.wire["wire_types"] + ], + "limits": [ + self.wire["limits"]["container_members_max"], + self.wire["limits"]["nesting_depth_max"], + self.wire["limits"]["string_or_bytes_length_max"], + self.wire["limits"]["uint_max"], + self.wire["limits"]["wwar_payload_length_max"], + ], + "unicode": [ + self.wire["unicode"]["version"], + self.wire["unicode"]["form"], + self.wire["unicode"]["nul_forbidden"], + self.wire["unicode"]["scalar_values_only"], + ], + }, + "scalars": { + row["name"]: [ + row["base"], + row.get("length"), + row.get("maximum"), + row.get("values"), + row.get("path_class"), + row.get("nonempty"), + ] + for row in self.records_data["scalar_types"] + }, + "paths": { + row["name"]: [ + row["shape"], + row["absolute"], + row["allow_complete_dot"], + row["allow_dotdot_segments"], + row["ascii"], + row.get("roots"), + ] + for row in self.records_data["path_classes"] + }, + "enums": { + row["name"]: [[item["value"], item["name"]] for item in row["values"]] + for row in self.records_data["enums"] + }, + "records": { + row["name"]: [ + row["top_level_kind"], + [ + [ + field["tag"], + field["name"], + _compiled_type(field["type"]), + field["cardinality"], + field["encoded_default"], + field["order"], + field["order_by"], + ] + for field in row["fields"] + ], + ] + for row in self.records_data["records"] + }, + "unions": { + row["record"]: [ + row["discriminator"], + { + case["value"]: [ + case["required"], + case["allowed"], + case["nonempty"], + case["empty"], + ] + for case in row["cases"] + }, + ] + for row in self.records_data["unions"] + }, + "kinds": { + str(row["kind"]): [row["name"], row["schema"]] + for row in self.records_data["record_kinds"] + }, + "artifacts": { + row["artifact_kind"]: [ + row["domain"], + row["record_kind"], + row["record_schema"], + ] + for row in self.records_data["artifact_digest_mapping"] + }, + "wrappers": { + row["name"]: [row["magic_hex"], row["body_record"]] + for row in self.records_data["wrappers"] + }, + "digests": { + row["name"]: [ + row["algorithm"], + row["separator_utf8_hex"], + row["input"], + row["formula"], + row.get("entry_encoding"), + ] + for row in self.digests_data["domains"] + }, + } + + def _materialize_record(self, name: str, value: Any, path: str) -> dict[str, Any]: + if name not in self.records or not isinstance(value, dict): + raise ProtocolError("CONSTRAINT_VIOLATION", path, "expected declared record object") + record = self.records[name] + fields = {field["name"]: field for field in record["fields"]} + unknown = sorted(set(value) - set(fields)) + if unknown: + raise ProtocolError("UNKNOWN_FIELD", path + "." + unknown[0]) + result: dict[str, Any] = {} + for field in record["fields"]: + field_name = field["name"] + if field_name in value: + result[field_name] = copy.deepcopy(value[field_name]) + elif field["encoded_default"] is not None: + result[field_name] = copy.deepcopy(field["encoded_default"]) + else: + raise ProtocolError("MISSING_FIELD", path + "." + field_name) + union = self.unions.get(name) + if union: + self._validate_union(union, result, path) + return result + + def _validate_union(self, union: dict[str, Any], value: dict[str, Any], path: str) -> None: + discriminator = union["discriminator"] + selected = value[discriminator] + case = next((row for row in union["cases"] if row["value"] == selected), None) + if case is None: + raise ProtocolError("INVALID_UNION", path + "." + discriminator) + for field_name in case["nonempty"]: + if _is_empty(value[field_name]): + raise ProtocolError("INVALID_UNION", path + "." + field_name) + for field_name in case["empty"]: + if not _is_empty(value[field_name]): + raise ProtocolError("INVALID_UNION", path + "." + field_name) + + def _order_component( + self, value: Any, type_spec: dict[str, Any], field_path: str, path: str + ) -> tuple[Any, dict[str, Any]]: + if field_path == "value": + return value, type_spec + current_value = value + current_type = type_spec + for component in field_path.split("."): + if current_type["kind"] != "record": + raise ProtocolError("CONSTRAINT_VIOLATION", path, "order path is not a record") + current_value = self._materialize_record( + current_type["name"], current_value, path + ) + fields = { + field["name"]: field for field in self.records[current_type["name"]]["fields"] + } + field = fields[component] + current_value = current_value[component] + current_type = field["type"] + return current_value, current_type + + def _canonical_order_key( + self, value: Any, type_spec: dict[str, Any], path: str + ) -> tuple[Any, ...]: + kind = type_spec["kind"] + if kind == "string": + return (0, value.encode("utf-8")) + if kind == "bytes": + return (1, bytes.fromhex(value)) + if kind == "uint": + return (2, int(value)) + if kind == "enum": + member = next( + row for row in self.enums[type_spec["name"]]["values"] if row["name"] == value + ) + return (2, member["value"]) + if kind == "bool": + return (3, int(value)) + if kind == "list": + return ( + 4, + tuple( + self._canonical_order_key(child, type_spec["item"], f"{path}[{index}]") + for index, child in enumerate(value) + ), + ) + if kind == "map": + return ( + 5, + tuple( + ( + key.encode("utf-8"), + self._canonical_order_key(value[key], type_spec["value"], path + "." + key), + ) + for key in sorted(value, key=lambda item: item.encode("utf-8")) + ), + ) + if kind == "record": + return (6, self.encode_record(type_spec["name"], value)) + raise ProtocolError("CONSTRAINT_VIOLATION", path, "unknown order-key type") + + def _validate_field_order( + self, field: dict[str, Any], value: Any, path: str + ) -> None: + if field["order"] != "sorted": + return + keys = [] + for index, item in enumerate(value): + components = [] + for field_path in field["order_by"]: + component, component_type = self._order_component( + item, field["type"]["item"], field_path, f"{path}[{index}]" + ) + components.append( + self._canonical_order_key( + component, component_type, f"{path}[{index}].{field_path}" + ) + ) + keys.append(tuple(components)) + for index, (left, right) in enumerate(zip(keys, keys[1:]), 1): + if right <= left: + raise ProtocolError("CONSTRAINT_VIOLATION", f"{path}[{index}]", "list order") + + def conformance_sample(self, name: str, union_case: str | None = None) -> dict[str, Any]: + """Construct one generic valid value for codec coverage, never build policy.""" + return self._sample_record(name, (), union_case) + + def _sample_type(self, type_spec: dict[str, Any], stack: tuple[str, ...]) -> Any: + kind = type_spec["kind"] + scalar = self.scalars.get(type_spec.get("scalar", ""), {}) + if kind == "bool": + return False + if kind == "bytes": + return "00" * scalar.get("length", 0) + if kind == "string": + if scalar.get("values"): + return scalar["values"][0] + if scalar.get("path_class"): + path = self.paths[scalar["path_class"]] + if path["allow_complete_dot"]: + return "." + if path["absolute"] is True: + return path.get("roots", ["/x"])[0] + return "x" + return "x" if scalar.get("nonempty") else "" + if kind == "uint": + return scalar.get("values", [0])[0] + if kind == "enum": + return self.enums[type_spec["name"]]["values"][0]["name"] + if kind == "record": + return self._sample_record(type_spec["name"], stack) + if kind == "list": + return [] + if kind == "map": + return {} + raise SchemaError(f"unknown sample type {kind!r}") + + def _nonempty_sample(self, type_spec: dict[str, Any], stack: tuple[str, ...]) -> Any: + kind = type_spec["kind"] + if kind == "bool": + return True + if kind == "bytes": + scalar = self.scalars.get(type_spec.get("scalar", ""), {}) + return "00" * scalar.get("length", 1) + if kind == "string": + return self._sample_type(type_spec, stack) or "x" + if kind == "uint": + return 1 + if kind == "enum": + return self._sample_type(type_spec, stack) + if kind == "record": + name = type_spec["name"] + if name in stack: + union = self.unions.get(name) + if union is None: + raise SchemaError(f"required recursive sample for {name}") + record = self.records[name] + fields = {field["name"]: field for field in record["fields"]} + + def recursive(spec: dict[str, Any]) -> bool: + if spec["kind"] == "record": + return spec["name"] == name + if spec["kind"] == "list": + return recursive(spec["item"]) + if spec["kind"] == "map": + return recursive(spec["value"]) + return False + + case = next( + ( + row + for row in union["cases"] + if not any(recursive(fields[field]["type"]) for field in row["nonempty"]) + ), + None, + ) + if case is None: + raise SchemaError(f"no finite recursive sample for {name}") + return self._sample_record(name, (), case["value"]) + return self._sample_record(name, stack) + if kind == "list": + return [self._nonempty_sample(type_spec["item"], stack)] + if kind == "map": + return {"x": self._nonempty_sample(type_spec["value"], stack)} + raise SchemaError(f"unknown nonempty sample type {kind!r}") + + def _sample_record( + self, name: str, stack: tuple[str, ...], union_case: str | None = None + ) -> dict[str, Any]: + if name in stack: + raise SchemaError(f"required record recursion: {' -> '.join(stack + (name,))}") + record = self.records.get(name) + if record is None: + raise SchemaError(f"unknown sample record {name!r}") + value: dict[str, Any] = {} + for field in record["fields"]: + default = field["encoded_default"] + value[field["name"]] = ( + copy.deepcopy(default) + if default is not None + else self._sample_type(field["type"], stack + (name,)) + ) + union = self.unions.get(name) + if union: + selected = union_case or union["cases"][0]["value"] + case = next((row for row in union["cases"] if row["value"] == selected), None) + if case is None: + raise SchemaError(f"unknown sample union case {name}.{selected}") + value[union["discriminator"]] = selected + fields = {field["name"]: field for field in record["fields"]} + for field_name in case["empty"]: + default = fields[field_name]["encoded_default"] + if default is None: + default = { + "bool": False, + "bytes": "", + "string": "", + "uint": 0, + "list": [], + "map": {}, + "record": {}, + }[fields[field_name]["type"]["kind"]] + value[field_name] = copy.deepcopy(default) + for field_name in case["nonempty"]: + value[field_name] = self._nonempty_sample( + fields[field_name]["type"], stack + (name,) + ) + return value + + def _semantic_ast( + self, + type_spec: dict[str, Any], + value: Any, + path: str, + cardinality: str = "1", + ) -> dict[str, Any]: + kind = type_spec["kind"] + try: + if kind == "bool": + if not isinstance(value, bool): + raise SchemaError("expected bool") + return {"bool": value} + if kind == "bytes": + raw = _hex(value, path) + self._validate_scalar(type_spec, value, raw, path, cardinality == "0/1") + return {"bytes": value} + if kind == "string": + if not isinstance(value, str) or "\x00" in value or unicodedata.normalize("NFC", value) != value: + raise SchemaError("expected NFC string without NUL") + self._validate_scalar(type_spec, value, value, path, cardinality == "0/1") + return {"string": value} + if kind == "uint": + number = _uint(value, path) + self._validate_scalar(type_spec, value, number, path, cardinality == "0/1") + return {"uint": str(number)} + if kind == "enum": + enum = self.enums[type_spec["name"]] + member = next((row for row in enum["values"] if row["name"] == value), None) + if member is None: + raise ProtocolError("UNKNOWN_ENUM", path) + return {"uint": str(member["value"])} + if kind == "record": + if value == {} and cardinality == "0/1": + return {"record": []} + return self._record_ast(type_spec["name"], value, path) + if kind == "list": + if not isinstance(value, list): + raise SchemaError("expected list") + return { + "list": [ + self._semantic_ast(type_spec["item"], child, f"{path}[{index}]") + for index, child in enumerate(value) + ] + } + if kind == "map": + if not isinstance(value, dict): + raise SchemaError("expected map object") + pairs = [] + for key in sorted(value, key=lambda item: item.encode("utf-8")): + _validate_string(key, path + ".key") + pairs.append([key, self._semantic_ast(type_spec["value"], value[key], path + "." + key)]) + return {"map": pairs} + except SchemaError as exc: + raise ProtocolError("CONSTRAINT_VIOLATION", path, str(exc)) from exc + raise ProtocolError("CONSTRAINT_VIOLATION", path, "unknown field type") + + def _record_ast(self, name: str, value: Any, path: str = "$") -> dict[str, Any]: + materialized = self._materialize_record(name, value, path) + fields = [] + for field in self.records[name]["fields"]: + field_path = path + "." + field["name"] + self._validate_field_order(field, materialized[field["name"]], field_path) + fields.append( + [ + field["tag"], + self._semantic_ast( + field["type"], materialized[field["name"]], field_path, field["cardinality"] + ), + ] + ) + return {"record": fields} + + def encode_record(self, name: str, value: Any) -> bytes: + return encode_envelope(self._record_ast(name, value), self.wire) + + def decode_record(self, name: str, encoded: bytes) -> dict[str, Any]: + ast = decode_envelope(encoded, self.wire) + return self._decode_record_ast(name, ast, "$") + + def _decode_record_ast(self, name: str, ast: Any, path: str) -> dict[str, Any]: + if not isinstance(ast, dict) or set(ast) != {"record"}: + raise ProtocolError("CONSTRAINT_VIOLATION", path, "expected record wire type") + pairs = ast["record"] + fields = self.records[name]["fields"] + known = {field["tag"]: field for field in fields} + actual = {tag for tag, _ in pairs} + for tag, _ in pairs: + if tag not in known: + raise ProtocolError("UNKNOWN_FIELD", path + f".{tag}") + for field in fields: + if field["tag"] not in actual: + raise ProtocolError("MISSING_FIELD", path + "." + field["name"]) + result: dict[str, Any] = {} + for tag, child in pairs: + field = known[tag] + result[field["name"]] = self._decode_semantic_ast( + field["type"], child, path + "." + field["name"], field["cardinality"] + ) + for field in fields: + self._validate_field_order(field, result[field["name"]], path + "." + field["name"]) + union = self.unions.get(name) + if union: + self._validate_union(union, result, path) + return result + + def _decode_semantic_ast( + self, type_spec: dict[str, Any], ast: Any, path: str, cardinality: str = "1" + ) -> Any: + kind = type_spec["kind"] + expected = "uint" if kind == "enum" else kind + if not isinstance(ast, dict) or set(ast) != {expected}: + raise ProtocolError("CONSTRAINT_VIOLATION", path, f"expected {expected} wire type") + value = ast[expected] + try: + if kind == "bool": + return value + if kind == "bytes": + raw = _hex(value, path) + self._validate_scalar(type_spec, value, raw, path, cardinality == "0/1") + return value + if kind == "string": + self._validate_scalar(type_spec, value, value, path, cardinality == "0/1") + return value + if kind == "uint": + number = int(value) + self._validate_scalar(type_spec, number, number, path, cardinality == "0/1") + return number + if kind == "enum": + number = int(value) + member = next( + (row for row in self.enums[type_spec["name"]]["values"] if row["value"] == number), + None, + ) + if member is None: + raise ProtocolError("UNKNOWN_ENUM", path) + return member["name"] + if kind == "record": + if value == [] and cardinality == "0/1": + return {} + return self._decode_record_ast(type_spec["name"], ast, path) + if kind == "list": + return [ + self._decode_semantic_ast(type_spec["item"], child, f"{path}[{index}]") + for index, child in enumerate(value) + ] + if kind == "map": + return { + key: self._decode_semantic_ast(type_spec["value"], child, path + "." + key) + for key, child in value + } + except SchemaError as exc: + raise ProtocolError("CONSTRAINT_VIOLATION", path, str(exc)) from exc + raise ProtocolError("CONSTRAINT_VIOLATION", path, "unknown field type") + + def record_id(self, name: str, kind: int, schema: int, value: Any) -> bytes: + record = self.records.get(name) + kind_row = self.kinds.get(kind) + if ( + record is None + or kind_row is None + or kind_row["name"] != name + or kind_row["schema"] != schema + or record["top_level_kind"] != kind + ): + raise ProtocolError("KIND_SUBSTITUTION", "$.kind") + encoded = self.encode_record(name, value) + domain = self._domain_by_formula(FORMULA_RECORD) + return hashlib.sha256( + bytes.fromhex(domain["separator_utf8_hex"]) + + struct.pack(">I", kind) + + struct.pack(">I", schema) + + struct.pack(">Q", len(encoded)) + + encoded + ).digest() + + def digest(self, domain_name: str, value: Any, record_name: str | None = None, kind: int | None = None, schema: int = 1) -> bytes: + domain = self.domains.get(domain_name) + if domain is None: + raise ProtocolError("CONSTRAINT_VIOLATION", "$.domain", "unknown digest domain") + formula = tuple(domain["formula"]) + separator = bytes.fromhex(domain["separator_utf8_hex"]) + if formula == FORMULA_BYTES: + if not isinstance(value, bytes): + raise ProtocolError("CONSTRAINT_VIOLATION", "$", "bytes digest needs bytes") + preimage = separator + struct.pack(">Q", len(value)) + value + elif formula == FORMULA_WWAR: + expected_record = domain["input"]["record"] + if record_name is not None and record_name != expected_record: + raise ProtocolError("KIND_SUBSTITUTION", "$.record") + encoded = self.encode_record(expected_record, value) + preimage = separator + struct.pack(">Q", len(encoded)) + encoded + elif formula == FORMULA_RECORD: + if record_name is None or kind is None: + raise ProtocolError("CONSTRAINT_VIOLATION", "$", "record digest needs record and kind") + return self.record_id(record_name, kind, schema, value) + elif formula == FORMULA_SOURCE_TREE: + encoded_entries = self._encode_source_tree(value) + preimage = separator + encoded_entries + else: + raise ProtocolError("CONSTRAINT_VIOLATION", "$.domain", "unsupported digest formula") + return hashlib.sha256(preimage).digest() + + def _domain_by_formula(self, formula: tuple[str, ...]) -> dict[str, Any]: + matches = [row for row in self.domains.values() if tuple(row["formula"]) == formula] + if len(matches) != 1: + raise SchemaError(f"expected one domain for formula {formula}") + return matches[0] + + def _encode_source_tree(self, entries: Any) -> bytes: + if not isinstance(entries, list): + raise ProtocolError("CONSTRAINT_VIOLATION", "$", "source tree needs an entry list") + out = bytearray() + previous: bytes | None = None + for index, entry in enumerate(entries): + path = f"$[{index}]" + if not isinstance(entry, dict) or set(entry) != {"path", "type", "executable", "content"}: + raise ProtocolError("CONSTRAINT_VIOLATION", path, "invalid source-tree entry") + name = entry["path"] + try: + _validate_string(name, path + ".path") + self._validate_path(name, { + "ascii": False, + "allow_complete_dot": False, + "shape": "path", + "absolute": False, + "allow_dotdot_segments": False, + }, path + ".path") + except SchemaError as exc: + raise ProtocolError("CONSTRAINT_VIOLATION", path + ".path", str(exc)) from exc + raw_path = name.encode("utf-8") + if previous is not None and raw_path <= previous: + code = "DUPLICATE_MAP_KEY" if raw_path == previous else "MAP_KEY_ORDER" + raise ProtocolError(code, path + ".path") + previous = raw_path + out += struct.pack(">Q", len(raw_path)) + raw_path + if entry["type"] == "dir": + if entry["executable"] is not False or entry["content"] != "": + raise ProtocolError("CONSTRAINT_VIOLATION", path) + out += b"\x01\x00" + struct.pack(">Q", 0) + elif entry["type"] == "file": + if not isinstance(entry["executable"], bool): + raise ProtocolError("CONSTRAINT_VIOLATION", path + ".executable") + try: + content = _hex(entry["content"], path + ".content", 32) + except SchemaError as exc: + raise ProtocolError("CONSTRAINT_VIOLATION", path + ".content", str(exc)) from exc + out += b"\x02" + bytes([int(entry["executable"])]) + struct.pack(">Q", 32) + content + else: + raise ProtocolError("CONSTRAINT_VIOLATION", path + ".type") + return bytes(out) + + def encode_wrapper(self, wrapper_name: str, value: Any) -> bytes: + wrapper = self.wrappers.get(wrapper_name) + if wrapper is None: + raise ProtocolError("CONSTRAINT_VIOLATION", "$.wrapper") + return bytes.fromhex(wrapper["magic_hex"]) + self.encode_record(wrapper["body_record"], value) + + def decode_wrapper(self, wrapper_name: str, encoded: bytes) -> dict[str, Any]: + wrapper = self.wrappers.get(wrapper_name) + if wrapper is None: + raise ProtocolError("CONSTRAINT_VIOLATION", "$.wrapper") + magic = bytes.fromhex(wrapper["magic_hex"]) + if len(encoded) < len(magic): + raise ProtocolError("TRUNCATED") + if encoded[: len(magic)] != magic: + raise ProtocolError("BAD_MAGIC") + return self.decode_record(wrapper["body_record"], encoded[len(magic) :]) + + +def _is_empty(value: Any) -> bool: + return value is False or value == 0 or value == "" or value == [] or value == {} + + +def _validate_string(value: Any, where: str) -> None: + if not isinstance(value, str): + raise SchemaError(f"{where}: expected string") + if "\x00" in value: + raise SchemaError(f"{where}: NUL is forbidden") + if unicodedata.normalize("NFC", value) != value: + raise SchemaError(f"{where}: string is not NFC") + + +def schema_bundle_digest(paths: dict[str, pathlib.Path]) -> str: + hasher = hashlib.sha256() + hasher.update(SCHEMA_DOMAIN) + for name in SCHEMA_FILES: + raw_name = name.encode("utf-8") + raw = paths[name].read_bytes() + hasher.update(struct.pack(">Q", len(raw_name))) + hasher.update(raw_name) + hasher.update(struct.pack(">Q", len(raw))) + hasher.update(raw) + return hasher.hexdigest() + + +def write_schema_manifest(schema_dir: pathlib.Path) -> None: + lines = [] + for name in SCHEMA_FILES: + digest = hashlib.sha256((schema_dir / name).read_bytes()).hexdigest() + lines.append(f"{digest} {name}\n") + (schema_dir / SCHEMA_MANIFEST).write_text("".join(lines), encoding="ascii") + + +def check_schema_manifest(schema_dir: pathlib.Path, expected: dict[str, str] | None = None) -> None: + path = schema_dir / SCHEMA_MANIFEST + try: + lines = path.read_text(encoding="ascii").splitlines() + except (OSError, UnicodeError) as exc: + raise SchemaError(f"cannot read schema manifest: {exc}") from exc + if len(lines) != len(SCHEMA_FILES): + raise SchemaError("schema manifest must contain exactly three lines") + parsed: dict[str, str] = {} + for index, line in enumerate(lines): + parts = line.split(" ") + if len(parts) != 2 or len(parts[0]) != 64 or parts[0].lower() != parts[0]: + raise SchemaError(f"schema manifest line {index + 1} is not canonical") + _hex(parts[0], f"schema manifest line {index + 1}", 32) + if parts[1] in parsed: + raise SchemaError("schema manifest has duplicate file") + parsed[parts[1]] = parts[0] + actual = expected or { + name: hashlib.sha256((schema_dir / name).read_bytes()).hexdigest() for name in SCHEMA_FILES + } + if list(parsed) != list(SCHEMA_FILES) or parsed != actual: + raise SchemaError("schema manifest does not match exact schema bytes") + + +def generate_table(schema_dir: pathlib.Path, output: pathlib.Path) -> bytes: + bundle = SchemaBundle.from_dir(schema_dir) + raw = canonical_json(bundle.generated_table()) + output.parent.mkdir(parents=True, exist_ok=True) + output.write_bytes(raw) + return raw + + +def expected_table(schema_dir: pathlib.Path) -> bytes: + return canonical_json(SchemaBundle.from_dir(schema_dir).generated_table()) + + +def encode_envelope(ast: Any, wire: dict[str, Any]) -> bytes: + payload = _encode_ast(ast, wire, 1, "$") + return bytes.fromhex(wire["magic_hex"]) + struct.pack(">H", wire["schema_version"]) + payload + + +def _encode_ast(ast: Any, wire: dict[str, Any], depth: int, path: str) -> bytes: + if depth > wire["limits"]["nesting_depth_max"]: + raise ProtocolError("LIMIT_EXCEEDED", path) + if not isinstance(ast, dict) or len(ast) != 1: + raise ProtocolError("CONSTRAINT_VIOLATION", path, "value AST needs one type member") + name, value = next(iter(ast.items())) + codes = {row["name"]: row["code"] for row in wire["wire_types"]} + if name not in codes: + raise ProtocolError("UNKNOWN_TYPE", path) + limit = wire["limits"]["string_or_bytes_length_max"] + members_limit = wire["limits"]["container_members_max"] + if name == "bool": + if not isinstance(value, bool): + raise ProtocolError("INVALID_BOOL", path) + payload = bytes([int(value)]) + elif name == "bytes": + try: + payload = _hex(value, path) + except SchemaError as exc: + raise ProtocolError("CONSTRAINT_VIOLATION", path, str(exc)) from exc + if len(payload) > limit: + raise ProtocolError("LIMIT_EXCEEDED", path) + elif name == "string": + try: + _validate_string(value, path) + except SchemaError as exc: + raise ProtocolError("CONSTRAINT_VIOLATION", path, str(exc)) from exc + payload = value.encode("utf-8") + if len(payload) > limit: + raise ProtocolError("LIMIT_EXCEEDED", path) + elif name == "uint": + try: + number = int(value) + except (TypeError, ValueError) as exc: + raise ProtocolError("NONMINIMAL_UINT", path) from exc + if isinstance(value, bool) or number < 0 or number > int(wire["limits"]["uint_max"]): + raise ProtocolError("OVERFLOW", path) + size = max(1, (number.bit_length() + 7) // 8) + payload = number.to_bytes(size, "big") + elif name == "list": + if not isinstance(value, list): + raise ProtocolError("CONSTRAINT_VIOLATION", path) + if len(value) > members_limit: + raise ProtocolError("LIMIT_EXCEEDED", path) + body = bytearray(struct.pack(">I", len(value))) + for index, child in enumerate(value): + encoded = _encode_ast(child, wire, depth + 1, f"{path}[{index}]") + body += struct.pack(">Q", len(encoded)) + encoded + payload = bytes(body) + elif name == "map": + if not isinstance(value, list) or len(value) > members_limit: + raise ProtocolError("LIMIT_EXCEEDED" if isinstance(value, list) else "CONSTRAINT_VIOLATION", path) + body = bytearray(struct.pack(">I", len(value))) + previous: bytes | None = None + for index, pair in enumerate(value): + if not isinstance(pair, list) or len(pair) != 2: + raise ProtocolError("CONSTRAINT_VIOLATION", f"{path}[{index}]") + key, child = pair + try: + _validate_string(key, f"{path}[{index}].key") + except SchemaError as exc: + raise ProtocolError("CONSTRAINT_VIOLATION", f"{path}[{index}].key", str(exc)) from exc + raw_key = key.encode("utf-8") + if len(raw_key) > limit: + raise ProtocolError("LIMIT_EXCEEDED", f"{path}[{index}].key") + if previous is not None and raw_key <= previous: + code = "DUPLICATE_MAP_KEY" if raw_key == previous else "MAP_KEY_ORDER" + raise ProtocolError(code, f"{path}[{index}].key") + previous = raw_key + encoded = _encode_ast(child, wire, depth + 1, f"{path}[{index}]") + body += struct.pack(">Q", len(raw_key)) + raw_key + struct.pack(">Q", len(encoded)) + encoded + payload = bytes(body) + else: + if not isinstance(value, list) or len(value) > members_limit: + raise ProtocolError("LIMIT_EXCEEDED" if isinstance(value, list) else "CONSTRAINT_VIOLATION", path) + body = bytearray(struct.pack(">I", len(value))) + previous = 0 + for index, pair in enumerate(value): + if not isinstance(pair, list) or len(pair) != 2: + raise ProtocolError("CONSTRAINT_VIOLATION", f"{path}.{index}") + tag, child = pair + if isinstance(tag, bool) or not isinstance(tag, int) or tag <= previous or tag > 0xFFFFFFFF: + raise ProtocolError("FIELD_ORDER", f"{path}.{tag}") + previous = tag + encoded = _encode_ast(child, wire, depth + 1, f"{path}.{tag}") + body += struct.pack(">I", tag) + struct.pack(">Q", len(encoded)) + encoded + payload = bytes(body) + return bytes([codes[name]]) + struct.pack(">Q", len(payload)) + payload + + +def decode_envelope(encoded: bytes, wire: dict[str, Any]) -> dict[str, Any]: + magic = bytes.fromhex(wire["magic_hex"]) + if len(encoded) < len(magic): + raise ProtocolError("TRUNCATED") + if encoded[: len(magic)] != magic: + raise ProtocolError("BAD_MAGIC") + if len(encoded) < len(magic) + 2: + raise ProtocolError("TRUNCATED") + version = struct.unpack_from(">H", encoded, len(magic))[0] + if version != wire["schema_version"]: + raise ProtocolError("BAD_VERSION") + ast, end = _decode_ast(encoded, len(magic) + 2, len(encoded), wire, 1, "$", False) + if end != len(encoded): + raise ProtocolError("TRAILING_BYTES") + return ast + + +def _need(data: bytes, offset: int, size: int, limit: int, path: str, bounded: bool = False) -> None: + if size < 0 or offset + size > limit: + raise ProtocolError("LENGTH_MISMATCH" if bounded else "TRUNCATED", path) + if offset + size > len(data): + raise ProtocolError("TRUNCATED", path) + + +def _decode_ast( + data: bytes, + offset: int, + limit: int, + wire: dict[str, Any], + depth: int, + path: str, + bounded: bool, +) -> tuple[dict[str, Any], int]: + if depth > wire["limits"]["nesting_depth_max"]: + raise ProtocolError("LIMIT_EXCEEDED", path) + _need(data, offset, 9, limit, path, bounded) + code = data[offset] + length = struct.unpack_from(">Q", data, offset + 1)[0] + names = {row["code"]: row["name"] for row in wire["wire_types"]} + if code not in names: + raise ProtocolError("UNKNOWN_TYPE", path) + name = names[code] + if name in {"bytes", "string"} and length > wire["limits"]["string_or_bytes_length_max"]: + raise ProtocolError("LIMIT_EXCEEDED", path) + start = offset + 9 + end = start + length + if end > limit: + raise ProtocolError("LENGTH_MISMATCH" if bounded else "TRUNCATED", path) + if end > len(data): + raise ProtocolError("TRUNCATED", path) + payload = data[start:end] + if name == "bytes": + value: Any = payload.hex() + elif name == "string": + try: + value = payload.decode("utf-8") + except UnicodeDecodeError as exc: + raise ProtocolError("INVALID_UTF8", path) from exc + if "\x00" in value: + raise ProtocolError("NUL_STRING", path) + if unicodedata.normalize("NFC", value) != value: + raise ProtocolError("NON_NFC", path) + elif name == "uint": + if length > 8: + raise ProtocolError("OVERFLOW", path) + if length == 0 or (length > 1 and payload[0] == 0): + raise ProtocolError("NONMINIMAL_UINT", path) + value = str(int.from_bytes(payload, "big")) + elif name == "bool": + if length != 1: + raise ProtocolError("LENGTH_MISMATCH", path) + if payload[0] not in (0, 1): + raise ProtocolError("INVALID_BOOL", path) + value = bool(payload[0]) + elif name == "list": + value = _decode_list(data, start, end, wire, depth, path) + elif name == "map": + value = _decode_map(data, start, end, wire, depth, path) + else: + value = _decode_record(data, start, end, wire, depth, path) + return {name: value}, end + + +def _container_count(data: bytes, start: int, end: int, wire: dict[str, Any], path: str) -> tuple[int, int]: + _need(data, start, 4, end, path) + count = struct.unpack_from(">I", data, start)[0] + if count > wire["limits"]["container_members_max"]: + raise ProtocolError("LIMIT_EXCEEDED", path) + return count, start + 4 + + +def _decode_list( + data: bytes, start: int, end: int, wire: dict[str, Any], depth: int, path: str +) -> list[Any]: + count, offset = _container_count(data, start, end, wire, path) + result = [] + for index in range(count): + child_path = f"{path}[{index}]" + _need(data, offset, 8, end, child_path) + length = struct.unpack_from(">Q", data, offset)[0] + offset += 8 + child_end = offset + length + if child_end > end: + raise ProtocolError("LENGTH_MISMATCH", child_path) + child, consumed = _decode_ast(data, offset, child_end, wire, depth + 1, child_path, True) + if consumed != child_end: + raise ProtocolError("LENGTH_MISMATCH", child_path) + result.append(child) + offset = child_end + if offset != end: + raise ProtocolError("LENGTH_MISMATCH", path) + return result + + +def _decode_map( + data: bytes, start: int, end: int, wire: dict[str, Any], depth: int, path: str +) -> list[Any]: + count, offset = _container_count(data, start, end, wire, path) + result = [] + previous: bytes | None = None + for index in range(count): + key_path = f"{path}[{index}].key" + _need(data, offset, 8, end, key_path) + key_length = struct.unpack_from(">Q", data, offset)[0] + offset += 8 + if key_length > wire["limits"]["string_or_bytes_length_max"]: + raise ProtocolError("LIMIT_EXCEEDED", key_path) + if offset + key_length > end: + raise ProtocolError("LENGTH_MISMATCH", key_path) + raw_key = data[offset : offset + key_length] + offset += key_length + try: + key = raw_key.decode("utf-8") + except UnicodeDecodeError as exc: + raise ProtocolError("INVALID_UTF8", key_path) from exc + if "\x00" in key: + raise ProtocolError("NUL_STRING", key_path) + if unicodedata.normalize("NFC", key) != key: + raise ProtocolError("NON_NFC", key_path) + if previous is not None and raw_key <= previous: + code = "DUPLICATE_MAP_KEY" if raw_key == previous else "MAP_KEY_ORDER" + raise ProtocolError(code, key_path) + previous = raw_key + child_path = f"{path}[{index}]" + _need(data, offset, 8, end, child_path) + value_length = struct.unpack_from(">Q", data, offset)[0] + offset += 8 + child_end = offset + value_length + if child_end > end: + raise ProtocolError("LENGTH_MISMATCH", child_path) + child, consumed = _decode_ast(data, offset, child_end, wire, depth + 1, child_path, True) + if consumed != child_end: + raise ProtocolError("LENGTH_MISMATCH", child_path) + result.append([key, child]) + offset = child_end + if offset != end: + raise ProtocolError("LENGTH_MISMATCH", path) + return result + + +def _decode_record( + data: bytes, start: int, end: int, wire: dict[str, Any], depth: int, path: str +) -> list[Any]: + count, offset = _container_count(data, start, end, wire, path) + result = [] + previous = 0 + for index in range(count): + _need(data, offset, 12, end, path) + tag = struct.unpack_from(">I", data, offset)[0] + length = struct.unpack_from(">Q", data, offset + 4)[0] + offset += 12 + if tag <= previous: + raise ProtocolError("FIELD_ORDER", path + f".{tag}") + previous = tag + child_end = offset + length + if child_end > end: + raise ProtocolError("LENGTH_MISMATCH", path + f".{tag}") + child, consumed = _decode_ast(data, offset, child_end, wire, depth + 1, path + f".{tag}", True) + if consumed != child_end: + raise ProtocolError("LENGTH_MISMATCH", path + f".{tag}") + result.append([tag, child]) + offset = child_end + if offset != end: + raise ProtocolError("LENGTH_MISMATCH", path) + return result + + +def _read_value_file(path: pathlib.Path) -> Any: + return load_json(path) + + +def main(argv: list[str] | None = None) -> int: + default_schema = pathlib.Path(__file__).resolve().parent / "schema" + parser = argparse.ArgumentParser(description=__doc__) + sub = parser.add_subparsers(dest="command", required=True) + + validate = sub.add_parser("validate") + validate.add_argument("--schema-dir", type=pathlib.Path, default=default_schema) + + manifest = sub.add_parser("write-manifest") + manifest.add_argument("--schema-dir", type=pathlib.Path, default=default_schema) + + emit_tables = sub.add_parser("emit-tables") + emit_tables.add_argument("--schema-dir", type=pathlib.Path, default=default_schema) + emit_tables.add_argument("--output", type=pathlib.Path, required=True) + + check = sub.add_parser("check-output") + check.add_argument("--schema-dir", type=pathlib.Path, default=default_schema) + check.add_argument("--output", type=pathlib.Path, required=True) + + schema_digest = sub.add_parser("schema-digest") + schema_digest.add_argument("--schema-dir", type=pathlib.Path, default=default_schema) + + encode_value_parser = sub.add_parser("encode-value") + encode_value_parser.add_argument("--schema-dir", type=pathlib.Path, default=default_schema) + encode_value_parser.add_argument("--json", type=pathlib.Path, required=True) + + encode_record_parser = sub.add_parser("encode-record") + encode_record_parser.add_argument("record") + encode_record_parser.add_argument("--schema-dir", type=pathlib.Path, default=default_schema) + encode_record_parser.add_argument("--json", type=pathlib.Path, required=True) + + digest_parser = sub.add_parser("digest") + digest_parser.add_argument("domain") + digest_parser.add_argument("--schema-dir", type=pathlib.Path, default=default_schema) + digest_parser.add_argument("--json", type=pathlib.Path) + digest_parser.add_argument("--hex") + digest_parser.add_argument("--record") + digest_parser.add_argument("--kind", type=int) + digest_parser.add_argument("--record-schema", type=int, default=1) + + args = parser.parse_args(argv) + try: + if args.command == "write-manifest": + SchemaBundle.from_dir(args.schema_dir, check_manifest=False) + write_schema_manifest(args.schema_dir) + return 0 + if args.command == "emit-tables": + generate_table(args.schema_dir, args.output) + return 0 + if args.command == "check-output": + expected = expected_table(args.schema_dir) + if not args.output.is_file() or args.output.read_bytes() != expected: + raise SchemaError(f"generated output is stale: {args.output}") + return 0 + bundle = SchemaBundle.from_dir(args.schema_dir) + if args.command == "validate": + return 0 + if args.command == "schema-digest": + print(bundle.schema_digest) + return 0 + if args.command == "encode-value": + print(encode_envelope(_read_value_file(args.json), bundle.wire).hex()) + return 0 + if args.command == "encode-record": + print(bundle.encode_record(args.record, _read_value_file(args.json)).hex()) + return 0 + if args.command == "digest": + if args.hex is not None: + value: Any = bytes.fromhex(args.hex) + elif args.json is not None: + value = _read_value_file(args.json) + else: + raise SchemaError("digest requires --hex or --json") + print( + bundle.digest( + args.domain, + value, + record_name=args.record, + kind=args.kind, + schema=args.record_schema, + ).hex() + ) + return 0 + except (SchemaError, ProtocolError, ValueError) as exc: + print(exc, file=sys.stderr) + return 2 + return 2 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/protocol/vectors/digests.json b/protocol/vectors/digests.json new file mode 100644 index 00000000..02c1e221 --- /dev/null +++ b/protocol/vectors/digests.json @@ -0,0 +1,456 @@ +{ + "format": "wwar-v1-digest-vectors", + "version": 1, + "cases": [ + { + "id": "action-key", + "domain": "action-key", + "record": "ActionRecordV1", + "value": { + "schema": 1, + "kind-version": { + "kind": "ww.package", + "version": 1 + }, + "protocols": { + "language": "x", + "compiler": "x", + "export": "x", + "object": "x", + "runtime": "x", + "manifest": 1, + "lock": 1 + }, + "platform-roles": { + "execution-platform": { + "domain": "blob", + "algorithm": "sha256", + "record-kind": 0, + "record-schema": 0, + "digest": "00" + }, + "product-platform": { + "domain": "blob", + "algorithm": "sha256", + "record-kind": 0, + "record-schema": 0, + "digest": "00" + }, + "compiler-output-platform": {}, + "execution-expanded": { + "schema": 1, + "name": "", + "identity": { + "arch": "", + "vendor": "", + "os": "", + "environment": "", + "object-format": "" + }, + "pointers": { + "endian": "little", + "address-spaces": [], + "pointer-widths": {} + }, + "data-layout": { + "integer-widths": {}, + "alignments": {}, + "aggregate-algorithm": "" + }, + "c-abi": { + "c-abi": "", + "data-model": "", + "calling-conventions": {} + }, + "float-variadic-name": { + "float-abi": "", + "variadic-abi": "", + "name-decoration": "" + }, + "cpu": { + "baseline": "", + "required": [], + "forbidden": [], + "atomics": [] + }, + "minimum-platform": {}, + "tls-unwind": { + "tls-models": [], + "default-tls": "", + "unwind-models": [], + "default-unwind": "" + }, + "relocation-code": { + "relocations": [], + "default-relocation": "", + "code-models": [], + "default-code-model": "" + }, + "object-rules": { + "executable": {}, + "shared": {}, + "page": {} + }, + "hosted-policy": { + "hosted": false, + "capabilities": [] + }, + "abi-protocols": { + "object": "x", + "runtime": "x" + } + }, + "product-expanded": { + "schema": 1, + "name": "", + "identity": { + "arch": "", + "vendor": "", + "os": "", + "environment": "", + "object-format": "" + }, + "pointers": { + "endian": "little", + "address-spaces": [], + "pointer-widths": {} + }, + "data-layout": { + "integer-widths": {}, + "alignments": {}, + "aggregate-algorithm": "" + }, + "c-abi": { + "c-abi": "", + "data-model": "", + "calling-conventions": {} + }, + "float-variadic-name": { + "float-abi": "", + "variadic-abi": "", + "name-decoration": "" + }, + "cpu": { + "baseline": "", + "required": [], + "forbidden": [], + "atomics": [] + }, + "minimum-platform": {}, + "tls-unwind": { + "tls-models": [], + "default-tls": "", + "unwind-models": [], + "default-unwind": "" + }, + "relocation-code": { + "relocations": [], + "default-relocation": "", + "code-models": [], + "default-code-model": "" + }, + "object-rules": { + "executable": {}, + "shared": {}, + "page": {} + }, + "hosted-policy": { + "hosted": false, + "capabilities": [] + }, + "abi-protocols": { + "object": "x", + "runtime": "x" + } + }, + "compiler-output-expanded": {} + }, + "selected-tool-closure": { + "toolchain-id": "", + "closure": { + "domain": "blob", + "algorithm": "sha256", + "record-kind": 0, + "record-schema": 0, + "digest": "00" + }, + "compiler-backend": { + "domain": "blob", + "algorithm": "sha256", + "record-kind": 0, + "record-schema": 0, + "digest": "00" + } + }, + "profile": { + "name": "", + "optimization": "0", + "debug": "none", + "assertions": false, + "overflow": "trap", + "panic": "abort", + "sanitizers": [], + "lto": "none", + "relocation": "pic", + "code-model": "", + "tls-default": "", + "strip": "none", + "reproducibility": "required" + }, + "identity": { + "logical-identity": "", + "cwd": "/work" + }, + "argv": [], + "environment": {}, + "inputs": [], + "source-selection": { + "members": [], + "target-tags": [] + }, + "native-link": { + "providers": [], + "link-plan": {}, + "required-provider-slots": [] + }, + "outputs": [], + "sandbox": { + "policy": "", + "version": 1, + "resources": { + "cpu-count": 0, + "memory-bytes": 0, + "output-bytes": 0, + "process-count": 0 + }, + "reproducibility": "required" + } + }, + "wwar_hex": "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", + "digest": "4b683d3ead0e005c406e46859cbe0f6d64bc40c91bcdd8995ba9650a42815b03" + }, + { + "id": "blob", + "domain": "blob", + "input_hex": "0001ff", + "digest": "56bcac444af6b509b29eff68ef44cb6231cbd7e77d8ec12eb782d38984167e7d" + }, + { + "id": "calling-conventions", + "domain": "calling-conventions", + "record": "CallingConventionTableProjectionV1", + "value": { + "c-abi": "", + "data-model": "", + "conventions": {} + }, + "wwar_hex": "5757415200010700000000000000470000000300000001000000000000000902000000000000000000000002000000000000000902000000000000000000000003000000000000000d06000000000000000400000000", + "digest": "8b5d66e3aa94024beb2565cb1cb73f2bf14749ffcd014fbd6aca73267ab5abc4" + }, + { + "id": "export-declaration-abi", + "domain": "export-declaration-abi", + "record": "ExportDeclarationABIProjectionV1", + "value": { + "abi": { + "product-platform": { + "domain": "blob", + "algorithm": "sha256", + "record-kind": 0, + "record-schema": 0, + "digest": "00" + }, + "c-abi": "", + "object-abi": "x", + "runtime-abi": "x" + }, + "package": { + "identity": "", + "name": "" + }, + "kind": "", + "name": "", + "overload": "", + "root": 1, + "type-closure": [], + "foreign": {} + }, + "wwar_hex": "5757415200010700000000000001af000000080000000100000000000000d50700000000000000cc0000000400000001000000000000007b0700000000000000720000000500000001000000000000000a0300000000000000010100000002000000000000000a0300000000000000010100000003000000000000000a0300000000000000010000000004000000000000000a0300000000000000010000000005000000000000000a0100000000000000010000000002000000000000000902000000000000000000000003000000000000000a0200000000000000017800000004000000000000000a0200000000000000017800000002000000000000003707000000000000002e0000000200000001000000000000000902000000000000000000000002000000000000000902000000000000000000000003000000000000000902000000000000000000000004000000000000000902000000000000000000000005000000000000000902000000000000000000000006000000000000000a0300000000000000010100000007000000000000000d0500000000000000040000000000000008000000000000000d07000000000000000400000000", + "digest": "3cfce1b9b144809f4e0464ee70b96b300cb3a9226c1ada2178b7f2d14471bad4" + }, + { + "id": "native-data-layout", + "domain": "native-data-layout", + "record": "NativeDataLayoutProjectionV1", + "value": { + "pointers": { + "endian": "little", + "address-spaces": [], + "pointer-widths": {} + }, + "data-layout": { + "integer-widths": {}, + "alignments": {}, + "aggregate-algorithm": "" + } + }, + "wwar_hex": "5757415200010700000000000000c50000000200000001000000000000005507000000000000004c0000000300000001000000000000000a0300000000000000010100000002000000000000000d0500000000000000040000000000000003000000000000000d0600000000000000040000000000000002000000000000005407000000000000004b0000000300000001000000000000000d0600000000000000040000000000000002000000000000000d06000000000000000400000000000000030000000000000009020000000000000000", + "digest": "799166e4c05167fb46ba27d387e9fa76e5f08bd9ec0dac3867b6735787d54e20" + }, + { + "id": "native-header-contract", + "domain": "native-header-contract", + "record": "NativeHeaderContractProjectionV1", + "value": { + "type-identity": "", + "native-type-digest": "0000000000000000000000000000000000000000000000000000000000000000", + "include-trees": [], + "language": "", + "preprocessing": "none", + "effective-defines": {} + }, + "wwar_hex": "5757415200010700000000000000ab00000006000000010000000000000009020000000000000000000000020000000000000029010000000000000020000000000000000000000000000000000000000000000000000000000000000000000003000000000000000d0500000000000000040000000000000004000000000000000902000000000000000000000005000000000000000a0300000000000000010100000006000000000000000d06000000000000000400000000", + "digest": "7f615d6f9135360fd8828c8501278036f09f7edad77c906ca854fde4419f7d0d" + }, + { + "id": "native-type-contract", + "domain": "native-type-contract", + "record": "NativeTypeContractProjectionV1", + "value": { + "platform": { + "object-format": "", + "object-class": "", + "endian": "little", + "machine-abi": "", + "c-abi": "", + "data-model": "", + "data-layout": "0000000000000000000000000000000000000000000000000000000000000000", + "calling-conventions": "0000000000000000000000000000000000000000000000000000000000000000", + "float-abi": "", + "variadic-abi": "", + "symbol-abi": "", + "object-abi": "x", + "runtime-abi": "" + }, + "kind": "opaque", + "exposure": "opaque", + "root": 1, + "type-closure": [], + "size": 0, + "alignment": 0 + }, + "wwar_hex": "5757415200010700000000000001f7000000070000000100000000000001600700000000000001570000000d00000001000000000000000902000000000000000000000002000000000000000902000000000000000000000003000000000000000a03000000000000000101000000040000000000000009020000000000000000000000050000000000000009020000000000000000000000060000000000000009020000000000000000000000070000000000000029010000000000000020000000000000000000000000000000000000000000000000000000000000000000000008000000000000002901000000000000002000000000000000000000000000000000000000000000000000000000000000000000000900000000000000090200000000000000000000000a00000000000000090200000000000000000000000b00000000000000090200000000000000000000000c000000000000000a020000000000000001780000000d000000000000000902000000000000000000000002000000000000000a0300000000000000010100000003000000000000000a0300000000000000010100000004000000000000000a0300000000000000010100000005000000000000000d0500000000000000040000000000000006000000000000000a0300000000000000010000000007000000000000000a03000000000000000100", + "digest": "13e7e98a44de1e8912df869c576804a3ad08f1b3b336440009cc9e3fa8b0244c" + }, + { + "id": "origin-type-contract", + "domain": "origin-type-contract", + "record": "OriginTypeContractProjectionV1", + "value": { + "language-type-protocol": { + "language": "x", + "type-system": "x" + }, + "abi": { + "product-platform": { + "domain": "blob", + "algorithm": "sha256", + "record-kind": 0, + "record-schema": 0, + "digest": "00" + }, + "c-abi": "", + "object-abi": "x", + "runtime-abi": "x" + }, + "package": "", + "type": "", + "root": 1, + "type-closure": [] + }, + "wwar_hex": "575741520001070000000000000183000000060000000100000000000000390700000000000000300000000200000001000000000000000a0200000000000000017800000002000000000000000a020000000000000001780000000200000000000000d50700000000000000cc0000000400000001000000000000007b0700000000000000720000000500000001000000000000000a0300000000000000010100000002000000000000000a0300000000000000010100000003000000000000000a0300000000000000010000000004000000000000000a0300000000000000010000000005000000000000000a0100000000000000010000000002000000000000000902000000000000000000000003000000000000000a0200000000000000017800000004000000000000000a0200000000000000017800000003000000000000000902000000000000000000000004000000000000000902000000000000000000000005000000000000000a0300000000000000010100000006000000000000000d05000000000000000400000000", + "digest": "ccd0f49b152609f1e88370cb11363d76cceefab7c9960b66fcb71f5d54f7fb65" + }, + { + "id": "public-abi", + "domain": "public-abi", + "record": "PublicABIProjectionV1", + "value": { + "abi": { + "product-platform": { + "domain": "blob", + "algorithm": "sha256", + "record-kind": 0, + "record-schema": 0, + "digest": "00" + }, + "c-abi": "", + "object-abi": "x", + "runtime-abi": "x" + }, + "package": { + "identity": "", + "name": "" + }, + "origin-types": [], + "declarations": [], + "initialization": { + "init-symbols": [], + "foreign-providers": [], + "abi-facts": {} + } + }, + "wwar_hex": "5757415200010700000000000001be000000050000000100000000000000d50700000000000000cc0000000400000001000000000000007b0700000000000000720000000500000001000000000000000a0300000000000000010100000002000000000000000a0300000000000000010100000003000000000000000a0300000000000000010000000004000000000000000a0300000000000000010000000005000000000000000a0100000000000000010000000002000000000000000902000000000000000000000003000000000000000a0200000000000000017800000004000000000000000a0200000000000000017800000002000000000000003707000000000000002e0000000200000001000000000000000902000000000000000000000002000000000000000902000000000000000000000003000000000000000d0500000000000000040000000000000004000000000000000d0500000000000000040000000000000005000000000000005807000000000000004f0000000300000001000000000000000d0500000000000000040000000000000002000000000000000d0500000000000000040000000000000003000000000000000d06000000000000000400000000", + "digest": "c7f74b0fff54dd74fb18bfecc1cd263276e5afce2f6cfc6c3210ce7c144995f6" + }, + { + "id": "public-type", + "domain": "public-type", + "record": "PublicTypeProjectionV1", + "value": { + "language-type-protocol": { + "language": "x", + "type-system": "x" + }, + "package": { + "identity": "", + "name": "" + }, + "origin-types": [], + "type-graph": [], + "declarations": [] + }, + "wwar_hex": "5757415200010700000000000000d7000000050000000100000000000000390700000000000000300000000200000001000000000000000a0200000000000000017800000002000000000000000a0200000000000000017800000002000000000000003707000000000000002e0000000200000001000000000000000902000000000000000000000002000000000000000902000000000000000000000003000000000000000d0500000000000000040000000000000004000000000000000d0500000000000000040000000000000005000000000000000d05000000000000000400000000", + "digest": "042cd4780e2523ef261ea9fd29e2c55b5cf9c3c7be3a25d8d5c8025aa02f21cd" + }, + { + "id": "record", + "domain": "record", + "record": "TreeV1", + "kind": 1, + "schema": 1, + "value": {}, + "wwar_hex": "5757415200010700000000000000330000000200000001000000000000000a0300000000000000010100000002000000000000000d05000000000000000400000000", + "digest": "653a4144fd5c916fc3bf5c1324296a757d5acf735ab888fe1842dcf5a01ca8da" + }, + { + "id": "source-tree", + "domain": "source-tree", + "entries": [ + { + "path": "dir", + "type": "dir", + "executable": false, + "content": "" + }, + { + "path": "dir/file", + "type": "file", + "executable": true, + "content": "3b9c358f36f0a31b6ad3e14f309c7cf198ac9246e8316f9ce543d5b19ac02b80" + } + ], + "digest": "e8f2ab9220693a73ac7ecb88441f3db193cd3b595467042537c61d94916f8978" + } + ] +} diff --git a/protocol/vectors/records.json b/protocol/vectors/records.json new file mode 100644 index 00000000..91b42c34 --- /dev/null +++ b/protocol/vectors/records.json @@ -0,0 +1,873 @@ +{ + "format": "wwar-v1-record-vectors", + "version": 1, + "archived_assignment_sha256": "7b8660b451cc5260e9c7ad8d45da8e62313ff1f9b54259e211ff04b49c38671f", + "assignment_sha256": "eb9397b996853d7f7b1b6bcaf6859ebbf076e5eb1dd9308ee53c7afae1314357", + "coverage": { + "scalar_types": 44, + "path_classes": 10, + "records": 165, + "fields": 809, + "encoded_defaults": 363, + "enums": 41, + "enum_values": 202, + "unions": 3, + "union_arms": 35, + "record_kinds": 22, + "artifact_mappings": 15, + "wrappers": 4 + }, + "cases": [ + { + "id": "tree.encoded-defaults", + "record": "TreeV1", + "value": {}, + "wwar_hex": "5757415200010700000000000000330000000200000001000000000000000a0300000000000000010100000002000000000000000d05000000000000000400000000", + "decoded": { + "schema": 1, + "entries": [] + }, + "record_id": "653a4144fd5c916fc3bf5c1324296a757d5acf735ab888fe1842dcf5a01ca8da" + }, + { + "id": "typed-digest.blob", + "record": "TypedDigestV1", + "value": { + "domain": "blob", + "algorithm": "sha256", + "record-kind": 0, + "record-schema": 0, + "digest": "0000000000000000000000000000000000000000000000000000000000000000" + }, + "wwar_hex": "5757415200010700000000000000910000000500000001000000000000000a0300000000000000010100000002000000000000000a0300000000000000010100000003000000000000000a0300000000000000010000000004000000000000000a030000000000000001000000000500000000000000290100000000000000200000000000000000000000000000000000000000000000000000000000000000", + "decoded": { + "domain": "blob", + "algorithm": "sha256", + "record-kind": 0, + "record-schema": 0, + "digest": "0000000000000000000000000000000000000000000000000000000000000000" + } + }, + { + "id": "typed-digest.record", + "record": "TypedDigestV1", + "value": { + "domain": "record", + "algorithm": "sha256", + "record-kind": 1, + "record-schema": 1, + "digest": "0000000000000000000000000000000000000000000000000000000000000000" + }, + "wwar_hex": "5757415200010700000000000000910000000500000001000000000000000a0300000000000000010200000002000000000000000a0300000000000000010100000003000000000000000a0300000000000000010100000004000000000000000a030000000000000001010000000500000000000000290100000000000000200000000000000000000000000000000000000000000000000000000000000000", + "decoded": { + "domain": "record", + "algorithm": "sha256", + "record-kind": 1, + "record-schema": 1, + "digest": "0000000000000000000000000000000000000000000000000000000000000000" + } + } + ], + "union_cases": [ + { + "id": "LinkTokenTemplateUnion.object", + "record": "LinkTokenTemplateV1", + "value": { + "kind": "object", + "artifact": { + "namespace": "source", + "owner": "", + "name": "x", + "artifact-kind": "file", + "expected": {}, + "mode": "data" + }, + "provider-slot": "", + "value": "", + "enabled": false, + "validated-path": "", + "runtime-path": "", + "items": [] + }, + "wwar_hex": "57574152000107000000000000013c0000000800000001000000000000000a0300000000000000010100000002000000000000009307000000000000008a0000000600000001000000000000000a0300000000000000010100000002000000000000000902000000000000000000000003000000000000000a0200000000000000017800000004000000000000000a0300000000000000010100000005000000000000000d0700000000000000040000000000000006000000000000000a0300000000000000010100000003000000000000000902000000000000000000000004000000000000000902000000000000000000000005000000000000000a0400000000000000010000000006000000000000000902000000000000000000000007000000000000000902000000000000000000000008000000000000000d05000000000000000400000000" + }, + { + "id": "LinkTokenTemplateUnion.archive", + "record": "LinkTokenTemplateV1", + "value": { + "kind": "archive", + "artifact": { + "namespace": "source", + "owner": "", + "name": "x", + "artifact-kind": "file", + "expected": {}, + "mode": "data" + }, + "provider-slot": "", + "value": "", + "enabled": false, + "validated-path": "", + "runtime-path": "", + "items": [] + }, + "wwar_hex": "57574152000107000000000000013c0000000800000001000000000000000a0300000000000000010200000002000000000000009307000000000000008a0000000600000001000000000000000a0300000000000000010100000002000000000000000902000000000000000000000003000000000000000a0200000000000000017800000004000000000000000a0300000000000000010100000005000000000000000d0700000000000000040000000000000006000000000000000a0300000000000000010100000003000000000000000902000000000000000000000004000000000000000902000000000000000000000005000000000000000a0400000000000000010000000006000000000000000902000000000000000000000007000000000000000902000000000000000000000008000000000000000d05000000000000000400000000" + }, + { + "id": "LinkTokenTemplateUnion.shared", + "record": "LinkTokenTemplateV1", + "value": { + "kind": "shared", + "artifact": { + "namespace": "source", + "owner": "", + "name": "x", + "artifact-kind": "file", + "expected": {}, + "mode": "data" + }, + "provider-slot": "", + "value": "", + "enabled": false, + "validated-path": "", + "runtime-path": "", + "items": [] + }, + "wwar_hex": "57574152000107000000000000013c0000000800000001000000000000000a0300000000000000010300000002000000000000009307000000000000008a0000000600000001000000000000000a0300000000000000010100000002000000000000000902000000000000000000000003000000000000000a0200000000000000017800000004000000000000000a0300000000000000010100000005000000000000000d0700000000000000040000000000000006000000000000000a0300000000000000010100000003000000000000000902000000000000000000000004000000000000000902000000000000000000000005000000000000000a0400000000000000010000000006000000000000000902000000000000000000000007000000000000000902000000000000000000000008000000000000000d05000000000000000400000000" + }, + { + "id": "LinkTokenTemplateUnion.provider", + "record": "LinkTokenTemplateV1", + "value": { + "kind": "provider", + "artifact": {}, + "provider-slot": "x", + "value": "", + "enabled": false, + "validated-path": "", + "runtime-path": "", + "items": [] + }, + "wwar_hex": "5757415200010700000000000000b70000000800000001000000000000000a0300000000000000010400000002000000000000000d0700000000000000040000000000000003000000000000000a0200000000000000017800000004000000000000000902000000000000000000000005000000000000000a0400000000000000010000000006000000000000000902000000000000000000000007000000000000000902000000000000000000000008000000000000000d05000000000000000400000000" + }, + { + "id": "LinkTokenTemplateUnion.group", + "record": "LinkTokenTemplateV1", + "value": { + "kind": "group", + "artifact": {}, + "provider-slot": "", + "value": "", + "enabled": false, + "validated-path": "", + "runtime-path": "", + "items": [ + { + "kind": "object", + "artifact": { + "namespace": "source", + "owner": "", + "name": "x", + "artifact-kind": "file", + "expected": {}, + "mode": "data" + }, + "provider-slot": "", + "value": "", + "enabled": false, + "validated-path": "", + "runtime-path": "", + "items": [] + } + ] + }, + "wwar_hex": "5757415200010700000000000002030000000800000001000000000000000a0300000000000000010500000002000000000000000d0700000000000000040000000000000003000000000000000902000000000000000000000004000000000000000902000000000000000000000005000000000000000a0400000000000000010000000006000000000000000902000000000000000000000007000000000000000902000000000000000000000008000000000000015a05000000000000015100000001000000000000014507000000000000013c0000000800000001000000000000000a0300000000000000010100000002000000000000009307000000000000008a0000000600000001000000000000000a0300000000000000010100000002000000000000000902000000000000000000000003000000000000000a0200000000000000017800000004000000000000000a0300000000000000010100000005000000000000000d0700000000000000040000000000000006000000000000000a0300000000000000010100000003000000000000000902000000000000000000000004000000000000000902000000000000000000000005000000000000000a0400000000000000010000000006000000000000000902000000000000000000000007000000000000000902000000000000000000000008000000000000000d05000000000000000400000000" + }, + { + "id": "LinkTokenTemplateUnion.whole", + "record": "LinkTokenTemplateV1", + "value": { + "kind": "whole", + "artifact": {}, + "provider-slot": "", + "value": "", + "enabled": false, + "validated-path": "", + "runtime-path": "", + "items": [ + { + "kind": "object", + "artifact": { + "namespace": "source", + "owner": "", + "name": "x", + "artifact-kind": "file", + "expected": {}, + "mode": "data" + }, + "provider-slot": "", + "value": "", + "enabled": false, + "validated-path": "", + "runtime-path": "", + "items": [] + } + ] + }, + "wwar_hex": "5757415200010700000000000002030000000800000001000000000000000a0300000000000000010600000002000000000000000d0700000000000000040000000000000003000000000000000902000000000000000000000004000000000000000902000000000000000000000005000000000000000a0400000000000000010000000006000000000000000902000000000000000000000007000000000000000902000000000000000000000008000000000000015a05000000000000015100000001000000000000014507000000000000013c0000000800000001000000000000000a0300000000000000010100000002000000000000009307000000000000008a0000000600000001000000000000000a0300000000000000010100000002000000000000000902000000000000000000000003000000000000000a0200000000000000017800000004000000000000000a0300000000000000010100000005000000000000000d0700000000000000040000000000000006000000000000000a0300000000000000010100000003000000000000000902000000000000000000000004000000000000000902000000000000000000000005000000000000000a0400000000000000010000000006000000000000000902000000000000000000000007000000000000000902000000000000000000000008000000000000000d05000000000000000400000000" + }, + { + "id": "LinkTokenTemplateUnion.as-needed", + "record": "LinkTokenTemplateV1", + "value": { + "kind": "as-needed", + "artifact": {}, + "provider-slot": "", + "value": "", + "enabled": false, + "validated-path": "", + "runtime-path": "", + "items": [ + { + "kind": "object", + "artifact": { + "namespace": "source", + "owner": "", + "name": "x", + "artifact-kind": "file", + "expected": {}, + "mode": "data" + }, + "provider-slot": "", + "value": "", + "enabled": false, + "validated-path": "", + "runtime-path": "", + "items": [] + } + ] + }, + "wwar_hex": "5757415200010700000000000002030000000800000001000000000000000a0300000000000000010700000002000000000000000d0700000000000000040000000000000003000000000000000902000000000000000000000004000000000000000902000000000000000000000005000000000000000a0400000000000000010000000006000000000000000902000000000000000000000007000000000000000902000000000000000000000008000000000000015a05000000000000015100000001000000000000014507000000000000013c0000000800000001000000000000000a0300000000000000010100000002000000000000009307000000000000008a0000000600000001000000000000000a0300000000000000010100000002000000000000000902000000000000000000000003000000000000000a0200000000000000017800000004000000000000000a0300000000000000010100000005000000000000000d0700000000000000040000000000000006000000000000000a0300000000000000010100000003000000000000000902000000000000000000000004000000000000000902000000000000000000000005000000000000000a0400000000000000010000000006000000000000000902000000000000000000000007000000000000000902000000000000000000000008000000000000000d05000000000000000400000000" + }, + { + "id": "LinkTokenTemplateUnion.linker-script", + "record": "LinkTokenTemplateV1", + "value": { + "kind": "linker-script", + "artifact": { + "namespace": "source", + "owner": "", + "name": "x", + "artifact-kind": "file", + "expected": {}, + "mode": "data" + }, + "provider-slot": "", + "value": "", + "enabled": false, + "validated-path": "", + "runtime-path": "", + "items": [] + }, + "wwar_hex": "57574152000107000000000000013c0000000800000001000000000000000a0300000000000000010800000002000000000000009307000000000000008a0000000600000001000000000000000a0300000000000000010100000002000000000000000902000000000000000000000003000000000000000a0200000000000000017800000004000000000000000a0300000000000000010100000005000000000000000d0700000000000000040000000000000006000000000000000a0300000000000000010100000003000000000000000902000000000000000000000004000000000000000902000000000000000000000005000000000000000a0400000000000000010000000006000000000000000902000000000000000000000007000000000000000902000000000000000000000008000000000000000d05000000000000000400000000" + }, + { + "id": "LinkTokenTemplateUnion.version-script", + "record": "LinkTokenTemplateV1", + "value": { + "kind": "version-script", + "artifact": { + "namespace": "source", + "owner": "", + "name": "x", + "artifact-kind": "file", + "expected": {}, + "mode": "data" + }, + "provider-slot": "", + "value": "", + "enabled": false, + "validated-path": "", + "runtime-path": "", + "items": [] + }, + "wwar_hex": "57574152000107000000000000013c0000000800000001000000000000000a0300000000000000010900000002000000000000009307000000000000008a0000000600000001000000000000000a0300000000000000010100000002000000000000000902000000000000000000000003000000000000000a0200000000000000017800000004000000000000000a0300000000000000010100000005000000000000000d0700000000000000040000000000000006000000000000000a0300000000000000010100000003000000000000000902000000000000000000000004000000000000000902000000000000000000000005000000000000000a0400000000000000010000000006000000000000000902000000000000000000000007000000000000000902000000000000000000000008000000000000000d05000000000000000400000000" + }, + { + "id": "LinkTokenTemplateUnion.export-map", + "record": "LinkTokenTemplateV1", + "value": { + "kind": "export-map", + "artifact": { + "namespace": "source", + "owner": "", + "name": "x", + "artifact-kind": "file", + "expected": {}, + "mode": "data" + }, + "provider-slot": "", + "value": "", + "enabled": false, + "validated-path": "", + "runtime-path": "", + "items": [] + }, + "wwar_hex": "57574152000107000000000000013c0000000800000001000000000000000a0300000000000000010a00000002000000000000009307000000000000008a0000000600000001000000000000000a0300000000000000010100000002000000000000000902000000000000000000000003000000000000000a0200000000000000017800000004000000000000000a0300000000000000010100000005000000000000000d0700000000000000040000000000000006000000000000000a0300000000000000010100000003000000000000000902000000000000000000000004000000000000000902000000000000000000000005000000000000000a0400000000000000010000000006000000000000000902000000000000000000000007000000000000000902000000000000000000000008000000000000000d05000000000000000400000000" + }, + { + "id": "LinkTokenTemplateUnion.def-file", + "record": "LinkTokenTemplateV1", + "value": { + "kind": "def-file", + "artifact": { + "namespace": "source", + "owner": "", + "name": "x", + "artifact-kind": "file", + "expected": {}, + "mode": "data" + }, + "provider-slot": "", + "value": "", + "enabled": false, + "validated-path": "", + "runtime-path": "", + "items": [] + }, + "wwar_hex": "57574152000107000000000000013c0000000800000001000000000000000a0300000000000000010b00000002000000000000009307000000000000008a0000000600000001000000000000000a0300000000000000010100000002000000000000000902000000000000000000000003000000000000000a0200000000000000017800000004000000000000000a0300000000000000010100000005000000000000000d0700000000000000040000000000000006000000000000000a0300000000000000010100000003000000000000000902000000000000000000000004000000000000000902000000000000000000000005000000000000000a0400000000000000010000000006000000000000000902000000000000000000000007000000000000000902000000000000000000000008000000000000000d05000000000000000400000000" + }, + { + "id": "LinkTokenTemplateUnion.runtime-search", + "record": "LinkTokenTemplateV1", + "value": { + "kind": "runtime-search", + "artifact": {}, + "provider-slot": "", + "value": "x", + "enabled": false, + "validated-path": "/x", + "runtime-path": "", + "items": [] + }, + "wwar_hex": "5757415200010700000000000000b90000000800000001000000000000000a0300000000000000010c00000002000000000000000d0700000000000000040000000000000003000000000000000902000000000000000000000004000000000000000a0200000000000000017800000005000000000000000a0400000000000000010000000006000000000000000b0200000000000000022f7800000007000000000000000902000000000000000000000008000000000000000d05000000000000000400000000" + }, + { + "id": "LinkTokenTemplateUnion.install-name", + "record": "LinkTokenTemplateV1", + "value": { + "kind": "install-name", + "artifact": {}, + "provider-slot": "", + "value": "x", + "enabled": false, + "validated-path": "", + "runtime-path": "", + "items": [] + }, + "wwar_hex": "5757415200010700000000000000b70000000800000001000000000000000a0300000000000000010d00000002000000000000000d0700000000000000040000000000000003000000000000000902000000000000000000000004000000000000000a0200000000000000017800000005000000000000000a0400000000000000010000000006000000000000000902000000000000000000000007000000000000000902000000000000000000000008000000000000000d05000000000000000400000000" + }, + { + "id": "LinkTokenTemplateUnion.dynamic-loader", + "record": "LinkTokenTemplateV1", + "value": { + "kind": "dynamic-loader", + "artifact": { + "namespace": "source", + "owner": "", + "name": "x", + "artifact-kind": "file", + "expected": {}, + "mode": "data" + }, + "provider-slot": "", + "value": "", + "enabled": false, + "validated-path": "", + "runtime-path": "/x", + "items": [] + }, + "wwar_hex": "57574152000107000000000000013e0000000800000001000000000000000a0300000000000000010e00000002000000000000009307000000000000008a0000000600000001000000000000000a0300000000000000010100000002000000000000000902000000000000000000000003000000000000000a0200000000000000017800000004000000000000000a0300000000000000010100000005000000000000000d0700000000000000040000000000000006000000000000000a0300000000000000010100000003000000000000000902000000000000000000000004000000000000000902000000000000000000000005000000000000000a0400000000000000010000000006000000000000000902000000000000000000000007000000000000000b0200000000000000022f7800000008000000000000000d05000000000000000400000000" + }, + { + "id": "LinkTokenTemplateUnion.entry", + "record": "LinkTokenTemplateV1", + "value": { + "kind": "entry", + "artifact": {}, + "provider-slot": "", + "value": "x", + "enabled": false, + "validated-path": "", + "runtime-path": "", + "items": [] + }, + "wwar_hex": "5757415200010700000000000000b70000000800000001000000000000000a0300000000000000010f00000002000000000000000d0700000000000000040000000000000003000000000000000902000000000000000000000004000000000000000a0200000000000000017800000005000000000000000a0400000000000000010000000006000000000000000902000000000000000000000007000000000000000902000000000000000000000008000000000000000d05000000000000000400000000" + }, + { + "id": "LinkTokenTemplateUnion.retain", + "record": "LinkTokenTemplateV1", + "value": { + "kind": "retain", + "artifact": {}, + "provider-slot": "", + "value": "x", + "enabled": false, + "validated-path": "", + "runtime-path": "", + "items": [] + }, + "wwar_hex": "5757415200010700000000000000b70000000800000001000000000000000a0300000000000000011000000002000000000000000d0700000000000000040000000000000003000000000000000902000000000000000000000004000000000000000a0200000000000000017800000005000000000000000a0400000000000000010000000006000000000000000902000000000000000000000007000000000000000902000000000000000000000008000000000000000d05000000000000000400000000" + }, + { + "id": "LinkTokenTemplateUnion.splice", + "record": "LinkTokenTemplateV1", + "value": { + "kind": "splice", + "artifact": {}, + "provider-slot": "", + "value": "x", + "enabled": false, + "validated-path": "", + "runtime-path": "", + "items": [] + }, + "wwar_hex": "5757415200010700000000000000b70000000800000001000000000000000a0300000000000000011100000002000000000000000d0700000000000000040000000000000003000000000000000902000000000000000000000004000000000000000a0200000000000000017800000005000000000000000a0400000000000000010000000006000000000000000902000000000000000000000007000000000000000902000000000000000000000008000000000000000d05000000000000000400000000" + }, + { + "id": "LinkTokenTemplateUnion.script-slot", + "record": "LinkTokenTemplateV1", + "value": { + "kind": "script-slot", + "artifact": {}, + "provider-slot": "", + "value": "", + "enabled": false, + "validated-path": "", + "runtime-path": "", + "items": [] + }, + "wwar_hex": "5757415200010700000000000000b60000000800000001000000000000000a0300000000000000011200000002000000000000000d0700000000000000040000000000000003000000000000000902000000000000000000000004000000000000000902000000000000000000000005000000000000000a0400000000000000010000000006000000000000000902000000000000000000000007000000000000000902000000000000000000000008000000000000000d05000000000000000400000000" + }, + { + "id": "LinkTokenUnion.object", + "record": "LinkTokenV1", + "value": { + "kind": "object", + "artifact": { + "slot": "", + "artifact-kind": "file" + }, + "provider-slot": "", + "value": "", + "enabled": false, + "validated-path": "", + "runtime-path": "", + "items": [] + }, + "wwar_hex": "5757415200010700000000000000e10000000800000001000000000000000a0300000000000000010100000002000000000000003807000000000000002f0000000200000001000000000000000902000000000000000000000002000000000000000a0300000000000000010100000003000000000000000902000000000000000000000004000000000000000902000000000000000000000005000000000000000a0400000000000000010000000006000000000000000902000000000000000000000007000000000000000902000000000000000000000008000000000000000d05000000000000000400000000" + }, + { + "id": "LinkTokenUnion.archive", + "record": "LinkTokenV1", + "value": { + "kind": "archive", + "artifact": { + "slot": "", + "artifact-kind": "file" + }, + "provider-slot": "", + "value": "", + "enabled": false, + "validated-path": "", + "runtime-path": "", + "items": [] + }, + "wwar_hex": "5757415200010700000000000000e10000000800000001000000000000000a0300000000000000010200000002000000000000003807000000000000002f0000000200000001000000000000000902000000000000000000000002000000000000000a0300000000000000010100000003000000000000000902000000000000000000000004000000000000000902000000000000000000000005000000000000000a0400000000000000010000000006000000000000000902000000000000000000000007000000000000000902000000000000000000000008000000000000000d05000000000000000400000000" + }, + { + "id": "LinkTokenUnion.shared", + "record": "LinkTokenV1", + "value": { + "kind": "shared", + "artifact": { + "slot": "", + "artifact-kind": "file" + }, + "provider-slot": "", + "value": "", + "enabled": false, + "validated-path": "", + "runtime-path": "", + "items": [] + }, + "wwar_hex": "5757415200010700000000000000e10000000800000001000000000000000a0300000000000000010300000002000000000000003807000000000000002f0000000200000001000000000000000902000000000000000000000002000000000000000a0300000000000000010100000003000000000000000902000000000000000000000004000000000000000902000000000000000000000005000000000000000a0400000000000000010000000006000000000000000902000000000000000000000007000000000000000902000000000000000000000008000000000000000d05000000000000000400000000" + }, + { + "id": "LinkTokenUnion.group", + "record": "LinkTokenV1", + "value": { + "kind": "group", + "artifact": {}, + "provider-slot": "", + "value": "", + "enabled": false, + "validated-path": "", + "runtime-path": "", + "items": [ + { + "kind": "object", + "artifact": { + "slot": "", + "artifact-kind": "file" + }, + "provider-slot": "", + "value": "", + "enabled": false, + "validated-path": "", + "runtime-path": "", + "items": [] + } + ] + }, + "wwar_hex": "5757415200010700000000000001a80000000800000001000000000000000a0300000000000000010500000002000000000000000d0700000000000000040000000000000003000000000000000902000000000000000000000004000000000000000902000000000000000000000005000000000000000a040000000000000001000000000600000000000000090200000000000000000000000700000000000000090200000000000000000000000800000000000000ff0500000000000000f60000000100000000000000ea0700000000000000e10000000800000001000000000000000a0300000000000000010100000002000000000000003807000000000000002f0000000200000001000000000000000902000000000000000000000002000000000000000a0300000000000000010100000003000000000000000902000000000000000000000004000000000000000902000000000000000000000005000000000000000a0400000000000000010000000006000000000000000902000000000000000000000007000000000000000902000000000000000000000008000000000000000d05000000000000000400000000" + }, + { + "id": "LinkTokenUnion.whole", + "record": "LinkTokenV1", + "value": { + "kind": "whole", + "artifact": {}, + "provider-slot": "", + "value": "", + "enabled": false, + "validated-path": "", + "runtime-path": "", + "items": [ + { + "kind": "object", + "artifact": { + "slot": "", + "artifact-kind": "file" + }, + "provider-slot": "", + "value": "", + "enabled": false, + "validated-path": "", + "runtime-path": "", + "items": [] + } + ] + }, + "wwar_hex": "5757415200010700000000000001a80000000800000001000000000000000a0300000000000000010600000002000000000000000d0700000000000000040000000000000003000000000000000902000000000000000000000004000000000000000902000000000000000000000005000000000000000a040000000000000001000000000600000000000000090200000000000000000000000700000000000000090200000000000000000000000800000000000000ff0500000000000000f60000000100000000000000ea0700000000000000e10000000800000001000000000000000a0300000000000000010100000002000000000000003807000000000000002f0000000200000001000000000000000902000000000000000000000002000000000000000a0300000000000000010100000003000000000000000902000000000000000000000004000000000000000902000000000000000000000005000000000000000a0400000000000000010000000006000000000000000902000000000000000000000007000000000000000902000000000000000000000008000000000000000d05000000000000000400000000" + }, + { + "id": "LinkTokenUnion.as-needed", + "record": "LinkTokenV1", + "value": { + "kind": "as-needed", + "artifact": {}, + "provider-slot": "", + "value": "", + "enabled": false, + "validated-path": "", + "runtime-path": "", + "items": [ + { + "kind": "object", + "artifact": { + "slot": "", + "artifact-kind": "file" + }, + "provider-slot": "", + "value": "", + "enabled": false, + "validated-path": "", + "runtime-path": "", + "items": [] + } + ] + }, + "wwar_hex": "5757415200010700000000000001a80000000800000001000000000000000a0300000000000000010700000002000000000000000d0700000000000000040000000000000003000000000000000902000000000000000000000004000000000000000902000000000000000000000005000000000000000a040000000000000001000000000600000000000000090200000000000000000000000700000000000000090200000000000000000000000800000000000000ff0500000000000000f60000000100000000000000ea0700000000000000e10000000800000001000000000000000a0300000000000000010100000002000000000000003807000000000000002f0000000200000001000000000000000902000000000000000000000002000000000000000a0300000000000000010100000003000000000000000902000000000000000000000004000000000000000902000000000000000000000005000000000000000a0400000000000000010000000006000000000000000902000000000000000000000007000000000000000902000000000000000000000008000000000000000d05000000000000000400000000" + }, + { + "id": "LinkTokenUnion.linker-script", + "record": "LinkTokenV1", + "value": { + "kind": "linker-script", + "artifact": { + "slot": "", + "artifact-kind": "file" + }, + "provider-slot": "", + "value": "", + "enabled": false, + "validated-path": "", + "runtime-path": "", + "items": [] + }, + "wwar_hex": "5757415200010700000000000000e10000000800000001000000000000000a0300000000000000010800000002000000000000003807000000000000002f0000000200000001000000000000000902000000000000000000000002000000000000000a0300000000000000010100000003000000000000000902000000000000000000000004000000000000000902000000000000000000000005000000000000000a0400000000000000010000000006000000000000000902000000000000000000000007000000000000000902000000000000000000000008000000000000000d05000000000000000400000000" + }, + { + "id": "LinkTokenUnion.version-script", + "record": "LinkTokenV1", + "value": { + "kind": "version-script", + "artifact": { + "slot": "", + "artifact-kind": "file" + }, + "provider-slot": "", + "value": "", + "enabled": false, + "validated-path": "", + "runtime-path": "", + "items": [] + }, + "wwar_hex": "5757415200010700000000000000e10000000800000001000000000000000a0300000000000000010900000002000000000000003807000000000000002f0000000200000001000000000000000902000000000000000000000002000000000000000a0300000000000000010100000003000000000000000902000000000000000000000004000000000000000902000000000000000000000005000000000000000a0400000000000000010000000006000000000000000902000000000000000000000007000000000000000902000000000000000000000008000000000000000d05000000000000000400000000" + }, + { + "id": "LinkTokenUnion.export-map", + "record": "LinkTokenV1", + "value": { + "kind": "export-map", + "artifact": { + "slot": "", + "artifact-kind": "file" + }, + "provider-slot": "", + "value": "", + "enabled": false, + "validated-path": "", + "runtime-path": "", + "items": [] + }, + "wwar_hex": "5757415200010700000000000000e10000000800000001000000000000000a0300000000000000010a00000002000000000000003807000000000000002f0000000200000001000000000000000902000000000000000000000002000000000000000a0300000000000000010100000003000000000000000902000000000000000000000004000000000000000902000000000000000000000005000000000000000a0400000000000000010000000006000000000000000902000000000000000000000007000000000000000902000000000000000000000008000000000000000d05000000000000000400000000" + }, + { + "id": "LinkTokenUnion.def-file", + "record": "LinkTokenV1", + "value": { + "kind": "def-file", + "artifact": { + "slot": "", + "artifact-kind": "file" + }, + "provider-slot": "", + "value": "", + "enabled": false, + "validated-path": "", + "runtime-path": "", + "items": [] + }, + "wwar_hex": "5757415200010700000000000000e10000000800000001000000000000000a0300000000000000010b00000002000000000000003807000000000000002f0000000200000001000000000000000902000000000000000000000002000000000000000a0300000000000000010100000003000000000000000902000000000000000000000004000000000000000902000000000000000000000005000000000000000a0400000000000000010000000006000000000000000902000000000000000000000007000000000000000902000000000000000000000008000000000000000d05000000000000000400000000" + }, + { + "id": "LinkTokenUnion.runtime-search", + "record": "LinkTokenV1", + "value": { + "kind": "runtime-search", + "artifact": {}, + "provider-slot": "", + "value": "x", + "enabled": false, + "validated-path": "/x", + "runtime-path": "", + "items": [] + }, + "wwar_hex": "5757415200010700000000000000b90000000800000001000000000000000a0300000000000000010c00000002000000000000000d0700000000000000040000000000000003000000000000000902000000000000000000000004000000000000000a0200000000000000017800000005000000000000000a0400000000000000010000000006000000000000000b0200000000000000022f7800000007000000000000000902000000000000000000000008000000000000000d05000000000000000400000000" + }, + { + "id": "LinkTokenUnion.install-name", + "record": "LinkTokenV1", + "value": { + "kind": "install-name", + "artifact": {}, + "provider-slot": "", + "value": "x", + "enabled": false, + "validated-path": "", + "runtime-path": "", + "items": [] + }, + "wwar_hex": "5757415200010700000000000000b70000000800000001000000000000000a0300000000000000010d00000002000000000000000d0700000000000000040000000000000003000000000000000902000000000000000000000004000000000000000a0200000000000000017800000005000000000000000a0400000000000000010000000006000000000000000902000000000000000000000007000000000000000902000000000000000000000008000000000000000d05000000000000000400000000" + }, + { + "id": "LinkTokenUnion.dynamic-loader", + "record": "LinkTokenV1", + "value": { + "kind": "dynamic-loader", + "artifact": { + "slot": "", + "artifact-kind": "file" + }, + "provider-slot": "", + "value": "", + "enabled": false, + "validated-path": "", + "runtime-path": "/x", + "items": [] + }, + "wwar_hex": "5757415200010700000000000000e30000000800000001000000000000000a0300000000000000010e00000002000000000000003807000000000000002f0000000200000001000000000000000902000000000000000000000002000000000000000a0300000000000000010100000003000000000000000902000000000000000000000004000000000000000902000000000000000000000005000000000000000a0400000000000000010000000006000000000000000902000000000000000000000007000000000000000b0200000000000000022f7800000008000000000000000d05000000000000000400000000" + }, + { + "id": "LinkTokenUnion.entry", + "record": "LinkTokenV1", + "value": { + "kind": "entry", + "artifact": {}, + "provider-slot": "", + "value": "x", + "enabled": false, + "validated-path": "", + "runtime-path": "", + "items": [] + }, + "wwar_hex": "5757415200010700000000000000b70000000800000001000000000000000a0300000000000000010f00000002000000000000000d0700000000000000040000000000000003000000000000000902000000000000000000000004000000000000000a0200000000000000017800000005000000000000000a0400000000000000010000000006000000000000000902000000000000000000000007000000000000000902000000000000000000000008000000000000000d05000000000000000400000000" + }, + { + "id": "LinkTokenUnion.retain", + "record": "LinkTokenV1", + "value": { + "kind": "retain", + "artifact": {}, + "provider-slot": "", + "value": "x", + "enabled": false, + "validated-path": "", + "runtime-path": "", + "items": [] + }, + "wwar_hex": "5757415200010700000000000000b70000000800000001000000000000000a0300000000000000011000000002000000000000000d0700000000000000040000000000000003000000000000000902000000000000000000000004000000000000000a0200000000000000017800000005000000000000000a0400000000000000010000000006000000000000000902000000000000000000000007000000000000000902000000000000000000000008000000000000000d05000000000000000400000000" + }, + { + "id": "TypedDigestUnion.blob", + "record": "TypedDigestV1", + "value": { + "domain": "blob", + "algorithm": "sha256", + "record-kind": 0, + "record-schema": 0, + "digest": "00" + }, + "wwar_hex": "5757415200010700000000000000720000000500000001000000000000000a0300000000000000010100000002000000000000000a0300000000000000010100000003000000000000000a0300000000000000010000000004000000000000000a0300000000000000010000000005000000000000000a01000000000000000100" + }, + { + "id": "TypedDigestUnion.record", + "record": "TypedDigestV1", + "value": { + "domain": "record", + "algorithm": "sha256", + "record-kind": 1, + "record-schema": 1, + "digest": "00" + }, + "wwar_hex": "5757415200010700000000000000720000000500000001000000000000000a0300000000000000010200000002000000000000000a0300000000000000010100000003000000000000000a0300000000000000010100000004000000000000000a0300000000000000010100000005000000000000000a01000000000000000100" + } + ], + "wrapper_cases": [ + { + "id": "wwe.magic-and-body", + "wrapper": ".wwe", + "value": { + "schema": 1, + "reader-capabilities": [], + "language-type-protocol": { + "language": "x", + "type-system": "x" + }, + "abi": { + "product-platform": { + "domain": "blob", + "algorithm": "sha256", + "record-kind": 0, + "record-schema": 0, + "digest": "00" + }, + "c-abi": "", + "object-abi": "x", + "runtime-abi": "x" + }, + "package": { + "identity": "", + "name": "" + }, + "origin-types": [], + "type-graph": [], + "declarations": [], + "public-init-abi": { + "init-symbols": [], + "foreign-providers": [], + "abi-facts": {} + }, + "public-type-digest": "0000000000000000000000000000000000000000000000000000000000000000", + "public-abi-digest": "0000000000000000000000000000000000000000000000000000000000000000" + }, + "bytes_hex": "57574558000000015757415200010700000000000002b50000000b00000001000000000000000a0300000000000000010100000002000000000000000d050000000000000004000000000000000300000000000000390700000000000000300000000200000001000000000000000a0200000000000000017800000002000000000000000a020000000000000001780000000400000000000000d50700000000000000cc0000000400000001000000000000007b0700000000000000720000000500000001000000000000000a0300000000000000010100000002000000000000000a0300000000000000010100000003000000000000000a0300000000000000010000000004000000000000000a0300000000000000010000000005000000000000000a0100000000000000010000000002000000000000000902000000000000000000000003000000000000000a0200000000000000017800000004000000000000000a0200000000000000017800000005000000000000003707000000000000002e0000000200000001000000000000000902000000000000000000000002000000000000000902000000000000000000000006000000000000000d0500000000000000040000000000000007000000000000000d0500000000000000040000000000000008000000000000000d0500000000000000040000000000000009000000000000005807000000000000004f0000000300000001000000000000000d0500000000000000040000000000000002000000000000000d0500000000000000040000000000000003000000000000000d060000000000000004000000000000000a000000000000002901000000000000002000000000000000000000000000000000000000000000000000000000000000000000000b00000000000000290100000000000000200000000000000000000000000000000000000000000000000000000000000000" + } + ], + "invalid_cases": [ + { + "id": "kind-substitution", + "operation": "record-id", + "record": "TreeV1", + "kind": 2, + "schema": 1, + "value": {}, + "error": { + "code": "KIND_SUBSTITUTION", + "path": "$.kind" + } + }, + { + "id": "missing-field", + "operation": "decode-record", + "record": "TreeV1", + "input_hex": "57574152000107000000000000001a0000000100000001000000000000000a03000000000000000101", + "error": { + "code": "MISSING_FIELD", + "path": "$.entries" + } + }, + { + "id": "unknown-field", + "operation": "decode-record", + "record": "TreeV1", + "input_hex": "5757415200010700000000000000490000000300000001000000000000000a0300000000000000010100000002000000000000000d0500000000000000040000000000000003000000000000000a04000000000000000100", + "error": { + "code": "UNKNOWN_FIELD", + "path": "$.3" + } + }, + { + "id": "unknown-enum", + "operation": "decode-record", + "record": "TypedDigestV1", + "input_hex": "5757415200010700000000000000910000000500000001000000000000000a0300000000000000016300000002000000000000000a0300000000000000010100000003000000000000000a0300000000000000010000000004000000000000000a030000000000000001000000000500000000000000290100000000000000200000000000000000000000000000000000000000000000000000000000000000", + "error": { + "code": "UNKNOWN_ENUM", + "path": "$.domain" + } + }, + { + "id": "wwe-bad-magic", + "operation": "decode-wrapper", + "wrapper": ".wwe", + "input_hex": "58574558000000015757415200010700000000000002b50000000b00000001000000000000000a0300000000000000010100000002000000000000000d050000000000000004000000000000000300000000000000390700000000000000300000000200000001000000000000000a0200000000000000017800000002000000000000000a020000000000000001780000000400000000000000d50700000000000000cc0000000400000001000000000000007b0700000000000000720000000500000001000000000000000a0300000000000000010100000002000000000000000a0300000000000000010100000003000000000000000a0300000000000000010000000004000000000000000a0300000000000000010000000005000000000000000a0100000000000000010000000002000000000000000902000000000000000000000003000000000000000a0200000000000000017800000004000000000000000a0200000000000000017800000005000000000000003707000000000000002e0000000200000001000000000000000902000000000000000000000002000000000000000902000000000000000000000006000000000000000d0500000000000000040000000000000007000000000000000d0500000000000000040000000000000008000000000000000d0500000000000000040000000000000009000000000000005807000000000000004f0000000300000001000000000000000d0500000000000000040000000000000002000000000000000d0500000000000000040000000000000003000000000000000d060000000000000004000000000000000a000000000000002901000000000000002000000000000000000000000000000000000000000000000000000000000000000000000b00000000000000290100000000000000200000000000000000000000000000000000000000000000000000000000000000", + "error": { + "code": "BAD_MAGIC", + "path": "$" + } + }, + { + "id": "wwe-trailing", + "operation": "decode-wrapper", + "wrapper": ".wwe", + "input_hex": "57574558000000015757415200010700000000000002b50000000b00000001000000000000000a0300000000000000010100000002000000000000000d050000000000000004000000000000000300000000000000390700000000000000300000000200000001000000000000000a0200000000000000017800000002000000000000000a020000000000000001780000000400000000000000d50700000000000000cc0000000400000001000000000000007b0700000000000000720000000500000001000000000000000a0300000000000000010100000002000000000000000a0300000000000000010100000003000000000000000a0300000000000000010000000004000000000000000a0300000000000000010000000005000000000000000a0100000000000000010000000002000000000000000902000000000000000000000003000000000000000a0200000000000000017800000004000000000000000a0200000000000000017800000005000000000000003707000000000000002e0000000200000001000000000000000902000000000000000000000002000000000000000902000000000000000000000006000000000000000d0500000000000000040000000000000007000000000000000d0500000000000000040000000000000008000000000000000d0500000000000000040000000000000009000000000000005807000000000000004f0000000300000001000000000000000d0500000000000000040000000000000002000000000000000d0500000000000000040000000000000003000000000000000d060000000000000004000000000000000a000000000000002901000000000000002000000000000000000000000000000000000000000000000000000000000000000000000b0000000000000029010000000000000020000000000000000000000000000000000000000000000000000000000000000000", + "error": { + "code": "TRAILING_BYTES", + "path": "$" + } + } + ] +} diff --git a/protocol/vectors/wire-invalid.json b/protocol/vectors/wire-invalid.json new file mode 100644 index 00000000..d93c4eca --- /dev/null +++ b/protocol/vectors/wire-invalid.json @@ -0,0 +1,222 @@ +{ + "format": "wwar-v1-wire-invalid", + "version": 1, + "cases": [ + { + "id": "bad-magic", + "input_hex": "58574152000107000000000000000400000000", + "error": { + "code": "BAD_MAGIC", + "path": "$" + } + }, + { + "id": "bad-version", + "input_hex": "57574152000207000000000000000400000000", + "error": { + "code": "BAD_VERSION", + "path": "$" + } + }, + { + "id": "truncated-magic", + "input_hex": "5757", + "error": { + "code": "TRUNCATED", + "path": "$" + } + }, + { + "id": "truncated-version", + "input_hex": "5757415200", + "error": { + "code": "TRUNCATED", + "path": "$" + } + }, + { + "id": "truncated-value-header", + "input_hex": "5757415200010100", + "error": { + "code": "TRUNCATED", + "path": "$" + } + }, + { + "id": "bytes-limit-before-truncation", + "input_hex": "575741520001010000000080000000", + "error": { + "code": "LIMIT_EXCEEDED", + "path": "$" + } + }, + { + "id": "bytes-truncated", + "input_hex": "575741520001010000000000000001", + "error": { + "code": "TRUNCATED", + "path": "$" + } + }, + { + "id": "bool-truncated-before-length", + "input_hex": "575741520001040000000000000002", + "error": { + "code": "TRUNCATED", + "path": "$" + } + }, + { + "id": "bool-length-mismatch", + "input_hex": "5757415200010400000000000000020000", + "error": { + "code": "LENGTH_MISMATCH", + "path": "$" + } + }, + { + "id": "bool-invalid", + "input_hex": "57574152000104000000000000000102", + "error": { + "code": "INVALID_BOOL", + "path": "$" + } + }, + { + "id": "uint-empty", + "input_hex": "575741520001030000000000000000", + "error": { + "code": "NONMINIMAL_UINT", + "path": "$" + } + }, + { + "id": "uint-nonminimal", + "input_hex": "5757415200010300000000000000020001", + "error": { + "code": "NONMINIMAL_UINT", + "path": "$" + } + }, + { + "id": "uint-overflow", + "input_hex": "575741520001030000000000000009010000000000000000", + "error": { + "code": "OVERFLOW", + "path": "$" + } + }, + { + "id": "string-invalid-utf8", + "input_hex": "575741520001020000000000000001ff", + "error": { + "code": "INVALID_UTF8", + "path": "$" + } + }, + { + "id": "string-nul", + "input_hex": "57574152000102000000000000000100", + "error": { + "code": "NUL_STRING", + "path": "$" + } + }, + { + "id": "string-non-nfc", + "input_hex": "57574152000102000000000000000365cc81", + "error": { + "code": "NON_NFC", + "path": "$" + } + }, + { + "id": "list-count-limit", + "input_hex": "57574152000105000000000000000401000000", + "error": { + "code": "LIMIT_EXCEEDED", + "path": "$" + } + }, + { + "id": "list-truncated-member", + "input_hex": "57574152000105000000000000000400000001", + "error": { + "code": "TRUNCATED", + "path": "$[0]" + } + }, + { + "id": "list-child-length-mismatch", + "input_hex": "57574152000105000000000000000c00000001000000000000000a", + "error": { + "code": "LENGTH_MISMATCH", + "path": "$[0]" + } + }, + { + "id": "map-duplicate", + "input_hex": "57574152000106000000000000003a00000002000000000000000161000000000000000a04000000000000000100000000000000000161000000000000000a04000000000000000100", + "error": { + "code": "DUPLICATE_MAP_KEY", + "path": "$[1].key" + } + }, + { + "id": "map-order", + "input_hex": "57574152000106000000000000003a00000002000000000000000162000000000000000a04000000000000000100000000000000000161000000000000000a04000000000000000101", + "error": { + "code": "MAP_KEY_ORDER", + "path": "$[1].key" + } + }, + { + "id": "record-duplicate", + "input_hex": "5757415200010700000000000000300000000200000001000000000000000a0400000000000000010000000001000000000000000a04000000000000000100", + "error": { + "code": "FIELD_ORDER", + "path": "$.1" + } + }, + { + "id": "record-order", + "input_hex": "5757415200010700000000000000300000000200000002000000000000000a0400000000000000010000000001000000000000000a04000000000000000100", + "error": { + "code": "FIELD_ORDER", + "path": "$.1" + } + }, + { + "id": "record-zero-tag", + "input_hex": "57574152000107000000000000001a0000000100000000000000000000000a04000000000000000100", + "error": { + "code": "FIELD_ORDER", + "path": "$.0" + } + }, + { + "id": "unknown-type", + "input_hex": "575741520001080000000000000000", + "error": { + "code": "UNKNOWN_TYPE", + "path": "$" + } + }, + { + "id": "trailing", + "input_hex": "5757415200010700000000000000040000000000", + "error": { + "code": "TRAILING_BYTES", + "path": "$" + } + }, + { + "id": "nesting-limit", + "input_hex": "57574152000105000000000000055600000001000000000000054a05000000000000054100000001000000000000053505000000000000052c00000001000000000000052005000000000000051700000001000000000000050b0500000000000005020000000100000000000004f60500000000000004ed0000000100000000000004e10500000000000004d80000000100000000000004cc0500000000000004c30000000100000000000004b70500000000000004ae0000000100000000000004a205000000000000049900000001000000000000048d05000000000000048400000001000000000000047805000000000000046f00000001000000000000046305000000000000045a00000001000000000000044e05000000000000044500000001000000000000043905000000000000043000000001000000000000042405000000000000041b00000001000000000000040f0500000000000004060000000100000000000003fa0500000000000003f10000000100000000000003e50500000000000003dc0000000100000000000003d00500000000000003c70000000100000000000003bb0500000000000003b20000000100000000000003a605000000000000039d00000001000000000000039105000000000000038800000001000000000000037c05000000000000037300000001000000000000036705000000000000035e00000001000000000000035205000000000000034900000001000000000000033d05000000000000033400000001000000000000032805000000000000031f00000001000000000000031305000000000000030a0000000100000000000002fe0500000000000002f50000000100000000000002e90500000000000002e00000000100000000000002d40500000000000002cb0000000100000000000002bf0500000000000002b60000000100000000000002aa0500000000000002a100000001000000000000029505000000000000028c00000001000000000000028005000000000000027700000001000000000000026b05000000000000026200000001000000000000025605000000000000024d00000001000000000000024105000000000000023800000001000000000000022c05000000000000022300000001000000000000021705000000000000020e0000000100000000000002020500000000000001f90000000100000000000001ed0500000000000001e40000000100000000000001d80500000000000001cf0000000100000000000001c30500000000000001ba0000000100000000000001ae0500000000000001a500000001000000000000019905000000000000019000000001000000000000018405000000000000017b00000001000000000000016f05000000000000016600000001000000000000015a05000000000000015100000001000000000000014505000000000000013c00000001000000000000013005000000000000012700000001000000000000011b0500000000000001120000000100000000000001060500000000000000fd0000000100000000000000f10500000000000000e80000000100000000000000dc0500000000000000d30000000100000000000000c70500000000000000be0000000100000000000000b20500000000000000a900000001000000000000009d05000000000000009400000001000000000000008805000000000000007f00000001000000000000007305000000000000006a00000001000000000000005e05000000000000005500000001000000000000004905000000000000004000000001000000000000003405000000000000002b00000001000000000000001f05000000000000001600000001000000000000000a04000000000000000100", + "error": { + "code": "LIMIT_EXCEEDED", + "path": "$[0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0]" + } + } + ] +} diff --git a/protocol/vectors/wire-valid.json b/protocol/vectors/wire-valid.json new file mode 100644 index 00000000..0ab4412f --- /dev/null +++ b/protocol/vectors/wire-valid.json @@ -0,0 +1,179 @@ +{ + "format": "wwar-v1-wire-valid", + "version": 1, + "cases": [ + { + "id": "bool.false", + "value": { + "bool": false + }, + "wwar_hex": "57574152000104000000000000000100", + "sha256": "a8c3e92d7edeecbc654f8f9390ea3eb12239202daa8b3b722f0712c30d1c8879" + }, + { + "id": "bool.true", + "value": { + "bool": true + }, + "wwar_hex": "57574152000104000000000000000101", + "sha256": "79f3f90ea5b8064498618c46a07327599f7106d675de57fd42d3d8507b768437" + }, + { + "id": "bytes.empty", + "value": { + "bytes": "" + }, + "wwar_hex": "575741520001010000000000000000", + "sha256": "8e009dfe2f881177e492688bb049de22f43d81d986546807c9f772096d9fe37f" + }, + { + "id": "bytes.payload", + "value": { + "bytes": "0001ff" + }, + "wwar_hex": "5757415200010100000000000000030001ff", + "sha256": "02e77171cbbb17f903aba78724c3cbfc14e3935b3de11bb3b430f18d560c9056" + }, + { + "id": "string.empty", + "value": { + "string": "" + }, + "wwar_hex": "575741520001020000000000000000", + "sha256": "c298a28c53cf596d254a78ac97c6c569477ac630abd8062df3f00f0a1122267d" + }, + { + "id": "string.ascii", + "value": { + "string": "WWAR" + }, + "wwar_hex": "57574152000102000000000000000457574152", + "sha256": "fab2562fb19a6baf0ea3ebf9e1b911596b79dee862c813a6f1384fe810073516" + }, + { + "id": "string.nfc", + "value": { + "string": "é" + }, + "wwar_hex": "575741520001020000000000000002c3a9", + "sha256": "9a42f284f8a3c27e4b7066d7a4528906b3c1645c81658744fc3b856191ed3342" + }, + { + "id": "uint.zero", + "value": { + "uint": "0" + }, + "wwar_hex": "57574152000103000000000000000100", + "sha256": "4904edc76c78e73847458c94978a584e464f8c2eb98f00ba35c662d2f1767ed5" + }, + { + "id": "uint.255", + "value": { + "uint": "255" + }, + "wwar_hex": "575741520001030000000000000001ff", + "sha256": "aa7c0cebc79e38b0102278f045375382c727253413ccfa002b70dfe3ed2819d4" + }, + { + "id": "uint.256", + "value": { + "uint": "256" + }, + "wwar_hex": "5757415200010300000000000000020100", + "sha256": "a68e8f2aedacb5259c116110773644f328372f2091043fd0651df87319eb8870" + }, + { + "id": "uint.max", + "value": { + "uint": "18446744073709551615" + }, + "wwar_hex": "575741520001030000000000000008ffffffffffffffff", + "sha256": "1f95d731a7a4889c49e5c8d1f97b44820a345926125c7625d9ef86745f35e260" + }, + { + "id": "list.empty", + "value": { + "list": [] + }, + "wwar_hex": "57574152000105000000000000000400000000", + "sha256": "f211cff02842ce114f6f5ef655593042e1e52531da70fa6df9f8c8eded7b534e" + }, + { + "id": "list.ordered", + "value": { + "list": [ + { + "string": "z" + }, + { + "string": "a" + } + ] + }, + "wwar_hex": "57574152000105000000000000002800000002000000000000000a0200000000000000017a000000000000000a02000000000000000161", + "sha256": "15c65285fe9d9b4c1beb1c20589c6408b54f1d48879a41cc3da12664e28b2439" + }, + { + "id": "map.empty", + "value": { + "map": [] + }, + "wwar_hex": "57574152000106000000000000000400000000", + "sha256": "194b1bb965574f395e9a4c040eec66c4aa3c8691b1b0a000cff5a59de75531c1" + }, + { + "id": "map.sorted", + "value": { + "map": [ + [ + "a", + { + "uint": "1" + } + ], + [ + "é", + { + "uint": "2" + } + ] + ] + }, + "wwar_hex": "57574152000106000000000000003b00000002000000000000000161000000000000000a030000000000000001010000000000000002c3a9000000000000000a03000000000000000102", + "sha256": "41eec75e4b05ca60b6da7abbc00b9820a09c698f86acd426e293ecaddfef883a" + }, + { + "id": "record.empty", + "value": { + "record": [] + }, + "wwar_hex": "57574152000107000000000000000400000000", + "sha256": "138c6acb7f01e91df73cb1d9c3356d18f19d7b8eb8b0a15426bef32e515d0de0" + }, + { + "id": "record.nested", + "value": { + "record": [ + [ + 1, + { + "record": [] + } + ], + [ + 9, + { + "list": [ + { + "bool": true + } + ] + } + ] + ] + }, + "wwar_hex": "5757415200010700000000000000480000000200000001000000000000000d0700000000000000040000000000000009000000000000001f05000000000000001600000001000000000000000a04000000000000000101", + "sha256": "9bf1bfd8d3ba6feb0f1a3093c17e6b22693b09bee1695f3c249a90953a3f210f" + } + ] +}